18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package com.sun.rowset; 27 28 import java.sql.*; 29 import javax.sql.*; 30 import javax.naming.*; 31 import java.io.*; 32 import java.math.*; 33 import java.util.*; 34 35 import javax.sql.rowset.*; 36 37 /** 38 * The standard implementation of the <code>JdbcRowSet</code> interface. See the interface 39 * definition for full behavior and implementation requirements. 40 * 41 * @author Jonathan Bruce, Amit Handa 42 */ 43 44 public class JdbcRowSetImpl extends BaseRowSet implements JdbcRowSet, Joinable { 45 46 /** 47 * The <code>Connection</code> object that is this rowset's 48 * current connection to the database. This field is set 49 * internally when the connection is established. 50 */ 51 private Connection conn; 52 53 /** 54 * The <code>PreparedStatement</code> object that is this rowset's 55 * current command. This field is set internally when the method 56 * <code>execute</code> creates the <code>PreparedStatement</code> 57 * object. 58 */ 59 private PreparedStatement ps; 60 61 /** 62 * The <code>ResultSet</code> object that is this rowset's 63 * current result set. This field is set internally when the method 64 * <code>execute</code> executes the rowset's command and thereby 65 * creates the rowset's <code>ResultSet</code> object. 66 */ 67 private ResultSet rs; 68 69 /** 70 * The <code>RowSetMetaDataImpl</code> object that is constructed when 71 * a <code>ResultSet</code> object is passed to the <code>JdbcRowSet</code> 72 * constructor. This helps in constructing all metadata associated 73 * with the <code>ResultSet</code> object using the setter methods of 74 * <code>RowSetMetaDataImpl</code>. 75 */ 76 private RowSetMetaDataImpl rowsMD; 77 78 /** 79 * The <code>ResultSetMetaData</code> object from which this 80 * <code>RowSetMetaDataImpl</code> is formed and which helps in getting 81 * the metadata information. 82 */ 83 private ResultSetMetaData resMD; 84 85 86 /** 87 * The Vector holding the Match Columns 88 */ 89 private Vector<Integer> iMatchColumns; 90 91 /** 92 * The Vector that will hold the Match Column names. 93 */ 94 private Vector<String> strMatchColumns; 95 96 97 protected transient JdbcRowSetResourceBundle resBundle; 98 99 /** 100 * Constructs a default <code>JdbcRowSet</code> object. 101 * The new instance of <code>JdbcRowSet</code> will serve as a proxy 102 * for the <code>ResultSet</code> object it creates, and by so doing, 103 * it will make it possible to use the result set as a JavaBeans 104 * component. 105 * <P> 106 * The following is true of a default <code>JdbcRowSet</code> instance: 107 * <UL> 108 * <LI>Does not show deleted rows 109 * <LI>Has no time limit for how long a driver may take to 110 * execute the rowset's command 111 * <LI>Has no limit for the number of rows it may contain 112 * <LI>Has no limit for the number of bytes a column may contain 113 * <LI>Has a scrollable cursor and does not show changes 114 * made by others 115 * <LI>Will not see uncommitted data (make "dirty" reads) 116 * <LI>Has escape processing turned on 117 * <LI>Has its connection's type map set to <code>null</code> 118 * <LI>Has an empty <code>Hashtable</code> object for storing any 119 * parameters that are set 120 * </UL> 121 * A newly created <code>JdbcRowSet</code> object must have its 122 * <code>execute</code> method invoked before other public methods 123 * are called on it; otherwise, such method calls will cause an 124 * exception to be thrown. 125 * 126 * @throws SQLException [1] if any of its public methods are called prior 127 * to calling the <code>execute</code> method; [2] if invalid JDBC driver 128 * properties are set or [3] if no connection to a data source exists. 129 */ 130 public JdbcRowSetImpl() { 131 conn = null; 132 ps = null; 133 rs = null; 134 135 try { 136 resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle(); 137 } catch(IOException ioe) { 138 throw new RuntimeException(ioe); 139 } 140 141 142 initParams(); 143 144 // set the defaults 145 146 try { 147 setShowDeleted(false); 200 setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED); 201 } catch(SQLException sqle){ 202 System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.settransactionisolation").toString() + 203 sqle.getLocalizedMessage()); 204 } 205 206 //Instantiating the vector for MatchColumns 207 208 iMatchColumns = new Vector<Integer>(10); 209 for(int i = 0; i < 10 ; i++) { 210 iMatchColumns.add(i,Integer.valueOf(-1)); 211 } 212 213 strMatchColumns = new Vector<String>(10); 214 for(int j = 0; j < 10; j++) { 215 strMatchColumns.add(j,null); 216 } 217 } 218 219 /** 220 * Constructs a default <code>JdbcRowSet</code> object given a 221 * valid <code>Connection</code> object. The new 222 * instance of <code>JdbcRowSet</code> will serve as a proxy for 223 * the <code>ResultSet</code> object it creates, and by so doing, 224 * it will make it possible to use the result set as a JavaBeans 225 * component. 226 * <P> 227 * The following is true of a default <code>JdbcRowSet</code> instance: 228 * <UL> 229 * <LI>Does not show deleted rows 230 * <LI>Has no time limit for how long a driver may take to 231 * execute the rowset's command 232 * <LI>Has no limit for the number of rows it may contain 233 * <LI>Has no limit for the number of bytes a column may contain 234 * <LI>Has a scrollable cursor and does not show changes 235 * made by others 236 * <LI>Will not see uncommitted data (make "dirty" reads) 237 * <LI>Has escape processing turned on 238 * <LI>Has its connection's type map set to <code>null</code> 239 * <LI>Has an empty <code>Hashtable</code> object for storing any 240 * parameters that are set 241 * </UL> 242 * A newly created <code>JdbcRowSet</code> object must have its 243 * <code>execute</code> method invoked before other public methods 244 * are called on it; otherwise, such method calls will cause an 245 * exception to be thrown. 246 * 247 * @throws SQLException [1] if any of its public methods are called prior 248 * to calling the <code>execute</code> method, [2] if invalid JDBC driver 249 * properties are set, or [3] if no connection to a data source exists. 250 */ 251 public JdbcRowSetImpl(Connection con) throws SQLException { 252 253 conn = con; 254 ps = null; 255 rs = null; 256 257 try { 258 resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle(); 259 } catch(IOException ioe) { 260 throw new RuntimeException(ioe); 261 } 262 263 264 initParams(); 265 // set the defaults 266 setShowDeleted(false); 267 setQueryTimeout(0); 268 setMaxRows(0); 272 273 setReadOnly(true); 274 setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED); 275 setEscapeProcessing(true); 276 setTypeMap(null); 277 278 //Instantiating the vector for MatchColumns 279 280 iMatchColumns = new Vector<Integer>(10); 281 for(int i = 0; i < 10 ; i++) { 282 iMatchColumns.add(i,Integer.valueOf(-1)); 283 } 284 285 strMatchColumns = new Vector<String>(10); 286 for(int j = 0; j < 10; j++) { 287 strMatchColumns.add(j,null); 288 } 289 } 290 291 /** 292 * Constructs a default <code>JdbcRowSet</code> object using the 293 * URL, username, and password arguments supplied. The new 294 * instance of <code>JdbcRowSet</code> will serve as a proxy for 295 * the <code>ResultSet</code> object it creates, and by so doing, 296 * it will make it possible to use the result set as a JavaBeans 297 * component. 298 * 299 * <P> 300 * The following is true of a default <code>JdbcRowSet</code> instance: 301 * <UL> 302 * <LI>Does not show deleted rows 303 * <LI>Has no time limit for how long a driver may take to 304 * execute the rowset's command 305 * <LI>Has no limit for the number of rows it may contain 306 * <LI>Has no limit for the number of bytes a column may contain 307 * <LI>Has a scrollable cursor and does not show changes 308 * made by others 309 * <LI>Will not see uncommitted data (make "dirty" reads) 310 * <LI>Has escape processing turned on 311 * <LI>Has its connection's type map set to <code>null</code> 312 * <LI>Has an empty <code>Hashtable</code> object for storing any 313 * parameters that are set 314 * </UL> 315 * 316 * @param url - a JDBC URL for the database to which this <code>JdbcRowSet</code> 317 * object will be connected. The form for a JDBC URL is 318 * <code>jdbc:subprotocol:subname</code>. 319 * @param user - the database user on whose behalf the connection 320 * is being made 321 * @param password - the user's password 322 * 323 * @throws SQLException if a database access error occurs 324 * 325 */ 326 public JdbcRowSetImpl(String url, String user, String password) throws SQLException { 327 conn = null; 328 ps = null; 329 rs = null; 330 331 try { 332 resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle(); 333 } catch(IOException ioe) { 334 throw new RuntimeException(ioe); 335 } 336 337 338 initParams(); 339 340 // Pass the arguments to BaseRowSet 341 // setter methods now. 355 setReadOnly(true); 356 setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED); 357 setEscapeProcessing(true); 358 setTypeMap(null); 359 360 //Instantiating the vector for MatchColumns 361 362 iMatchColumns = new Vector<Integer>(10); 363 for(int i = 0; i < 10 ; i++) { 364 iMatchColumns.add(i,Integer.valueOf(-1)); 365 } 366 367 strMatchColumns = new Vector<String>(10); 368 for(int j = 0; j < 10; j++) { 369 strMatchColumns.add(j,null); 370 } 371 } 372 373 374 /** 375 * Constructs a <code>JdbcRowSet</code> object using the given valid 376 * <code>ResultSet</code> object. The new 377 * instance of <code>JdbcRowSet</code> will serve as a proxy for 378 * the <code>ResultSet</code> object, and by so doing, 379 * it will make it possible to use the result set as a JavaBeans 380 * component. 381 * 382 * <P> 383 * The following is true of a default <code>JdbcRowSet</code> instance: 384 * <UL> 385 * <LI>Does not show deleted rows 386 * <LI>Has no time limit for how long a driver may take to 387 * execute the rowset's command 388 * <LI>Has no limit for the number of rows it may contain 389 * <LI>Has no limit for the number of bytes a column may contain 390 * <LI>Has a scrollable cursor and does not show changes 391 * made by others 392 * <LI>Will not see uncommitted data (make "dirty" reads) 393 * <LI>Has escape processing turned on 394 * <LI>Has its connection's type map set to <code>null</code> 395 * <LI>Has an empty <code>Hashtable</code> object for storing any 396 * parameters that are set 397 * </UL> 398 * 399 * @param res a valid <code>ResultSet</code> object 400 * 401 * @throws SQLException if a database access occurs due to a non 402 * valid ResultSet handle. 403 */ 404 public JdbcRowSetImpl(ResultSet res) throws SQLException { 405 406 // A ResultSet handle encapsulates a connection handle. 407 // But there is no way we can retrieve a Connection handle 408 // from a ResultSet object. 409 // So to avoid any anomalies we keep the conn = null 410 // The passed rs handle will be a wrapper around for 411 // "this" object's all operations. 412 conn = null; 413 414 ps = null; 415 416 rs = res; 417 418 try { 419 resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle(); 443 resMD = rs.getMetaData(); 444 445 rowsMD = new RowSetMetaDataImpl(); 446 447 initMetaData(rowsMD, resMD); 448 449 //Instantiating the vector for MatchColumns 450 451 iMatchColumns = new Vector<Integer>(10); 452 for(int i = 0; i < 10 ; i++) { 453 iMatchColumns.add(i,Integer.valueOf(-1)); 454 } 455 456 strMatchColumns = new Vector<String>(10); 457 for(int j = 0; j < 10; j++) { 458 strMatchColumns.add(j,null); 459 } 460 } 461 462 /** 463 * Initializes the given <code>RowSetMetaData</code> object with the values 464 * in the given <code>ResultSetMetaData</code> object. 465 * 466 * @param md the <code>RowSetMetaData</code> object for this 467 * <code>JdbcRowSetImpl</code> object, which will be set with 468 * values from rsmd 469 * @param rsmd the <code>ResultSetMetaData</code> object from which new 470 * values for md will be read 471 * @throws SQLException if an error occurs 472 */ 473 protected void initMetaData(RowSetMetaData md, ResultSetMetaData rsmd) throws SQLException { 474 int numCols = rsmd.getColumnCount(); 475 476 md.setColumnCount(numCols); 477 for (int col=1; col <= numCols; col++) { 478 md.setAutoIncrement(col, rsmd.isAutoIncrement(col)); 479 md.setCaseSensitive(col, rsmd.isCaseSensitive(col)); 480 md.setCurrency(col, rsmd.isCurrency(col)); 481 md.setNullable(col, rsmd.isNullable(col)); 482 md.setSigned(col, rsmd.isSigned(col)); 483 md.setSearchable(col, rsmd.isSearchable(col)); 484 md.setColumnDisplaySize(col, rsmd.getColumnDisplaySize(col)); 485 md.setColumnLabel(col, rsmd.getColumnLabel(col)); 486 md.setColumnName(col, rsmd.getColumnName(col)); 487 md.setSchemaName(col, rsmd.getSchemaName(col)); 488 md.setPrecision(col, rsmd.getPrecision(col)); 489 md.setScale(col, rsmd.getScale(col)); 494 } 495 } 496 497 498 protected void checkState() throws SQLException { 499 500 // If all the three i.e. conn, ps & rs are 501 // simultaneously null implies we are not connected 502 // to the db, implies undesirable state so throw exception 503 504 if (conn == null && ps == null && rs == null ) { 505 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.invalstate").toString()); 506 } 507 } 508 509 //--------------------------------------------------------------------- 510 // Reading and writing data 511 //--------------------------------------------------------------------- 512 513 /** 514 * Creates the internal <code>ResultSet</code> object for which this 515 * <code>JdbcRowSet</code> object is a wrapper, effectively 516 * making the result set a JavaBeans component. 517 * <P> 518 * Certain properties must have been set before this method is called 519 * so that it can establish a connection to a database and execute the 520 * query that will create the result set. If a <code>DataSource</code> 521 * object will be used to create the connection, properties for the 522 * data source name, user name, and password must be set. If the 523 * <code>DriverManager</code> will be used, the properties for the 524 * URL, user name, and password must be set. In either case, the 525 * property for the command must be set. If the command has placeholder 526 * parameters, those must also be set. This method throws 527 * an exception if the required properties are not set. 528 * <P> 529 * Other properties have default values that may optionally be set 530 * to new values. The <code>execute</code> method will use the value 531 * for the command property to create a <code>PreparedStatement</code> 532 * object and set its properties (escape processing, maximum field 533 * size, maximum number of rows, and query timeout limit) to be those 534 * of this rowset. 535 * 536 * @throws SQLException if (1) a database access error occurs, 537 * (2) any required JDBC properties are not set, or (3) if an 538 * invalid connection exists. 539 */ 540 public void execute() throws SQLException { 541 /* 542 * To execute based on the properties: 543 * i) determine how to get a connection 544 * ii) prepare the statement 545 * iii) set the properties of the statement 546 * iv) parse the params. and set them 547 * v) execute the statement 548 * 549 * During all of this try to tolerate as many errors 550 * as possible, many drivers will not support all of 551 * the properties and will/should throw SQLException 767 ((Integer)param[2]).intValue()); 768 continue; 769 } 770 771 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.paramtype").toString()); 772 773 } else { 774 // common case - this catches all SQL92 types 775 ps.setObject(i + 1, params[i]); 776 continue; 777 } 778 } else { 779 // Try to get all the params to be set here 780 ps.setObject(i + 1, params[i]); 781 782 } 783 } 784 } 785 786 /** 787 * Moves the cursor for this rowset's <code>ResultSet</code> 788 * object down one row from its current position. 789 * A <code>ResultSet</code> cursor is initially positioned 790 * before the first row; the first call to the method 791 * <code>next</code> makes the first row the current row; the 792 * second call makes the second row the current row, and so on. 793 * 794 * <P>If an input stream is open for the current row, a call 795 * to the method <code>next</code> will 796 * implicitly close it. A <code>ResultSet</code> object's 797 * warning chain is cleared when a new row is read. 798 * 799 * @return <code>true</code> if the new current row is valid; 800 * <code>false</code> if there are no more rows 801 * @throws SQLException if a database access error occurs 802 * or this rowset does not currently have a valid connection, 803 * prepared statement, and result set 804 */ 805 public boolean next() throws SQLException { 806 checkState(); 807 808 boolean b = rs.next(); 809 notifyCursorMoved(); 810 return b; 811 } 812 813 /** 814 * Releases this rowset's <code>ResultSet</code> object's database and 815 * JDBC resources immediately instead of waiting for 816 * this to happen when it is automatically closed. 817 * 818 * <P><B>Note:</B> A <code>ResultSet</code> object 819 * is automatically closed by the 820 * <code>Statement</code> object that generated it when 821 * that <code>Statement</code> object is closed, 822 * re-executed, or is used to retrieve the next result from a 823 * sequence of multiple results. A <code>ResultSet</code> object 824 * is also automatically closed when it is garbage collected. 825 * 826 * @throws SQLException if a database access error occurs 827 */ 828 public void close() throws SQLException { 829 if (rs != null) 830 rs.close(); 831 if (ps != null) 832 ps.close(); 833 if (conn != null) 834 conn.close(); 835 } 836 837 /** 838 * Reports whether the last column read from this rowset's 839 * <code>ResultSet</code> object had a value of SQL <code>NULL</code>. 840 * Note that you must first call one of the <code>getXXX</code> methods 841 * on a column to try to read its value and then call 842 * the method <code>wasNull</code> to see if the value read was 843 * SQL <code>NULL</code>. 844 * 845 * @return <code>true</code> if the last column value read was SQL 846 * <code>NULL</code> and <code>false</code> otherwise 847 * @throws SQLException if a database access error occurs 848 * or this rowset does not have a currently valid connection, 849 * prepared statement, and result set 850 */ 851 public boolean wasNull() throws SQLException { 852 checkState(); 853 854 return rs.wasNull(); 855 } 856 857 //====================================================================== 858 // Methods for accessing results by column index 859 //====================================================================== 860 861 /** 862 * Gets the value of the designated column in the current row 863 * of this rowset's <code>ResultSet</code> object as 864 * a <code>String</code>. 865 * 866 * @param columnIndex the first column is 1, the second is 2, and so on 867 * @return the column value; if the value is SQL <code>NULL</code>, the 868 * value returned is <code>null</code> 869 * @throws SQLException if (1) a database access error occurs 870 * or (2) this rowset does not currently have a valid connection, 871 * prepared statement, and result set 872 */ 873 public String getString(int columnIndex) throws SQLException { 874 checkState(); 875 876 return rs.getString(columnIndex); 877 } 878 879 /** 880 * Gets the value of the designated column in the current row 881 * of this rowset's <code>ResultSet</code> object as 882 * a <code>boolean</code>. 883 * 884 * @param columnIndex the first column is 1, the second is 2, and so on 885 * @return the column value; if the value is SQL <code>NULL</code>, the 886 * value returned is <code>false</code> 887 * @throws SQLException if (1) a database access error occurs 888 * or (2) this rowset does not have a currently valid connection, 889 * prepared statement, and result set 890 */ 891 public boolean getBoolean(int columnIndex) throws SQLException { 892 checkState(); 893 894 return rs.getBoolean(columnIndex); 895 } 896 897 /** 898 * Gets the value of the designated column in the current row 899 * of this rowset's <code>ResultSet</code> object as 900 * a <code>byte</code>. 901 * 902 * @param columnIndex the first column is 1, the second is 2, and so on 903 * @return the column value; if the value is SQL <code>NULL</code>, the 904 * value returned is <code>0</code> 905 * @throws SQLException if (1) a database access error occurs 906 * or (2) this rowset does not have a currently valid connection, 907 * prepared statement, and result set 908 */ 909 public byte getByte(int columnIndex) throws SQLException { 910 checkState(); 911 912 return rs.getByte(columnIndex); 913 } 914 915 /** 916 * Gets the value of the designated column in the current row 917 * of this rowset's <code>ResultSet</code> object as 918 * a <code>short</code>. 919 * 920 * @param columnIndex the first column is 1, the second is 2, and so on 921 * @return the column value; if the value is SQL <code>NULL</code>, the 922 * value returned is <code>0</code> 923 * @throws SQLException if (1) a database access error occurs 924 * or (2) this rowset does not have a currently valid connection, 925 * prepared statement, and result set 926 */ 927 public short getShort(int columnIndex) throws SQLException { 928 checkState(); 929 930 return rs.getShort(columnIndex); 931 } 932 933 /** 934 * Gets the value of the designated column in the current row 935 * of this rowset's <code>ResultSet</code> object as 936 * an <code>int</code>. 937 * 938 * @param columnIndex the first column is 1, the second is 2, and so on 939 * @return the column value; if the value is SQL <code>NULL</code>, the 940 * value returned is <code>0</code> 941 * @throws SQLException if (1) a database access error occurs 942 * or (2) this rowset does not have a currently valid connection, 943 * prepared statement, and result set 944 */ 945 public int getInt(int columnIndex) throws SQLException { 946 checkState(); 947 948 return rs.getInt(columnIndex); 949 } 950 951 /** 952 * Gets the value of the designated column in the current row 953 * of this rowset's <code>ResultSet</code> object as 954 * a <code>long</code>. 955 * 956 * @param columnIndex the first column is 1, the second is 2, and so on 957 * @return the column value; if the value is SQL <code>NULL</code>, the 958 * value returned is <code>0</code> 959 * @throws SQLException if (1) a database access error occurs 960 * or (2) this rowset does not have a currently valid connection, 961 * prepared statement, and result set 962 */ 963 public long getLong(int columnIndex) throws SQLException { 964 checkState(); 965 966 return rs.getLong(columnIndex); 967 } 968 969 /** 970 * Gets the value of the designated column in the current row 971 * of this rowset's <code>ResultSet</code> object as 972 * a <code>float</code>. 973 * 974 * @param columnIndex the first column is 1, the second is 2, and so on 975 * @return the column value; if the value is SQL <code>NULL</code>, the 976 * value returned is <code>0</code> 977 * @throws SQLException if (1) a database access error occurs 978 * or (2) this rowset does not have a currently valid connection, 979 * prepared statement, and result set 980 */ 981 public float getFloat(int columnIndex) throws SQLException { 982 checkState(); 983 984 return rs.getFloat(columnIndex); 985 } 986 987 /** 988 * Gets the value of the designated column in the current row 989 * of this rowset's <code>ResultSet</code> object as 990 * a <code>double</code>. 991 * 992 * @param columnIndex the first column is 1, the second is 2, and so on 993 * @return the column value; if the value is SQL <code>NULL</code>, the 994 * value returned is <code>0</code> 995 * @throws SQLException if (1) a database access error occurs 996 * or (2) this rowset does not have a currently valid connection, 997 * prepared statement, and result set 998 */ 999 public double getDouble(int columnIndex) throws SQLException { 1000 checkState(); 1001 1002 return rs.getDouble(columnIndex); 1003 } 1004 1005 /** 1006 * Gets the value of the designated column in the current row 1007 * of this rowset's <code>ResultSet</code> object as 1008 * a <code>java.sql.BigDecimal</code>. 1009 * 1010 * @param columnIndex the first column is 1, the second is 2, and so on 1011 * @param scale the number of digits to the right of the decimal point 1012 * @return the column value; if the value is SQL <code>NULL</code>, the 1013 * value returned is <code>null</code> 1014 * @throws SQLException if (1) database access error occurs 1015 * or (2) this rowset does not have a currently valid connection, 1016 * prepared statement, and result set 1017 * @deprecated 1018 */ 1019 @Deprecated 1020 public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException { 1021 checkState(); 1022 1023 return rs.getBigDecimal(columnIndex, scale); 1024 } 1025 1026 /** 1027 * Gets the value of the designated column in the current row 1028 * of this rowset's <code>ResultSet</code> object as 1029 * a <code>byte</code> array in the Java programming language. 1030 * The bytes represent the raw values returned by the driver. 1031 * 1032 * @param columnIndex the first column is 1, the second is 2, and so on 1033 * @return the column value; if the value is SQL <code>NULL</code>, the 1034 * value returned is <code>null</code> 1035 * @throws SQLException if (1) a database access error occurs 1036 * or (2) this rowset does not have a currently valid connection, 1037 * prepared statement, and result set 1038 */ 1039 public byte[] getBytes(int columnIndex) throws SQLException { 1040 checkState(); 1041 1042 return rs.getBytes(columnIndex); 1043 } 1044 1045 /** 1046 * Gets the value of the designated column in the current row 1047 * of this rowset's <code>ResultSet</code> object as 1048 * a <code>java.sql.Date</code> object in the Java programming language. 1049 * 1050 * @param columnIndex the first column is 1, the second is 2, and so on 1051 * @return the column value; if the value is SQL <code>NULL</code>, the 1052 * value returned is <code>null</code> 1053 * @throws SQLException if (1) a database access error occurs 1054 * or (2) this rowset does not have a currently valid connection, 1055 * prepared statement, and result set 1056 */ 1057 public java.sql.Date getDate(int columnIndex) throws SQLException { 1058 checkState(); 1059 1060 return rs.getDate(columnIndex); 1061 } 1062 1063 /** 1064 * Gets the value of the designated column in the current row 1065 * of this rowset's <code>ResultSet</code> object as 1066 * a <code>java.sql.Time</code> object in the Java programming language. 1067 * 1068 * @param columnIndex the first column is 1, the second is 2, and so on 1069 * @return the column value; if the value is SQL <code>NULL</code>, the 1070 * value returned is <code>null</code> 1071 * @throws SQLException if (1) a database access error occurs 1072 * or (2) this rowset does not have a currently valid connection, 1073 * prepared statement, and result set 1074 */ 1075 public java.sql.Time getTime(int columnIndex) throws SQLException { 1076 checkState(); 1077 1078 return rs.getTime(columnIndex); 1079 } 1080 1081 /** 1082 * Gets the value of the designated column in the current row 1083 * of this rowset's <code>ResultSet</code> object as 1084 * a <code>java.sql.Timestamp</code> object in the Java programming language. 1085 * 1086 * @param columnIndex the first column is 1, the second is 2, and so on 1087 * @return the column value; if the value is SQL <code>NULL</code>, the 1088 * value returned is <code>null</code> 1089 * @throws SQLException if (1) a database access error occurs 1090 * or (2) this rowset does not have a currently valid connection, 1091 * prepared statement, and result set 1092 */ 1093 public java.sql.Timestamp getTimestamp(int columnIndex) throws SQLException { 1094 checkState(); 1095 1096 return rs.getTimestamp(columnIndex); 1097 } 1098 1099 /** 1100 * Gets the value of the designated column in the current row 1101 * of this rowset's <code>ResultSet</code> object as 1102 * a stream of ASCII characters. The value can then be read in chunks from the 1103 * stream. This method is particularly 1104 * suitable for retrieving large <code>LONGVARCHAR</code> values. 1105 * The JDBC driver will 1106 * do any necessary conversion from the database format into ASCII. 1107 * 1108 * <P><B>Note:</B> All the data in the returned stream must be 1109 * read prior to getting the value of any other column. The next 1110 * call to a <code>getXXX</code> method implicitly closes the stream. Also, a 1111 * stream may return <code>0</code> when the method 1112 * <code>InputStream.available</code> 1113 * is called whether there is data available or not. 1114 * 1115 * @param columnIndex the first column is 1, the second is 2, and so on 1116 * @return a Java input stream that delivers the database column value 1117 * as a stream of one-byte ASCII characters; 1118 * if the value is SQL <code>NULL</code>, the 1119 * value returned is <code>null</code> 1120 * @throws SQLException if (1) database access error occurs 1121 * (2) this rowset does not have a currently valid connection, 1122 * prepared statement, and result set 1123 */ 1124 public java.io.InputStream getAsciiStream(int columnIndex) throws SQLException { 1125 checkState(); 1126 1127 return rs.getAsciiStream(columnIndex); 1128 } 1129 1130 /** 1131 * Gets the value of the designated column in the current row 1132 * of this rowset's <code>ResultSet</code> object as 1133 * as a stream of Unicode characters. 1134 * The value can then be read in chunks from the 1135 * stream. This method is particularly 1136 * suitable for retrieving large<code>LONGVARCHAR</code>values. The JDBC driver will 1137 * do any necessary conversion from the database format into Unicode. 1138 * The byte format of the Unicode stream must be Java UTF-8, 1139 * as specified in the Java virtual machine specification. 1140 * 1141 * <P><B>Note:</B> All the data in the returned stream must be 1142 * read prior to getting the value of any other column. The next 1143 * call to a <code>getXXX</code> method implicitly closes the stream. Also, a 1144 * stream may return <code>0</code> when the method 1145 * <code>InputStream.available</code> 1146 * is called whether there is data available or not. 1147 * 1148 * @param columnIndex the first column is 1, the second is 2, and so on 1149 * @return a Java input stream that delivers the database column value 1150 * as a stream in Java UTF-8 byte format; 1151 * if the value is SQL <code>NULL</code>, the value returned is <code>null</code> 1152 * @throws SQLException if (1) a database access error occurs 1153 * or (2) this rowset does not have a currently valid connection, 1154 * prepared statement, and result set 1155 * @deprecated use <code>getCharacterStream</code> in place of 1156 * <code>getUnicodeStream</code> 1157 */ 1158 @Deprecated 1159 public java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException { 1160 checkState(); 1161 1162 return rs.getUnicodeStream(columnIndex); 1163 } 1164 1165 /** 1166 * Gets the value of a column in the current row as a stream of 1167 * the value of the designated column in the current row 1168 * of this rowset's <code>ResultSet</code> object as a binary stream of 1169 * uninterpreted bytes. The value can then be read in chunks from the 1170 * stream. This method is particularly 1171 * suitable for retrieving large <code>LONGVARBINARY</code> values. 1172 * 1173 * <P><B>Note:</B> All the data in the returned stream must be 1174 * read prior to getting the value of any other column. The next 1175 * call to a <code>getXXX</code> method implicitly closes the stream. Also, a 1176 * stream may return <code>0</code> when the method 1177 * <code>InputStream.available</code> 1178 * is called whether there is data available or not. 1179 * 1180 * @param columnIndex the first column is 1, the second is 2, and so on 1181 * @return a Java input stream that delivers the database column value 1182 * as a stream of uninterpreted bytes; 1183 * if the value is SQL <code>NULL</code>, the value returned is <code>null</code> 1184 * @throws SQLException if (1) a database access error occurs 1185 * or (2) this rowset does not have a currently valid connection, 1186 * prepared statement, and result set 1187 */ 1188 public java.io.InputStream getBinaryStream(int columnIndex) throws SQLException { 1189 checkState(); 1190 1191 return rs.getBinaryStream(columnIndex); 1192 } 1193 1194 1195 //====================================================================== 1196 // Methods for accessing results by column name 1197 //====================================================================== 1198 1199 /** 1200 * Gets the value of the designated column in the current row 1201 * of this rowset's <code>ResultSet</code> object as 1202 * a <code>String</code>. 1203 * 1204 * @param columnName the SQL name of the column 1205 * @return the column value; if the value is SQL <code>NULL</code>, the 1206 * value returned is <code>null</code> 1207 * @throws SQLException if (1) a database access error occurs 1208 * or (2) this rowset does not have a currently valid connection, 1209 * prepared statement, and result set 1210 */ 1211 public String getString(String columnName) throws SQLException { 1212 return getString(findColumn(columnName)); 1213 } 1214 1215 /** 1216 * Gets the value of the designated column in the current row 1217 * of this rowset's <code>ResultSet</code> object as 1218 * a <code>boolean</code>. 1219 * 1220 * @param columnName the SQL name of the column 1221 * @return the column value; if the value is SQL <code>NULL</code>, the 1222 * value returned is <code>false</code> 1223 * @throws SQLException if (1) a database access error occurs 1224 * or (2) this rowset does not have a currently valid connection, 1225 * prepared statement, and result set 1226 */ 1227 public boolean getBoolean(String columnName) throws SQLException { 1228 return getBoolean(findColumn(columnName)); 1229 } 1230 1231 /** 1232 * Gets the value of the designated column in the current row 1233 * of this rowset's <code>ResultSet</code> object as 1234 * a <code>byte</code>. 1235 * 1236 * @param columnName the SQL name of the column 1237 * @return the column value; if the value is SQL <code>NULL</code>, the 1238 * value returned is <code>0</code> 1239 * @throws SQLException if (1) a database access error occurs 1240 * or (2) this rowset does not have a currently valid connection, 1241 * prepared statement, and result set 1242 */ 1243 public byte getByte(String columnName) throws SQLException { 1244 return getByte(findColumn(columnName)); 1245 } 1246 1247 /** 1248 * Gets the value of the designated column in the current row 1249 * of this rowset's <code>ResultSet</code> object as 1250 * a <code>short</code>. 1251 * 1252 * @param columnName the SQL name of the column 1253 * @return the column value; if the value is SQL <code>NULL</code>, the 1254 * value returned is <code>0</code> 1255 * @throws SQLException if (1) a database access error occurs 1256 * or (2) this rowset does not have a currently valid connection, 1257 * prepared statement, and result set 1258 */ 1259 public short getShort(String columnName) throws SQLException { 1260 return getShort(findColumn(columnName)); 1261 } 1262 1263 /** 1264 * Gets the value of the designated column in the current row 1265 * of this rowset's <code>ResultSet</code> object as 1266 * an <code>int</code>. 1267 * 1268 * @param columnName the SQL name of the column 1269 * @return the column value; if the value is SQL <code>NULL</code>, the 1270 * value returned is <code>0</code> 1271 * @throws SQLException if (1) a database access error occurs 1272 * or (2) this rowset does not have a currently valid connection, 1273 * prepared statement, and result set 1274 */ 1275 public int getInt(String columnName) throws SQLException { 1276 return getInt(findColumn(columnName)); 1277 } 1278 1279 /** 1280 * Gets the value of the designated column in the current row 1281 * of this rowset's <code>ResultSet</code> object as 1282 * a <code>long</code>. 1283 * 1284 * @param columnName the SQL name of the column 1285 * @return the column value; if the value is SQL <code>NULL</code>, the 1286 * value returned is <code>0</code> 1287 * @throws SQLException if a database access error occurs 1288 * or this rowset does not have a currently valid connection, 1289 * prepared statement, and result set 1290 */ 1291 public long getLong(String columnName) throws SQLException { 1292 return getLong(findColumn(columnName)); 1293 } 1294 1295 /** 1296 * Gets the value of the designated column in the current row 1297 * of this rowset's <code>ResultSet</code> object as 1298 * a <code>float</code>. 1299 * 1300 * @param columnName the SQL name of the column 1301 * @return the column value; if the value is SQL <code>NULL</code>, the 1302 * value returned is <code>0</code> 1303 * @throws SQLException if (1) a database access error occurs 1304 * or (2) this rowset does not have a currently valid connection, 1305 * prepared statement, and result set 1306 */ 1307 public float getFloat(String columnName) throws SQLException { 1308 return getFloat(findColumn(columnName)); 1309 } 1310 1311 /** 1312 * Gets the value of the designated column in the current row 1313 * of this rowset's <code>ResultSet</code> object as 1314 * a <code>double</code>. 1315 * 1316 * @param columnName the SQL name of the column 1317 * @return the column value; if the value is SQL <code>NULL</code>, the 1318 * value returned is <code>0</code> 1319 * @throws SQLException if (1) a database access error occurs 1320 * or (2) this rowset does not have a currently valid connection, 1321 * prepared statement, and result set 1322 */ 1323 public double getDouble(String columnName) throws SQLException { 1324 return getDouble(findColumn(columnName)); 1325 } 1326 1327 /** 1328 * Gets the value of the designated column in the current row 1329 * of this rowset's <code>ResultSet</code> object as 1330 * a <code>java.math.BigDecimal</code>. 1331 * 1332 * @param columnName the SQL name of the column 1333 * @param scale the number of digits to the right of the decimal point 1334 * @return the column value; if the value is SQL <code>NULL</code>, the 1335 * value returned is <code>null</code> 1336 * @throws SQLException if (1) adatabase access error occurs 1337 * or (2) this rowset does not have a currently valid connection, 1338 * prepared statement, and result set 1339 * @deprecated 1340 */ 1341 @Deprecated 1342 public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException { 1343 return getBigDecimal(findColumn(columnName), scale); 1344 } 1345 1346 /** 1347 * Gets the value of the designated column in the current row 1348 * of this rowset's <code>ResultSet</code> object as 1349 * a <code>byte</code> array in the Java programming language. 1350 * The bytes represent the raw values returned by the driver. 1351 * 1352 * @param columnName the SQL name of the column 1353 * @return the column value; if the value is SQL <code>NULL</code>, the 1354 * value returned is <code>null</code> 1355 * @throws SQLException if (1) a database access error occurs 1356 * or (2) this rowset does not have a currently valid connection, 1357 * prepared statement, and result set 1358 */ 1359 public byte[] getBytes(String columnName) throws SQLException { 1360 return getBytes(findColumn(columnName)); 1361 } 1362 1363 /** 1364 * Gets the value of the designated column in the current row 1365 * of this rowset's <code>ResultSet</code> object as 1366 * a <code>java.sql.Date</code> object in the Java programming language. 1367 * 1368 * @param columnName the SQL name of the column 1369 * @return the column value; if the value is SQL <code>NULL</code>, the 1370 * value returned is <code>null</code> 1371 * @throws SQLException if (1) a database access error occurs 1372 * or (2) this rowset does not have a currently valid connection, 1373 * prepared statement, and result set 1374 */ 1375 public java.sql.Date getDate(String columnName) throws SQLException { 1376 return getDate(findColumn(columnName)); 1377 } 1378 1379 /** 1380 * Gets the value of the designated column in the current row 1381 * of this rowset's <code>ResultSet</code> object as 1382 * a <code>java.sql.Time</code> object in the Java programming language. 1383 * 1384 * @param columnName the SQL name of the column 1385 * @return the column value; 1386 * if the value is SQL <code>NULL</code>, 1387 * the value returned is <code>null</code> 1388 * @throws SQLException if (1) a database access error occurs 1389 * or (2) this rowset does not have a currently valid connection, 1390 * prepared statement, and result set 1391 */ 1392 public java.sql.Time getTime(String columnName) throws SQLException { 1393 return getTime(findColumn(columnName)); 1394 } 1395 1396 /** 1397 * Gets the value of the designated column in the current row 1398 * of this rowset's <code>ResultSet</code> object as 1399 * a <code>java.sql.Timestamp</code> object. 1400 * 1401 * @param columnName the SQL name of the column 1402 * @return the column value; if the value is SQL <code>NULL</code>, the 1403 * value returned is <code>null</code> 1404 * @throws SQLException if (1) a database access error occurs 1405 * or (2) this rowset does not have a currently valid connection, 1406 * prepared statement, and result set 1407 */ 1408 public java.sql.Timestamp getTimestamp(String columnName) throws SQLException { 1409 return getTimestamp(findColumn(columnName)); 1410 } 1411 1412 /** 1413 * Gets the value of the designated column in the current row 1414 * of this rowset's <code>ResultSet</code> object as a stream of 1415 * ASCII characters. The value can then be read in chunks from the 1416 * stream. This method is particularly 1417 * suitable for retrieving large <code>LONGVARCHAR</code> values. 1418 * The JDBC driver will 1419 * do any necessary conversion from the database format into ASCII. 1420 * 1421 * <P><B>Note:</B> All the data in the returned stream must be 1422 * read prior to getting the value of any other column. The next 1423 * call to a <code>getXXX</code> method implicitly closes the stream. Also, a 1424 * stream may return <code>0</code> when the method <code>available</code> 1425 * is called whether there is data available or not. 1426 * 1427 * @param columnName the SQL name of the column 1428 * @return a Java input stream that delivers the database column value 1429 * as a stream of one-byte ASCII characters. 1430 * If the value is SQL <code>NULL</code>, 1431 * the value returned is <code>null</code>. 1432 * @throws SQLException if (1) a database access error occurs 1433 * or (2) this rowset does not have a currently valid connection, 1434 * prepared statement, and result set 1435 */ 1436 public java.io.InputStream getAsciiStream(String columnName) throws SQLException { 1437 return getAsciiStream(findColumn(columnName)); 1438 } 1439 1440 /** 1441 * Gets the value of the designated column in the current row 1442 * of this rowset's <code>ResultSet</code> object as a stream of 1443 * Unicode characters. The value can then be read in chunks from the 1444 * stream. This method is particularly 1445 * suitable for retrieving large <code>LONGVARCHAR</code> values. 1446 * The JDBC driver will 1447 * do any necessary conversion from the database format into Unicode. 1448 * The byte format of the Unicode stream must be Java UTF-8, 1449 * as defined in the Java virtual machine specification. 1450 * 1451 * <P><B>Note:</B> All the data in the returned stream must be 1452 * read prior to getting the value of any other column. The next 1453 * call to a <code>getXXX</code> method implicitly closes the stream. Also, a 1454 * stream may return <code>0</code> when the method <code>available</code> 1455 * is called whether there is data available or not. 1456 * 1457 * @param columnName the SQL name of the column 1458 * @return a Java input stream that delivers the database column value 1459 * as a stream of two-byte Unicode characters. 1460 * If the value is SQL <code>NULL</code>, 1461 * the value returned is <code>null</code>. 1462 * @throws SQLException if (1) a database access error occurs 1463 * or (2) this rowset does not have a currently valid connection, 1464 * prepared statement, and result set 1465 * @deprecated 1466 */ 1467 @Deprecated 1468 public java.io.InputStream getUnicodeStream(String columnName) throws SQLException { 1469 return getUnicodeStream(findColumn(columnName)); 1470 } 1471 1472 /** 1473 * Gets the value of the designated column in the current row 1474 * of this rowset's <code>ResultSet</code> object as a stream of uninterpreted 1475 * <code>byte</code>s. 1476 * The value can then be read in chunks from the 1477 * stream. This method is particularly 1478 * suitable for retrieving large <code>LONGVARBINARY</code> 1479 * values. 1480 * 1481 * <P><B>Note:</B> All the data in the returned stream must be 1482 * read prior to getting the value of any other column. The next 1483 * call to a <code>getXXX</code> method implicitly closes the stream. Also, a 1484 * stream may return <code>0</code> when the method <code>available</code> 1485 * is called whether there is data available or not. 1486 * 1487 * @param columnName the SQL name of the column 1488 * @return a Java input stream that delivers the database column value 1489 * as a stream of uninterpreted bytes; 1490 * if the value is SQL <code>NULL</code>, the result is <code>null</code> 1491 * @throws SQLException if (1) a database access error occurs 1492 * or (2) this rowset does not have a currently valid connection, 1493 * prepared statement, and result set 1494 */ 1495 public java.io.InputStream getBinaryStream(String columnName) throws SQLException { 1496 return getBinaryStream(findColumn(columnName)); 1497 } 1498 1499 1500 //===================================================================== 1501 // Advanced features: 1502 //===================================================================== 1503 1504 /** 1505 * Returns the first warning reported by calls on this rowset's 1506 * <code>ResultSet</code> object. 1507 * Subsequent warnings on this rowset's <code>ResultSet</code> object 1508 * will be chained to the <code>SQLWarning</code> object that 1509 * this method returns. 1510 * 1511 * <P>The warning chain is automatically cleared each time a new 1512 * row is read. 1513 * 1514 * <P><B>Note:</B> This warning chain only covers warnings caused 1515 * by <code>ResultSet</code> methods. Any warning caused by 1516 * <code>Statement</code> methods 1517 * (such as reading OUT parameters) will be chained on the 1518 * <code>Statement</code> object. 1519 * 1520 * @return the first <code>SQLWarning</code> object reported or <code>null</code> 1521 * @throws SQLException if (1) a database access error occurs 1522 * or (2) this rowset does not have a currently valid connection, 1523 * prepared statement, and result set 1524 */ 1525 public SQLWarning getWarnings() throws SQLException { 1526 checkState(); 1527 1528 return rs.getWarnings(); 1529 } 1530 1531 /** 1532 * Clears all warnings reported on this rowset's <code>ResultSet</code> object. 1533 * After this method is called, the method <code>getWarnings</code> 1534 * returns <code>null</code> until a new warning is 1535 * reported for this rowset's <code>ResultSet</code> object. 1536 * 1537 * @throws SQLException if (1) a database access error occurs 1538 * or (2) this rowset does not have a currently valid connection, 1539 * prepared statement, and result set 1540 */ 1541 public void clearWarnings() throws SQLException { 1542 checkState(); 1543 1544 rs.clearWarnings(); 1545 } 1546 1547 /** 1548 * Gets the name of the SQL cursor used by this rowset's <code>ResultSet</code> 1549 * object. 1550 * 1551 * <P>In SQL, a result table is retrieved through a cursor that is 1552 * named. The current row of a result set can be updated or deleted 1553 * using a positioned update/delete statement that references the 1554 * cursor name. To insure that the cursor has the proper isolation 1555 * level to support update, the cursor's <code>select</code> statement should be 1556 * of the form 'select for update'. If the 'for update' clause is 1557 * omitted, the positioned updates may fail. 1558 * 1559 * <P>The JDBC API supports this SQL feature by providing the name of the 1560 * SQL cursor used by a <code>ResultSet</code> object. 1561 * The current row of a <code>ResultSet</code> object 1562 * is also the current row of this SQL cursor. 1563 * 1564 * <P><B>Note:</B> If positioned update is not supported, a 1565 * <code>SQLException</code> is thrown. 1566 * 1567 * @return the SQL name for this rowset's <code>ResultSet</code> object's cursor 1568 * @throws SQLException if (1) a database access error occurs 1569 * or (2) xthis rowset does not have a currently valid connection, 1570 * prepared statement, and result set 1571 */ 1572 public String getCursorName() throws SQLException { 1573 checkState(); 1574 1575 return rs.getCursorName(); 1576 } 1577 1578 /** 1579 * Retrieves the number, types and properties of 1580 * this rowset's <code>ResultSet</code> object's columns. 1581 * 1582 * @return the description of this rowset's <code>ResultSet</code> 1583 * object's columns 1584 * @throws SQLException if (1) a database access error occurs 1585 * or (2) this rowset does not have a currently valid connection, 1586 * prepared statement, and result set 1587 */ 1588 public ResultSetMetaData getMetaData() throws SQLException { 1589 1590 checkState(); 1591 1592 // It may be the case that JdbcRowSet might not have been 1593 // initialized with ResultSet handle and may be by PreparedStatement 1594 // internally when we set JdbcRowSet.setCommand(). 1595 // We may require all the basic properties of setEscapeProcessing 1596 // setMaxFieldSize etc. which an application can use before we call 1597 // execute. 1598 try { 1599 checkState(); 1600 } catch(SQLException sqle) { 1601 prepare(); 1602 // will return ResultSetMetaData 1603 return ps.getMetaData(); 1604 } 1605 return rs.getMetaData(); 1606 } 1607 1608 /** 1609 * <p>Gets the value of the designated column in the current row 1610 * of this rowset's <code>ResultSet</code> object as 1611 * an <code>Object</code>. 1612 * 1613 * <p>This method will return the value of the given column as a 1614 * Java object. The type of the Java object will be the default 1615 * Java object type corresponding to the column's SQL type, 1616 * following the mapping for built-in types specified in the JDBC 1617 * specification. 1618 * 1619 * <p>This method may also be used to read datatabase-specific 1620 * abstract data types. 1621 * 1622 * In the JDBC 3.0 API, the behavior of method 1623 * <code>getObject</code> is extended to materialize 1624 * data of SQL user-defined types. When a column contains 1625 * a structured or distinct value, the behavior of this method is as 1626 * if it were a call to: <code>getObject(columnIndex, 1627 * this.getStatement().getConnection().getTypeMap())</code>. 1628 * 1629 * @param columnIndex the first column is 1, the second is 2, and so on 1630 * @return a <code>java.lang.Object</code> holding the column value 1631 * @throws SQLException if (1) a database access error occurs 1632 * or (2) this rowset does not currently have a valid connection, 1633 * prepared statement, and result set 1634 */ 1635 public Object getObject(int columnIndex) throws SQLException { 1636 checkState(); 1637 1638 return rs.getObject(columnIndex); 1639 } 1640 1641 /** 1642 * <p>Gets the value of the designated column in the current row 1643 * of this rowset's <code>ResultSet</code> object as 1644 * an <code>Object</code>. 1645 * 1646 * <p>This method will return the value of the given column as a 1647 * Java object. The type of the Java object will be the default 1648 * Java object type corresponding to the column's SQL type, 1649 * following the mapping for built-in types specified in the JDBC 1650 * specification. 1651 * 1652 * <p>This method may also be used to read datatabase-specific 1653 * abstract data types. 1654 * 1655 * In the JDBC 3.0 API, the behavior of the method 1656 * <code>getObject</code> is extended to materialize 1657 * data of SQL user-defined types. When a column contains 1658 * a structured or distinct value, the behavior of this method is as 1659 * if it were a call to: <code>getObject(columnIndex, 1660 * this.getStatement().getConnection().getTypeMap())</code>. 1661 * 1662 * @param columnName the SQL name of the column 1663 * @return a <code>java.lang.Object</code> holding the column value 1664 * @throws SQLException if (1) a database access error occurs 1665 * or (2) this rowset does not currently have a valid connection, 1666 * prepared statement, and result set 1667 */ 1668 public Object getObject(String columnName) throws SQLException { 1669 return getObject(findColumn(columnName)); 1670 } 1671 1672 //---------------------------------------------------------------- 1673 1674 /** 1675 * Maps the given <code>JdbcRowSetImpl</code> column name to its 1676 * <code>JdbcRowSetImpl</code> column index and reflects this on 1677 * the internal <code>ResultSet</code> object. 1678 * 1679 * @param columnName the name of the column 1680 * @return the column index of the given column name 1681 * @throws SQLException if (1) a database access error occurs 1682 * (2) this rowset does not have a currently valid connection, 1683 * prepared statement, and result set 1684 */ 1685 public int findColumn(String columnName) throws SQLException { 1686 checkState(); 1687 1688 return rs.findColumn(columnName); 1689 } 1690 1691 1692 //--------------------------JDBC 2.0----------------------------------- 1693 1694 //--------------------------------------------------------------------- 1695 // Getters and Setters 1696 //--------------------------------------------------------------------- 1697 1698 /** 1699 * Gets the value of the designated column in the current row 1700 * of this rowset's <code>ResultSet</code> object as a 1701 * <code>java.io.Reader</code> object. 1702 * @return a <code>java.io.Reader</code> object that contains the column 1703 * value; if the value is SQL <code>NULL</code>, the value returned is 1704 * <code>null</code>. 1705 * @param columnIndex the first column is 1, the second is 2, and so on 1706 * 1707 */ 1708 public java.io.Reader getCharacterStream(int columnIndex) throws SQLException { 1709 checkState(); 1710 1711 return rs.getCharacterStream(columnIndex); 1712 } 1713 1714 /** 1715 * Gets the value of the designated column in the current row 1716 * of this rowset's <code>ResultSet</code> object as a 1717 * <code>java.io.Reader</code> object. 1718 * 1719 * @return a <code>java.io.Reader</code> object that contains the column 1720 * value; if the value is SQL <code>NULL</code>, the value returned is 1721 * <code>null</code>. 1722 * @param columnName the name of the column 1723 * @return the value in the specified column as a <code>java.io.Reader</code> 1724 * 1725 */ 1726 public java.io.Reader getCharacterStream(String columnName) throws SQLException { 1727 return getCharacterStream(findColumn(columnName)); 1728 } 1729 1730 /** 1731 * Gets the value of the designated column in the current row 1732 * of this rowset's <code>ResultSet</code> object as a 1733 * <code>java.math.BigDecimal</code> with full precision. 1734 * 1735 * @param columnIndex the first column is 1, the second is 2, and so on 1736 * @return the column value (full precision); 1737 * if the value is SQL <code>NULL</code>, the value returned is 1738 * <code>null</code>. 1739 * @throws SQLException if a database access error occurs 1740 * or this rowset does not currently have a valid 1741 * connection, prepared statement, and result set 1742 */ 1743 public BigDecimal getBigDecimal(int columnIndex) throws SQLException { 1744 checkState(); 1745 1746 return rs.getBigDecimal(columnIndex); 1747 } 1748 1749 /** 1750 * Gets the value of the designated column in the current row 1751 * of this rowset's <code>ResultSet</code> object as a 1752 * <code>java.math.BigDecimal</code> with full precision. 1753 * 1754 * @param columnName the column name 1755 * @return the column value (full precision); 1756 * if the value is SQL <code>NULL</code>, the value returned is 1757 * <code>null</code>. 1758 * @throws SQLException if a database access error occurs 1759 * or this rowset does not currently have a valid 1760 * connection, prepared statement, and result set 1761 */ 1762 public BigDecimal getBigDecimal(String columnName) throws SQLException { 1763 return getBigDecimal(findColumn(columnName)); 1764 } 1765 1766 //--------------------------------------------------------------------- 1767 // Traversal/Positioning 1768 //--------------------------------------------------------------------- 1769 1770 /** 1771 * Indicates whether the cursor is before the first row in 1772 * this rowset's <code>ResultSet</code> object. 1773 * 1774 * @return <code>true</code> if the cursor is before the first row; 1775 * <code>false</code> if the cursor is at any other position or the 1776 * result set contains no rows 1777 * @throws SQLException if a database access error occurs 1778 * or this rowset does not currently have a valid 1779 * connection, prepared statement, and result set 1780 */ 1781 public boolean isBeforeFirst() throws SQLException { 1782 checkState(); 1783 1784 return rs.isBeforeFirst(); 1785 } 1786 1787 /** 1788 * Indicates whether the cursor is after the last row in 1789 * this rowset's <code>ResultSet</code> object. 1790 * 1791 * @return <code>true</code> if the cursor is after the last row; 1792 * <code>false</code> if the cursor is at any other position or the 1793 * result set contains no rows 1794 * @throws SQLException if a database access error occurs 1795 * or this rowset does not currently have a valid 1796 * connection, prepared statement, and result set 1797 */ 1798 public boolean isAfterLast() throws SQLException { 1799 checkState(); 1800 1801 return rs.isAfterLast(); 1802 } 1803 1804 /** 1805 * Indicates whether the cursor is on the first row of 1806 * this rowset's <code>ResultSet</code> object. 1807 * 1808 * @return <code>true</code> if the cursor is on the first row; 1809 * <code>false</code> otherwise 1810 * @throws SQLException if a database access error occurs 1811 * or this rowset does not currently have a valid 1812 * connection, prepared statement, and result set 1813 */ 1814 public boolean isFirst() throws SQLException { 1815 checkState(); 1816 1817 return rs.isFirst(); 1818 } 1819 1820 /** 1821 * Indicates whether the cursor is on the last row of 1822 * this rowset's <code>ResultSet</code> object. 1823 * Note: Calling the method <code>isLast</code> may be expensive 1824 * because the JDBC driver 1825 * might need to fetch ahead one row in order to determine 1826 * whether the current row is the last row in the result set. 1827 * 1828 * @return <code>true</code> if the cursor is on the last row; 1829 * <code>false</code> otherwise 1830 * @throws SQLException if a database access error occurs 1831 * or this rowset does not currently have a valid 1832 * connection, prepared statement, and result set 1833 * 1834 */ 1835 public boolean isLast() throws SQLException { 1836 checkState(); 1837 1838 return rs.isLast(); 1839 } 1840 1841 /** 1842 * Moves the cursor to the front of 1843 * this rowset's <code>ResultSet</code> object, just before the 1844 * first row. This method has no effect if the result set contains no rows. 1845 * 1846 * @throws SQLException if (1) a database access error occurs, 1847 * (2) the result set type is <code>TYPE_FORWARD_ONLY</code>, 1848 * or (3) this rowset does not currently have a valid 1849 * connection, prepared statement, and result set 1850 */ 1851 public void beforeFirst() throws SQLException { 1852 checkState(); 1853 1854 rs.beforeFirst(); 1855 notifyCursorMoved(); 1856 } 1857 1858 /** 1859 * Moves the cursor to the end of 1860 * this rowset's <code>ResultSet</code> object, just after the 1861 * last row. This method has no effect if the result set contains no rows. 1862 * @throws SQLException if (1) a database access error occurs, 1863 * (2) the result set type is <code>TYPE_FORWARD_ONLY</code>, 1864 * or (3) this rowset does not currently have a valid 1865 * connection, prepared statement, and result set 1866 */ 1867 public void afterLast() throws SQLException { 1868 checkState(); 1869 1870 rs.afterLast(); 1871 notifyCursorMoved(); 1872 } 1873 1874 /** 1875 * Moves the cursor to the first row in 1876 * this rowset's <code>ResultSet</code> object. 1877 * 1878 * @return <code>true</code> if the cursor is on a valid row; 1879 * <code>false</code> if there are no rows in the result set 1880 * @throws SQLException if (1) a database access error occurs, 1881 * (2) the result set type is <code>TYPE_FORWARD_ONLY</code>, 1882 * or (3) this rowset does not currently have a valid 1883 * connection, prepared statement, and result set 1884 */ 1885 public boolean first() throws SQLException { 1886 checkState(); 1887 1888 boolean b = rs.first(); 1889 notifyCursorMoved(); 1890 return b; 1891 1892 } 1893 1894 /** 1895 * Moves the cursor to the last row in 1896 * this rowset's <code>ResultSet</code> object. 1897 * 1898 * @return <code>true</code> if the cursor is on a valid row; 1899 * <code>false</code> if there are no rows in the result set 1900 * @throws SQLException if (1) a database access error occurs, 1901 * (2) the result set type is <code>TYPE_FORWARD_ONLY</code>, 1902 * or (3) this rowset does not currently have a valid 1903 * connection, prepared statement, and result set 1904 */ 1905 public boolean last() throws SQLException { 1906 checkState(); 1907 1908 boolean b = rs.last(); 1909 notifyCursorMoved(); 1910 return b; 1911 } 1912 1913 /** 1914 * Retrieves the current row number. The first row is number 1, the 1915 * second is number 2, and so on. 1916 * 1917 * @return the current row number; <code>0</code> if there is no current row 1918 * @throws SQLException if a database access error occurs 1919 * or this rowset does not currently have a valid connection, 1920 * prepared statement, and result set 1921 */ 1922 public int getRow() throws SQLException { 1923 checkState(); 1924 1925 return rs.getRow(); 1926 } 1927 1928 /** 1929 * Moves the cursor to the given row number in 1930 * this rowset's internal <code>ResultSet</code> object. 1931 * 1932 * <p>If the row number is positive, the cursor moves to 1933 * the given row number with respect to the 1934 * beginning of the result set. The first row is row 1, the second 1935 * is row 2, and so on. 1936 * 1937 * <p>If the given row number is negative, the cursor moves to 1938 * an absolute row position with respect to 1939 * the end of the result set. For example, calling the method 1940 * <code>absolute(-1)</code> positions the 1941 * cursor on the last row, calling the method <code>absolute(-2)</code> 1942 * moves the cursor to the next-to-last row, and so on. 1943 * 1944 * <p>An attempt to position the cursor beyond the first/last row in 1945 * the result set leaves the cursor before the first row or after 1946 * the last row. 1947 * 1948 * <p><B>Note:</B> Calling <code>absolute(1)</code> is the same 1949 * as calling <code>first()</code>. Calling <code>absolute(-1)</code> 1950 * is the same as calling <code>last()</code>. 1951 * 1952 * @return <code>true</code> if the cursor is on the result set; 1953 * <code>false</code> otherwise 1954 * @throws SQLException if (1) a database access error occurs, 1955 * (2) the row is <code>0</code>, (3) the result set 1956 * type is <code>TYPE_FORWARD_ONLY</code>, or (4) this 1957 * rowset does not currently have a valid connection, 1958 * prepared statement, and result set 1959 */ 1960 public boolean absolute(int row) throws SQLException { 1961 checkState(); 1962 1963 boolean b = rs.absolute(row); 1964 notifyCursorMoved(); 1965 return b; 1966 } 1967 1968 /** 1969 * Moves the cursor a relative number of rows, either positive or negative. 1970 * Attempting to move beyond the first/last row in the 1971 * result set positions the cursor before/after the 1972 * the first/last row. Calling <code>relative(0)</code> is valid, but does 1973 * not change the cursor position. 1974 * 1975 * <p>Note: Calling the method <code>relative(1)</code> 1976 * is different from calling the method <code>next()</code> 1977 * because is makes sense to call <code>next()</code> when there 1978 * is no current row, 1979 * for example, when the cursor is positioned before the first row 1980 * or after the last row of the result set. 1981 * 1982 * @return <code>true</code> if the cursor is on a row; 1983 * <code>false</code> otherwise 1984 * @throws SQLException if (1) a database access error occurs, 1985 * (2) there is no current row, (3) the result set 1986 * type is <code>TYPE_FORWARD_ONLY</code>, or (4) this 1987 * rowset does not currently have a valid connection, 1988 * prepared statement, and result set 1989 */ 1990 public boolean relative(int rows) throws SQLException { 1991 checkState(); 1992 1993 boolean b = rs.relative(rows); 1994 notifyCursorMoved(); 1995 return b; 1996 } 1997 1998 /** 1999 * Moves the cursor to the previous row in this 2000 * <code>ResultSet</code> object. 2001 * 2002 * <p><B>Note:</B> Calling the method <code>previous()</code> is not the same as 2003 * calling the method <code>relative(-1)</code> because it 2004 * makes sense to call <code>previous()</code> when there is no current row. 2005 * 2006 * @return <code>true</code> if the cursor is on a valid row; 2007 * <code>false</code> if it is off the result set 2008 * @throws SQLException if (1) a database access error occurs, 2009 * (2) the result set type is <code>TYPE_FORWARD_ONLY</code>, 2010 * or (3) this rowset does not currently have a valid 2011 * connection, prepared statement, and result set 2012 */ 2013 public boolean previous() throws SQLException { 2014 checkState(); 2015 2016 boolean b = rs.previous(); 2017 notifyCursorMoved(); 2018 return b; 2019 } 2020 2021 /** 2022 * Gives a hint as to the direction in which the rows in this 2023 * <code>ResultSet</code> object will be processed. 2024 * The initial value is determined by the 2025 * <code>Statement</code> object 2026 * that produced this rowset's <code>ResultSet</code> object. 2027 * The fetch direction may be changed at any time. 2028 * 2029 * @throws SQLException if (1) a database access error occurs, 2030 * (2) the result set type is <code>TYPE_FORWARD_ONLY</code> 2031 * and the fetch direction is not <code>FETCH_FORWARD</code>, 2032 * or (3) this rowset does not currently have a valid 2033 * connection, prepared statement, and result set 2034 * @see java.sql.Statement#setFetchDirection 2035 */ 2036 public void setFetchDirection(int direction) throws SQLException { 2037 checkState(); 2038 2039 rs.setFetchDirection(direction); 2040 } 2041 2042 /** 2043 * Returns the fetch direction for this 2044 * <code>ResultSet</code> object. 2045 * 2046 * @return the current fetch direction for this rowset's 2047 * <code>ResultSet</code> object 2048 * @throws SQLException if a database access error occurs 2049 * or this rowset does not currently have a valid connection, 2050 * prepared statement, and result set 2051 */ 2052 public int getFetchDirection() throws SQLException { 2053 try { 2054 checkState(); 2055 } catch(SQLException sqle) { 2056 super.getFetchDirection(); 2057 } 2058 return rs.getFetchDirection(); 2059 } 2060 2061 /** 2062 * Gives the JDBC driver a hint as to the number of rows that should 2063 * be fetched from the database when more rows are needed for this 2064 * <code>ResultSet</code> object. 2065 * If the fetch size specified is zero, the JDBC driver 2066 * ignores the value and is free to make its own best guess as to what 2067 * the fetch size should be. The default value is set by the 2068 * <code>Statement</code> object 2069 * that created the result set. The fetch size may be changed at any time. 2070 * 2071 * @param rows the number of rows to fetch 2072 * @throws SQLException if (1) a database access error occurs, (2) the 2073 * condition <code>0 <= rows <= this.getMaxRows()</code> is not 2074 * satisfied, or (3) this rowset does not currently have a valid 2075 * connection, prepared statement, and result set 2076 * 2077 */ 2078 public void setFetchSize(int rows) throws SQLException { 2079 checkState(); 2080 2081 rs.setFetchSize(rows); 2082 } 2083 2084 /** 2085 * 2086 * Returns the fetch size for this 2087 * <code>ResultSet</code> object. 2088 * 2089 * @return the current fetch size for this rowset's <code>ResultSet</code> object 2090 * @throws SQLException if a database access error occurs 2091 * or this rowset does not currently have a valid connection, 2092 * prepared statement, and result set 2093 */ 2094 public int getType() throws SQLException { 2095 try { 2096 checkState(); 2097 } catch(SQLException sqle) { 2098 return super.getType(); 2099 } 2100 2101 // If the ResultSet has not been created, then return the default type 2102 // otherwise return the type from the ResultSet. 2103 if(rs == null) { 2104 return super.getType(); 2105 } else { 2106 int rstype = rs.getType(); 2107 return rstype; 2108 } 2109 2110 2111 } 2112 2113 /** 2114 * Returns the concurrency mode of this rowset's <code>ResultSet</code> object. 2115 * The concurrency used is determined by the 2116 * <code>Statement</code> object that created the result set. 2117 * 2118 * @return the concurrency type, either <code>CONCUR_READ_ONLY</code> 2119 * or <code>CONCUR_UPDATABLE</code> 2120 * @throws SQLException if (1) a database access error occurs 2121 * or (2) this rowset does not currently have a valid connection, 2122 * prepared statement, and result set 2123 */ 2124 public int getConcurrency() throws SQLException { 2125 try { 2126 checkState(); 2127 } catch(SQLException sqle) { 2128 super.getConcurrency(); 2129 } 2130 return rs.getConcurrency(); 2131 } 2132 2133 //--------------------------------------------------------------------- 2134 // Updates 2135 //--------------------------------------------------------------------- 2136 2137 /** 2138 * Indicates whether the current row has been updated. The value returned 2139 * depends on whether or not the result set can detect updates. 2140 * 2141 * @return <code>true</code> if the row has been visibly updated 2142 * by the owner or another, and updates are detected 2143 * @throws SQLException if a database access error occurs 2144 * or this rowset does not currently have a valid connection, 2145 * prepared statement, and result set 2146 * @see java.sql.DatabaseMetaData#updatesAreDetected 2147 */ 2148 public boolean rowUpdated() throws SQLException { 2149 checkState(); 2150 2151 return rs.rowUpdated(); 2152 } 2153 2154 /** 2155 * Indicates whether the current row has had an insertion. 2156 * The value returned depends on whether or not this 2157 * <code>ResultSet</code> object can detect visible inserts. 2158 * 2159 * @return <code>true</code> if a row has had an insertion 2160 * and insertions are detected; <code>false</code> otherwise 2161 * @throws SQLException if a database access error occurs 2162 * or this rowset does not currently have a valid connection, 2163 * prepared statement, and result set 2164 * @see java.sql.DatabaseMetaData#insertsAreDetected 2165 * 2166 */ 2167 public boolean rowInserted() throws SQLException { 2168 checkState(); 2169 2170 return rs.rowInserted(); 2171 } 2172 2173 /** 2174 * Indicates whether a row has been deleted. A deleted row may leave 2175 * a visible "hole" in a result set. This method can be used to 2176 * detect holes in a result set. The value returned depends on whether 2177 * or not this rowset's <code>ResultSet</code> object can detect deletions. 2178 * 2179 * @return <code>true</code> if a row was deleted and deletions are detected; 2180 * <code>false</code> otherwise 2181 * @throws SQLException if a database access error occurs 2182 * or this rowset does not currently have a valid connection, 2183 * prepared statement, and result set 2184 * @see java.sql.DatabaseMetaData#deletesAreDetected 2185 */ 2186 public boolean rowDeleted() throws SQLException { 2187 checkState(); 2188 2189 return rs.rowDeleted(); 2190 } 2191 2192 /** 2193 * Gives a nullable column a null value. 2194 * 2195 * The <code>updateXXX</code> methods are used to update column values in the 2196 * current row or the insert row. The <code>updateXXX</code> methods do not 2197 * update the underlying database; instead the <code>updateRow</code> 2198 * or <code>insertRow</code> methods are called to update the database. 2199 * 2200 * @param columnIndex the first column is 1, the second is 2, and so on 2201 * @throws SQLException if a database access error occurs 2202 * or this rowset does not currently have a valid connection, 2203 * prepared statement, and result set 2204 */ 2205 public void updateNull(int columnIndex) throws SQLException { 2206 checkState(); 2207 2208 // To check the type and concurrency of the ResultSet 2209 // to verify whether updates are possible or not 2210 checkTypeConcurrency(); 2211 2212 rs.updateNull(columnIndex); 2213 } 2214 2215 /** 2216 * Updates the designated column with a <code>boolean</code> value. 2217 * The <code>updateXXX</code> methods are used to update column values in the 2218 * current row or the insert row. The <code>updateXXX</code> methods do not 2219 * update the underlying database; instead the <code>updateRow</code> or 2220 * <code>insertRow</code> methods are called to update the database. 2221 * 2222 * @param columnIndex the first column is 1, the second is 2, and so on 2223 * @param x the new column value 2224 * @throws SQLException if a database access error occurs 2225 * or this rowset does not currently have a valid connection, 2226 * prepared statement, and result set 2227 * 2228 */ 2229 public void updateBoolean(int columnIndex, boolean x) throws SQLException { 2230 checkState(); 2231 2232 // To check the type and concurrency of the ResultSet 2233 // to verify whether updates are possible or not 2234 checkTypeConcurrency(); 2235 2236 rs.updateBoolean(columnIndex, x); 2237 } 2238 2239 /** 2240 * Updates the designated column with a <code>byte</code> value. 2241 * The <code>updateXXX</code> methods are used to update column values in the 2242 * current row or the insert row. The <code>updateXXX</code> methods do not 2243 * update the underlying database; instead the <code>updateRow</code> or 2244 * <code>insertRow</code> methods are called to update the database. 2245 * 2246 * 2247 * @param columnIndex the first column is 1, the second is 2, and so on 2248 * @param x the new column value 2249 * @throws SQLException if a database access error occurs 2250 * or this rowset does not currently have a valid connection, 2251 * prepared statement, and result set 2252 * 2253 */ 2254 public void updateByte(int columnIndex, byte x) throws SQLException { 2255 checkState(); 2256 2257 // To check the type and concurrency of the ResultSet 2258 // to verify whether updates are possible or not 2259 checkTypeConcurrency(); 2260 2261 rs.updateByte(columnIndex, x); 2262 } 2263 2264 /** 2265 * Updates the designated column with a <code>short</code> value. 2266 * The <code>updateXXX</code> methods are used to update column values in the 2267 * current row or the insert row. The <code>updateXXX</code> methods do not 2268 * update the underlying database; instead the <code>updateRow</code> or 2269 * <code>insertRow</code> methods are called to update the database. 2270 * 2271 * @param columnIndex the first column is 1, the second is 2, and so on 2272 * @param x the new column value 2273 * @throws SQLException if a database access error occurs 2274 * or this rowset does not currently have a valid connection, 2275 * prepared statement, and result set 2276 * 2277 */ 2278 public void updateShort(int columnIndex, short x) throws SQLException { 2279 checkState(); 2280 2281 // To check the type and concurrency of the ResultSet 2282 // to verify whether updates are possible or not 2283 checkTypeConcurrency(); 2284 2285 rs.updateShort(columnIndex, x); 2286 } 2287 2288 /** 2289 * Updates the designated column with an <code>int</code> value. 2290 * The <code>updateXXX</code> methods are used to update column values in the 2291 * current row or the insert row. The <code>updateXXX</code> methods do not 2292 * update the underlying database; instead the <code>updateRow</code> or 2293 * <code>insertRow</code> methods are called to update the database. 2294 * 2295 * @param columnIndex the first column is 1, the second is 2, and so on 2296 * @param x the new column value 2297 * @throws SQLException if a database access error occurs 2298 * or this rowset does not currently have a valid connection, 2299 * prepared statement, and result set 2300 */ 2301 public void updateInt(int columnIndex, int x) throws SQLException { 2302 checkState(); 2303 2304 // To check the type and concurrency of the ResultSet 2305 // to verify whether updates are possible or not 2306 checkTypeConcurrency(); 2307 2308 rs.updateInt(columnIndex, x); 2309 } 2310 2311 /** 2312 * Updates the designated column with a <code>long</code> value. 2313 * The <code>updateXXX</code> methods are used to update column values in the 2314 * current row or the insert row. The <code>updateXXX</code> methods do not 2315 * update the underlying database; instead the <code>updateRow</code> or 2316 * <code>insertRow</code> methods are called to update the database. 2317 * 2318 * @param columnIndex the first column is 1, the second is 2, and so on 2319 * @param x the new column value 2320 * @throws SQLException if a database access error occurs 2321 * or this rowset does not currently have a valid connection, 2322 * prepared statement, and result set 2323 * 2324 */ 2325 public void updateLong(int columnIndex, long x) throws SQLException { 2326 checkState(); 2327 2328 // To check the type and concurrency of the ResultSet 2329 // to verify whether updates are possible or not 2330 checkTypeConcurrency(); 2331 2332 rs.updateLong(columnIndex, x); 2333 } 2334 2335 /** 2336 * Updates the designated column with a <code>float</code> value. 2337 * The <code>updateXXX</code> methods are used to update column values in the 2338 * current row or the insert row. The <code>updateXXX</code> methods do not 2339 * update the underlying database; instead the <code>updateRow</code> or 2340 * <code>insertRow</code> methods are called to update the database. 2341 * 2342 * @param columnIndex the first column is 1, the second is 2, and so on 2343 * @param x the new column value 2344 * @throws SQLException if a database access error occurs 2345 * or this rowset does not currently have a valid connection, 2346 * prepared statement, and result set 2347 * 2348 */ 2349 public void updateFloat(int columnIndex, float x) throws SQLException { 2350 checkState(); 2351 2352 // To check the type and concurrency of the ResultSet 2353 // to verify whether updates are possible or not 2354 checkTypeConcurrency(); 2355 2356 rs.updateFloat(columnIndex, x); 2357 } 2358 2359 /** 2360 * Updates the designated column with a <code>double</code> value. 2361 * The <code>updateXXX</code> methods are used to update column values in the 2362 * current row or the insert row. The <code>updateXXX</code> methods do not 2363 * update the underlying database; instead the <code>updateRow</code> or 2364 * <code>insertRow</code> methods are called to update the database. 2365 * 2366 * @param columnIndex the first column is 1, the second is 2, and so on 2367 * @param x the new column value 2368 * @throws SQLException if a database access error occurs 2369 * or this rowset does not currently have a valid connection, 2370 * prepared statement, and result set 2371 * 2372 */ 2373 public void updateDouble(int columnIndex, double x) throws SQLException { 2374 checkState(); 2375 2376 // To check the type and concurrency of the ResultSet 2377 // to verify whether updates are possible or not 2378 checkTypeConcurrency(); 2379 2380 rs.updateDouble(columnIndex, x); 2381 } 2382 2383 /** 2384 * Updates the designated column with a <code>java.math.BigDecimal</code> 2385 * value. 2386 * The <code>updateXXX</code> methods are used to update column values in the 2387 * current row or the insert row. The <code>updateXXX</code> methods do not 2388 * update the underlying database; instead the <code>updateRow</code> or 2389 * <code>insertRow</code> methods are called to update the database. 2390 * 2391 * @param columnIndex the first column is 1, the second is 2, and so on 2392 * @param x the new column value 2393 * @throws SQLException if a database access error occurs 2394 * or this rowset does not currently have a valid connection, 2395 * prepared statement, and result set 2396 * 2397 */ 2398 public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException { 2399 checkState(); 2400 2401 // To check the type and concurrency of the ResultSet 2402 // to verify whether updates are possible or not 2403 checkTypeConcurrency(); 2404 2405 rs.updateBigDecimal(columnIndex, x); 2406 } 2407 2408 /** 2409 * Updates the designated column with a <code>String</code> value. 2410 * The <code>updateXXX</code> methods are used to update column values in the 2411 * current row or the insert row. The <code>updateXXX</code> methods do not 2412 * update the underlying database; instead the <code>updateRow</code> or 2413 * <code>insertRow</code> methods are called to update the database. 2414 * 2415 * @param columnIndex the first column is 1, the second is 2, and so on 2416 * @param x the new column value 2417 * @throws SQLException if a database access error occurs 2418 * or this rowset does not currently have a valid connection, 2419 * prepared statement, and result set 2420 * 2421 */ 2422 public void updateString(int columnIndex, String x) throws SQLException { 2423 checkState(); 2424 2425 // To check the type and concurrency of the ResultSet 2426 // to verify whether updates are possible or not 2427 checkTypeConcurrency(); 2428 2429 rs.updateString(columnIndex, x); 2430 } 2431 2432 /** 2433 * Updates the designated column with a <code>byte</code> array value. 2434 * The <code>updateXXX</code> methods are used to update column values in the 2435 * current row or the insert row. The <code>updateXXX</code> methods do not 2436 * update the underlying database; instead the <code>updateRow</code> or 2437 * <code>insertRow</code> methods are called to update the database. 2438 * 2439 * @param columnIndex the first column is 1, the second is 2, and so on 2440 * @param x the new column value 2441 * @throws SQLException if a database access error occurs 2442 * or this rowset does not currently have a valid connection, 2443 * prepared statement, and result set 2444 * 2445 */ 2446 public void updateBytes(int columnIndex, byte x[]) throws SQLException { 2447 checkState(); 2448 2449 // To check the type and concurrency of the ResultSet 2450 // to verify whether updates are possible or not 2451 checkTypeConcurrency(); 2452 2453 rs.updateBytes(columnIndex, x); 2454 } 2455 2456 /** 2457 * Updates the designated column with a <code>java.sql.Date</code> value. 2458 * The <code>updateXXX</code> methods are used to update column values in the 2459 * current row or the insert row. The <code>updateXXX</code> methods do not 2460 * update the underlying database; instead the <code>updateRow</code> or 2461 * <code>insertRow</code> methods are called to update the database. 2462 * 2463 * @param columnIndex the first column is 1, the second is 2, and so on 2464 * @param x the new column value 2465 * @throws SQLException if a database access error occurs 2466 * or this rowset does not currently have a valid connection, 2467 * prepared statement, and result set 2468 * 2469 */ 2470 public void updateDate(int columnIndex, java.sql.Date x) throws SQLException { 2471 checkState(); 2472 2473 // To check the type and concurrency of the ResultSet 2474 // to verify whether updates are possible or not 2475 checkTypeConcurrency(); 2476 2477 rs.updateDate(columnIndex, x); 2478 } 2479 2480 2481 /** 2482 * Updates the designated column with a <code>java.sql.Time</code> value. 2483 * The <code>updateXXX</code> methods are used to update column values in the 2484 * current row or the insert row. The <code>updateXXX</code> methods do not 2485 * update the underlying database; instead the <code>updateRow</code> or 2486 * <code>insertRow</code> methods are called to update the database. 2487 * 2488 * @param columnIndex the first column is 1, the second is 2, and so on 2489 * @param x the new column value 2490 * @throws SQLException if a database access error occurs 2491 * or this rowset does not currently have a valid connection, 2492 * prepared statement, and result set 2493 * 2494 */ 2495 public void updateTime(int columnIndex, java.sql.Time x) throws SQLException { 2496 checkState(); 2497 2498 // To check the type and concurrency of the ResultSet 2499 // to verify whether updates are possible or not 2500 checkTypeConcurrency(); 2501 2502 rs.updateTime(columnIndex, x); 2503 } 2504 2505 /** 2506 * Updates the designated column with a <code>java.sql.Timestamp</code> 2507 * value. 2508 * The <code>updateXXX</code> methods are used to update column values in the 2509 * current row or the insert row. The <code>updateXXX</code> methods do not 2510 * update the underlying database; instead the <code>updateRow</code> or 2511 * <code>insertRow</code> methods are called to update the database. 2512 * 2513 * @param columnIndex the first column is 1, the second is 2, and so on 2514 * @param x the new column value 2515 * @throws SQLException if a database access error occurs 2516 * or this rowset does not currently have a valid connection, 2517 * prepared statement, and result set 2518 * 2519 */ 2520 public void updateTimestamp(int columnIndex, java.sql.Timestamp x) throws SQLException { 2521 checkState(); 2522 2523 // To check the type and concurrency of the ResultSet 2524 // to verify whether updates are possible or not 2525 checkTypeConcurrency(); 2526 2527 rs.updateTimestamp(columnIndex, x); 2528 } 2529 2530 /** 2531 * Updates the designated column with an ascii stream value. 2532 * The <code>updateXXX</code> methods are used to update column values in the 2533 * current row or the insert row. The <code>updateXXX</code> methods do not 2534 * update the underlying database; instead the <code>updateRow</code> or 2535 * <code>insertRow</code> methods are called to update the database. 2536 * 2537 * @param columnIndex the first column is 1, the second is 2, and so on 2538 * @param x the new column value 2539 * @param length the length of the stream 2540 * @throws SQLException if (1) a database access error occurs 2541 * (2) or this rowset does not currently have a valid connection, 2542 * prepared statement, and result set 2543 * 2544 */ 2545 public void updateAsciiStream(int columnIndex, java.io.InputStream x, int length) throws SQLException { 2546 checkState(); 2547 2548 // To check the type and concurrency of the ResultSet 2549 // to verify whether updates are possible or not 2550 checkTypeConcurrency(); 2551 2552 rs.updateAsciiStream(columnIndex, x, length); 2553 } 2554 2555 /** 2556 * Updates the designated column with a binary stream value. 2557 * The <code>updateXXX</code> methods are used to update column values in the 2558 * current row or the insert row. The <code>updateXXX</code> methods do not 2559 * update the underlying database; instead the <code>updateRow</code> or 2560 * <code>insertRow</code> methods are called to update the database. 2561 * 2562 * @param columnIndex the first column is 1, the second is 2, and so on 2563 * @param x the new column value 2564 * @param length the length of the stream 2565 * @throws SQLException if a database access error occurs 2566 * or this rowset does not currently have a valid connection, 2567 * prepared statement, and result set 2568 * 2569 */ 2570 public void updateBinaryStream(int columnIndex, java.io.InputStream x, int length) throws SQLException { 2571 checkState(); 2572 2573 // To check the type and concurrency of the ResultSet 2574 // to verify whether updates are possible or not 2575 checkTypeConcurrency(); 2576 2577 rs.updateBinaryStream(columnIndex, x, length); 2578 } 2579 2580 /** 2581 * Updates the designated column with a character stream value. 2582 * The <code>updateXXX</code> methods are used to update column values in the 2583 * current row or the insert row. The <code>updateXXX</code> methods do not 2584 * update the underlying database; instead the <code>updateRow</code> or 2585 * <code>insertRow</code> methods are called to update the database. 2586 * 2587 * @param columnIndex the first column is 1, the second is 2, and so on 2588 * @param x the new column value 2589 * @param length the length of the stream 2590 * @throws SQLException if a database access error occurs 2591 * or this rowset does not currently have a valid connection, 2592 * prepared statement, and result set 2593 * 2594 */ 2595 public void updateCharacterStream(int columnIndex, java.io.Reader x, int length) throws SQLException { 2596 checkState(); 2597 2598 // To check the type and concurrency of the ResultSet 2599 // to verify whether updates are possible or not 2600 checkTypeConcurrency(); 2601 2602 rs.updateCharacterStream(columnIndex, x, length); 2603 } 2604 2605 /** 2606 * Updates the designated column with an <code>Object</code> value. 2607 * The <code>updateXXX</code> methods are used to update column values in the 2608 * current row or the insert row. The <code>updateXXX</code> methods do not 2609 * update the underlying database; instead the <code>updateRow</code> or 2610 * <code>insertRow</code> methods are called to update the database. 2611 * 2612 * @param columnIndex the first column is 1, the second is 2, and so on 2613 * @param x the new column value 2614 * @param scale for <code>java.sql.Types.DECIMAl</code> 2615 * or <code>java.sql.Types.NUMERIC</code> types, 2616 * this is the number of digits after the decimal point. For all other 2617 * types this value will be ignored. 2618 * @throws SQLException if a database access error occurs 2619 * or this rowset does not currently have a valid connection, 2620 * prepared statement, and result set 2621 * 2622 */ 2623 public void updateObject(int columnIndex, Object x, int scale) throws SQLException { 2624 checkState(); 2625 2626 // To check the type and concurrency of the ResultSet 2627 // to verify whether updates are possible or not 2628 checkTypeConcurrency(); 2629 2630 rs.updateObject(columnIndex, x, scale); 2631 } 2632 2633 /** 2634 * Updates the designated column with an <code>Object</code> value. 2635 * The <code>updateXXX</code> methods are used to update column values in the 2636 * current row or the insert row. The <code>updateXXX</code> methods do not 2637 * update the underlying database; instead the <code>updateRow</code> or 2638 * <code>insertRow</code> methods are called to update the database. 2639 * 2640 * @param columnIndex the first column is 1, the second is 2, and so on 2641 * @param x the new column value 2642 * @throws SQLException if a database access error occurs 2643 * or this rowset does not currently have a valid connection, 2644 * prepared statement, and result set 2645 * 2646 */ 2647 public void updateObject(int columnIndex, Object x) throws SQLException { 2648 checkState(); 2649 2650 // To check the type and concurrency of the ResultSet 2651 // to verify whether updates are possible or not 2652 checkTypeConcurrency(); 2653 2654 rs.updateObject(columnIndex, x); 2655 } 2656 2657 /** 2658 * Updates the designated column with a <code>null</code> value. 2659 * The <code>updateXXX</code> methods are used to update column values in the 2660 * current row or the insert row. The <code>updateXXX</code> methods do not 2661 * update the underlying database; instead the <code>updateRow</code> or 2662 * <code>insertRow</code> methods are called to update the database. 2663 * 2664 * @param columnName the name of the column 2665 * @throws SQLException if a database access error occurs 2666 * or this rowset does not currently have a valid connection, 2667 * prepared statement, and result set 2668 * 2669 */ 2670 public void updateNull(String columnName) throws SQLException { 2671 updateNull(findColumn(columnName)); 2672 } 2673 2674 /** 2675 * Updates the designated column with a <code>boolean</code> value. 2676 * The <code>updateXXX</code> methods are used to update column values in the 2677 * current row or the insert row. The <code>updateXXX</code> methods do not 2678 * update the underlying database; instead the <code>updateRow</code> or 2679 * <code>insertRow</code> methods are called to update the database. 2680 * 2681 * @param columnName the name of the column 2682 * @param x the new column value 2683 * @throws SQLException if a database access error occurs 2684 * 2685 */ 2686 public void updateBoolean(String columnName, boolean x) throws SQLException { 2687 updateBoolean(findColumn(columnName), x); 2688 } 2689 2690 /** 2691 * Updates the designated column with a <code>byte</code> value. 2692 * The <code>updateXXX</code> methods are used to update column values in the 2693 * current row or the insert row. The <code>updateXXX</code> methods do not 2694 * update the underlying database; instead the <code>updateRow</code> or 2695 * <code>insertRow</code> methods are called to update the database. 2696 * 2697 * @param columnName the name of the column 2698 * @param x the new column value 2699 * @throws SQLException if a database access error occurs 2700 * 2701 */ 2702 public void updateByte(String columnName, byte x) throws SQLException { 2703 updateByte(findColumn(columnName), x); 2704 } 2705 2706 /** 2707 * Updates the designated column with a <code>short</code> value. 2708 * The <code>updateXXX</code> methods are used to update column values in the 2709 * current row or the insert row. The <code>updateXXX</code> methods do not 2710 * update the underlying database; instead the <code>updateRow</code> or 2711 * <code>insertRow</code> methods are called to update the database. 2712 * 2713 * @param columnName the name of the column 2714 * @param x the new column value 2715 * @throws SQLException if a database access error occurs 2716 * 2717 */ 2718 public void updateShort(String columnName, short x) throws SQLException { 2719 updateShort(findColumn(columnName), x); 2720 } 2721 2722 /** 2723 * Updates the designated column with an <code>int</code> value. 2724 * The <code>updateXXX</code> methods are used to update column values in the 2725 * current row or the insert row. The <code>updateXXX</code> methods do not 2726 * update the underlying database; instead the <code>updateRow</code> or 2727 * <code>insertRow</code> methods are called to update the database. 2728 * 2729 * @param columnName the name of the column 2730 * @param x the new column value 2731 * @throws SQLException if a database access error occurs 2732 * 2733 */ 2734 public void updateInt(String columnName, int x) throws SQLException { 2735 updateInt(findColumn(columnName), x); 2736 } 2737 2738 /** 2739 * Updates the designated column with a <code>long</code> value. 2740 * The <code>updateXXX</code> methods are used to update column values in the 2741 * current row or the insert row. The <code>updateXXX</code> methods do not 2742 * update the underlying database; instead the <code>updateRow</code> or 2743 * <code>insertRow</code> methods are called to update the database. 2744 * 2745 * @param columnName the name of the column 2746 * @param x the new column value 2747 * @throws SQLException if a database access error occurs 2748 * 2749 */ 2750 public void updateLong(String columnName, long x) throws SQLException { 2751 updateLong(findColumn(columnName), x); 2752 } 2753 2754 /** 2755 * Updates the designated column with a <code>float </code> value. 2756 * The <code>updateXXX</code> methods are used to update column values in the 2757 * current row or the insert row. The <code>updateXXX</code> methods do not 2758 * update the underlying database; instead the <code>updateRow</code> or 2759 * <code>insertRow</code> methods are called to update the database. 2760 * 2761 * @param columnName the name of the column 2762 * @param x the new column value 2763 * @throws SQLException if a database access error occurs 2764 * 2765 */ 2766 public void updateFloat(String columnName, float x) throws SQLException { 2767 updateFloat(findColumn(columnName), x); 2768 } 2769 2770 /** 2771 * Updates the designated column with a <code>double</code> value. 2772 * The <code>updateXXX</code> methods are used to update column values in the 2773 * current row or the insert row. The <code>updateXXX</code> methods do not 2774 * update the underlying database; instead the <code>updateRow</code> or 2775 * <code>insertRow</code> methods are called to update the database. 2776 * 2777 * @param columnName the name of the column 2778 * @param x the new column value 2779 * @throws SQLException if a database access error occurs 2780 * 2781 */ 2782 public void updateDouble(String columnName, double x) throws SQLException { 2783 updateDouble(findColumn(columnName), x); 2784 } 2785 2786 /** 2787 * Updates the designated column with a <code>java.sql.BigDecimal</code> 2788 * value. 2789 * The <code>updateXXX</code> methods are used to update column values in the 2790 * current row or the insert row. The <code>updateXXX</code> methods do not 2791 * update the underlying database; instead the <code>updateRow</code> or 2792 * <code>insertRow</code> methods are called to update the database. 2793 * 2794 * @param columnName the name of the column 2795 * @param x the new column value 2796 * @throws SQLException if a database access error occurs 2797 * 2798 */ 2799 public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException { 2800 updateBigDecimal(findColumn(columnName), x); 2801 } 2802 2803 /** 2804 * Updates the designated column with a <code>String</code> value. 2805 * The <code>updateXXX</code> methods are used to update column values in the 2806 * current row or the insert row. The <code>updateXXX</code> methods do not 2807 * update the underlying database; instead the <code>updateRow</code> or 2808 * <code>insertRow</code> methods are called to update the database. 2809 * 2810 * @param columnName the name of the column 2811 * @param x the new column value 2812 * @throws SQLException if a database access error occurs 2813 * 2814 */ 2815 public void updateString(String columnName, String x) throws SQLException { 2816 updateString(findColumn(columnName), x); 2817 } 2818 2819 /** 2820 * Updates the designated column with a <code>boolean</code> value. 2821 * The <code>updateXXX</code> methods are used to update column values in the 2822 * current row or the insert row. The <code>updateXXX</code> methods do not 2823 * update the underlying database; instead the <code>updateRow</code> or 2824 * <code>insertRow</code> methods are called to update the database. 2825 * 2826 * JDBC 2.0 2827 * 2828 * Updates a column with a byte array value. 2829 * 2830 * The <code>updateXXX</code> methods are used to update column values in the 2831 * current row, or the insert row. The <code>updateXXX</code> methods do not 2832 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code> 2833 * methods are called to update the database. 2834 * 2835 * @param columnName the name of the column 2836 * @param x the new column value 2837 * @throws SQLException if a database access error occurs 2838 * 2839 */ 2840 public void updateBytes(String columnName, byte x[]) throws SQLException { 2841 updateBytes(findColumn(columnName), x); 2842 } 2843 2844 /** 2845 * Updates the designated column with a <code>java.sql.Date</code> value. 2846 * The <code>updateXXX</code> methods are used to update column values in the 2847 * current row or the insert row. The <code>updateXXX</code> methods do not 2848 * update the underlying database; instead the <code>updateRow</code> or 2849 * <code>insertRow</code> methods are called to update the database. 2850 * 2851 * @param columnName the name of the column 2852 * @param x the new column value 2853 * @throws SQLException if a database access error occurs 2854 * 2855 */ 2856 public void updateDate(String columnName, java.sql.Date x) throws SQLException { 2857 updateDate(findColumn(columnName), x); 2858 } 2859 2860 /** 2861 * Updates the designated column with a <code>java.sql.Time</code> value. 2862 * The <code>updateXXX</code> methods are used to update column values in the 2863 * current row or the insert row. The <code>updateXXX</code> methods do not 2864 * update the underlying database; instead the <code>updateRow</code> or 2865 * <code>insertRow</code> methods are called to update the database. 2866 * 2867 * @param columnName the name of the column 2868 * @param x the new column value 2869 * @throws SQLException if a database access error occurs 2870 * 2871 */ 2872 public void updateTime(String columnName, java.sql.Time x) throws SQLException { 2873 updateTime(findColumn(columnName), x); 2874 } 2875 2876 /** 2877 * Updates the designated column with a <code>java.sql.Timestamp</code> 2878 * value. 2879 * The <code>updateXXX</code> methods are used to update column values in the 2880 * current row or the insert row. The <code>updateXXX</code> methods do not 2881 * update the underlying database; instead the <code>updateRow</code> or 2882 * <code>insertRow</code> methods are called to update the database. 2883 * 2884 * @param columnName the name of the column 2885 * @param x the new column value 2886 * @throws SQLException if a database access error occurs 2887 * 2888 */ 2889 public void updateTimestamp(String columnName, java.sql.Timestamp x) throws SQLException { 2890 updateTimestamp(findColumn(columnName), x); 2891 } 2892 2893 /** 2894 * Updates the designated column with an ascii stream value. 2895 * The <code>updateXXX</code> methods are used to update column values in the 2896 * current row or the insert row. The <code>updateXXX</code> methods do not 2897 * update the underlying database; instead the <code>updateRow</code> or 2898 * <code>insertRow</code> methods are called to update the database. 2899 * 2900 * @param columnName the name of the column 2901 * @param x the new column value 2902 * @param length the length of the stream 2903 * @throws SQLException if a database access error occurs 2904 * 2905 */ 2906 public void updateAsciiStream(String columnName, java.io.InputStream x, int length) throws SQLException { 2907 updateAsciiStream(findColumn(columnName), x, length); 2908 } 2909 2910 /** 2911 * Updates the designated column with a binary stream value. 2912 * The <code>updateXXX</code> methods are used to update column values in the 2913 * current row or the insert row. The <code>updateXXX</code> methods do not 2914 * update the underlying database; instead the <code>updateRow</code> or 2915 * <code>insertRow</code> methods are called to update the database. 2916 * 2917 * @param columnName the name of the column 2918 * @param x the new column value 2919 * @param length the length of the stream 2920 * @throws SQLException if a database access error occurs 2921 * 2922 */ 2923 public void updateBinaryStream(String columnName, java.io.InputStream x, int length) throws SQLException { 2924 updateBinaryStream(findColumn(columnName), x, length); 2925 } 2926 2927 /** 2928 * Updates the designated column with a character stream value. 2929 * The <code>updateXXX</code> methods are used to update column values 2930 * in the current row or the insert row. The <code>updateXXX</code> 2931 * methods do not update the underlying database; instead the 2932 * <code>updateRow</code> or <code>insertRow</code> methods are called 2933 * to update the database. 2934 * 2935 * @param columnName the name of the column 2936 * @param reader the new column <code>Reader</code> stream value 2937 * @param length the length of the stream 2938 * @throws SQLException if a database access error occurs 2939 * 2940 */ 2941 public void updateCharacterStream(String columnName, java.io.Reader reader, int length) throws SQLException { 2942 updateCharacterStream(findColumn(columnName), reader, length); 2943 } 2944 2945 /** 2946 * Updates the designated column with an <code>Object</code> value. 2947 * The <code>updateXXX</code> methods are used to update column values in the 2948 * current row or the insert row. The <code>updateXXX</code> methods do not 2949 * update the underlying database; instead the <code>updateRow</code> or 2950 * <code>insertRow</code> methods are called to update the database. 2951 * 2952 * @param columnName the name of the column 2953 * @param x the new column value 2954 * @param scale for <code>java.sql.Types.DECIMAL</code> 2955 * or <code>java.sql.Types.NUMERIC</code> types, 2956 * this is the number of digits after the decimal point. For all other 2957 * types this value will be ignored. 2958 * @throws SQLException if a database access error occurs 2959 * 2960 */ 2961 public void updateObject(String columnName, Object x, int scale) throws SQLException { 2962 updateObject(findColumn(columnName), x, scale); 2963 } 2964 2965 /** 2966 * Updates the designated column with an <code>Object</code> value. 2967 * The <code>updateXXX</code> methods are used to update column values in the 2968 * current row or the insert row. The <code>updateXXX</code> methods do not 2969 * update the underlying database; instead the <code>updateRow</code> or 2970 * <code>insertRow</code> methods are called to update the database. 2971 * 2972 * @param columnName the name of the column 2973 * @param x the new column value 2974 * @throws SQLException if a database access error occurs 2975 * 2976 */ 2977 public void updateObject(String columnName, Object x) throws SQLException { 2978 updateObject(findColumn(columnName), x); 2979 } 2980 2981 /** 2982 * Inserts the contents of the insert row into this 2983 * <code>ResultSet</code> object and into the database 2984 * and also notifies listeners that a row has changed. 2985 * The cursor must be on the insert row when this method is called. 2986 * 2987 * @throws SQLException if (1) a database access error occurs, 2988 * (2) this method is called when the cursor is not 2989 * on the insert row, (3) not all non-nullable columns in 2990 * the insert row have been given a value, or (4) this 2991 * rowset does not currently have a valid connection, 2992 * prepared statement, and result set 2993 */ 2994 public void insertRow() throws SQLException { 2995 checkState(); 2996 2997 rs.insertRow(); 2998 notifyRowChanged(); 2999 } 3000 3001 /** 3002 * Updates the underlying database with the new contents of the 3003 * current row of this rowset's <code>ResultSet</code> object 3004 * and notifies listeners that a row has changed. 3005 * This method cannot be called when the cursor is on the insert row. 3006 * 3007 * @throws SQLException if (1) a database access error occurs, 3008 * (2) this method is called when the cursor is 3009 * on the insert row, (3) the concurrency of the result 3010 * set is <code>ResultSet.CONCUR_READ_ONLY</code>, or 3011 * (4) this rowset does not currently have a valid connection, 3012 * prepared statement, and result set 3013 */ 3014 public void updateRow() throws SQLException { 3015 checkState(); 3016 3017 rs.updateRow(); 3018 notifyRowChanged(); 3019 } 3020 3021 /** 3022 * Deletes the current row from this rowset's <code>ResultSet</code> object 3023 * and from the underlying database and also notifies listeners that a row 3024 * has changed. This method cannot be called when the cursor is on the insert 3025 * row. 3026 * 3027 * @throws SQLException if a database access error occurs 3028 * or if this method is called when the cursor is on the insert row 3029 * @throws SQLException if (1) a database access error occurs, 3030 * (2) this method is called when the cursor is before the 3031 * first row, after the last row, or on the insert row, 3032 * (3) the concurrency of this rowset's result 3033 * set is <code>ResultSet.CONCUR_READ_ONLY</code>, or 3034 * (4) this rowset does not currently have a valid connection, 3035 * prepared statement, and result set 3036 */ 3037 public void deleteRow() throws SQLException { 3038 checkState(); 3039 3040 rs.deleteRow(); 3041 notifyRowChanged(); 3042 } 3043 3044 /** 3045 * Refreshes the current row of this rowset's <code>ResultSet</code> 3046 * object with its most recent value in the database. This method 3047 * cannot be called when the cursor is on the insert row. 3048 * 3049 * <P>The <code>refreshRow</code> method provides a way for an 3050 * application to explicitly tell the JDBC driver to refetch 3051 * a row(s) from the database. An application may want to call 3052 * <code>refreshRow</code> when caching or prefetching is being 3053 * done by the JDBC driver to fetch the latest value of a row 3054 * from the database. The JDBC driver may actually refresh multiple 3055 * rows at once if the fetch size is greater than one. 3056 * 3057 * <P> All values are refetched subject to the transaction isolation 3058 * level and cursor sensitivity. If <code>refreshRow</code> is called after 3059 * calling an <code>updateXXX</code> method, but before calling 3060 * the method <code>updateRow</code>, then the 3061 * updates made to the row are lost. Calling the method 3062 * <code>refreshRow</code> frequently will likely slow performance. 3063 * 3064 * @throws SQLException if (1) a database access error occurs, 3065 * (2) this method is called when the cursor is 3066 * on the insert row, or (3) this rowset does not 3067 * currently have a valid connection, prepared statement, 3068 * and result set 3069 * 3070 */ 3071 public void refreshRow() throws SQLException { 3072 checkState(); 3073 3074 rs.refreshRow(); 3075 } 3076 3077 /** 3078 * Cancels the updates made to the current row in this 3079 * <code>ResultSet</code> object and notifies listeners that a row 3080 * has changed. This method may be called after calling an 3081 * <code>updateXXX</code> method(s) and before calling 3082 * the method <code>updateRow</code> to roll back 3083 * the updates made to a row. If no updates have been made or 3084 * <code>updateRow</code> has already been called, this method has no 3085 * effect. 3086 * 3087 * @throws SQLException if (1) a database access error occurs, 3088 * (2) this method is called when the cursor is 3089 * on the insert row, or (3) this rowset does not 3090 * currently have a valid connection, prepared statement, 3091 * and result set 3092 */ 3093 public void cancelRowUpdates() throws SQLException { 3094 checkState(); 3095 3096 rs.cancelRowUpdates(); 3097 3098 notifyRowChanged(); 3099 } 3100 3101 /** 3102 * Moves the cursor to the insert row. The current cursor position is 3103 * remembered while the cursor is positioned on the insert row. 3104 * 3105 * The insert row is a special row associated with an updatable 3106 * result set. It is essentially a buffer where a new row may 3107 * be constructed by calling the <code>updateXXX</code> methods prior to 3108 * inserting the row into the result set. 3109 * 3110 * Only the <code>updateXXX</code>, <code>getXXX</code>, 3111 * and <code>insertRow</code> methods may be 3112 * called when the cursor is on the insert row. All of the columns in 3113 * a result set must be given a value each time this method is 3114 * called before calling <code>insertRow</code>. 3115 * An <code>updateXXX</code> method must be called before a 3116 * <code>getXXX</code> method can be called on a column value. 3117 * 3118 * @throws SQLException if (1) a database access error occurs, 3119 * (2) this rowset's <code>ResultSet</code> object is 3120 * not updatable, or (3) this rowset does not 3121 * currently have a valid connection, prepared statement, 3122 * and result set 3123 * 3124 */ 3125 public void moveToInsertRow() throws SQLException { 3126 checkState(); 3127 3128 rs.moveToInsertRow(); 3129 } 3130 3131 /** 3132 * Moves the cursor to the remembered cursor position, usually the 3133 * current row. This method has no effect if the cursor is not on 3134 * the insert row. 3135 * 3136 * @throws SQLException if (1) a database access error occurs, 3137 * (2) this rowset's <code>ResultSet</code> object is 3138 * not updatable, or (3) this rowset does not 3139 * currently have a valid connection, prepared statement, 3140 * and result set 3141 */ 3142 public void moveToCurrentRow() throws SQLException { 3143 checkState(); 3144 3145 rs.moveToCurrentRow(); 3146 } 3147 3148 /** 3149 * Returns the <code>Statement</code> object that produced this 3150 * <code>ResultSet</code> object. 3151 * If the result set was generated some other way, such as by a 3152 * <code>DatabaseMetaData</code> method, this method returns 3153 * <code>null</code>. 3154 * 3155 * @return the <code>Statement</code> object that produced 3156 * this rowset's <code>ResultSet</code> object or <code>null</code> 3157 * if the result set was produced some other way 3158 * @throws SQLException if a database access error occurs 3159 */ 3160 public java.sql.Statement getStatement() throws SQLException { 3161 3162 if(rs != null) 3163 { 3164 return rs.getStatement(); 3165 } else { 3166 return null; 3167 } 3168 } 3169 3170 /** 3171 * Returns the value of the designated column in the current row 3172 * of this rowset's <code>ResultSet</code> object as an <code>Object</code>. 3173 * This method uses the given <code>Map</code> object 3174 * for the custom mapping of the 3175 * SQL structured or distinct type that is being retrieved. 3176 * 3177 * @param i the first column is 1, the second is 2, and so on 3178 * @param map a <code>java.util.Map</code> object that contains the mapping 3179 * from SQL type names to classes in the Java programming language 3180 * @return an <code>Object</code> in the Java programming language 3181 * representing the SQL value 3182 * @throws SQLException if (1) a database access error occurs 3183 * or (2) this rowset does not currently have a valid connection, 3184 * prepared statement, and result set 3185 */ 3186 public Object getObject(int i, java.util.Map<String,Class<?>> map) 3187 throws SQLException 3188 { 3189 checkState(); 3190 3191 return rs.getObject(i, map); 3192 } 3193 3194 /** 3195 * Returns the value of the designated column in the current row 3196 * of this rowset's <code>ResultSet</code> object as a <code>Ref</code> object. 3197 * 3198 * @param i the first column is 1, the second is 2, and so on 3199 * @return a <code>Ref</code> object representing an SQL <code>REF</code> value 3200 * @throws SQLException if (1) a database access error occurs 3201 * or (2) this rowset does not currently have a valid connection, 3202 * prepared statement, and result set 3203 */ 3204 public Ref getRef(int i) throws SQLException { 3205 checkState(); 3206 3207 return rs.getRef(i); 3208 } 3209 3210 3211 /** 3212 * Returns the value of the designated column in the current row 3213 * of this rowset's <code>ResultSet</code> object as a <code>Blob</code> object. 3214 * 3215 * @param i the first column is 1, the second is 2, and so on 3216 * @return a <code>Blob</code> object representing the SQL <code>BLOB</code> 3217 * value in the specified column 3218 * @throws SQLException if (1) a database access error occurs 3219 * or (2) this rowset does not currently have a valid connection, 3220 * prepared statement, and result set 3221 */ 3222 public Blob getBlob(int i) throws SQLException { 3223 checkState(); 3224 3225 return rs.getBlob(i); 3226 } 3227 3228 /** 3229 * Returns the value of the designated column in the current row 3230 * of this rowset's <code>ResultSet</code> object as a <code>Clob</code> object. 3231 * 3232 * @param i the first column is 1, the second is 2, and so on 3233 * @return a <code>Clob</code> object representing the SQL <code>CLOB</code> 3234 * value in the specified column 3235 * @throws SQLException if (1) a database access error occurs 3236 * or (2) this rowset does not currently have a valid connection, 3237 * prepared statement, and result set 3238 */ 3239 public Clob getClob(int i) throws SQLException { 3240 checkState(); 3241 3242 return rs.getClob(i); 3243 } 3244 3245 /** 3246 * Returns the value of the designated column in the current row 3247 * of this rowset's <code>ResultSet</code> object as an <code>Array</code> object. 3248 * 3249 * @param i the first column is 1, the second is 2, and so on. 3250 * @return an <code>Array</code> object representing the SQL <code>ARRAY</code> 3251 * value in the specified column 3252 * @throws SQLException if (1) a database access error occurs 3253 * or (2) this rowset does not currently have a valid connection, 3254 * prepared statement, and result set 3255 */ 3256 public Array getArray(int i) throws SQLException { 3257 checkState(); 3258 3259 return rs.getArray(i); 3260 } 3261 3262 /** 3263 * Returns the value of the designated column in the current row 3264 * of this rowset's <code>ResultSet</code> object as an <code>Object</code>. 3265 * This method uses the specified <code>Map</code> object for 3266 * custom mapping if appropriate. 3267 * 3268 * @param colName the name of the column from which to retrieve the value 3269 * @param map a <code>java.util.Map</code> object that contains the mapping 3270 * from SQL type names to classes in the Java programming language 3271 * @return an <code>Object</code> representing the SQL 3272 * value in the specified column 3273 * @throws SQLException if (1) a database access error occurs 3274 * or (2) this rowset does not currently have a valid connection, 3275 * prepared statement, and result set 3276 */ 3277 public Object getObject(String colName, java.util.Map<String,Class<?>> map) 3278 throws SQLException 3279 { 3280 return getObject(findColumn(colName), map); 3281 } 3282 3283 /** 3284 * Returns the value of the designated column in the current row 3285 * of this rowset's <code>ResultSet</code> object as a <code>Ref</code> object. 3286 * 3287 * @param colName the column name 3288 * @return a <code>Ref</code> object representing the SQL <code>REF</code> value in 3289 * the specified column 3290 * @throws SQLException if (1) a database access error occurs 3291 * or (2) this rowset does not currently have a valid connection, 3292 * prepared statement, and result set 3293 */ 3294 public Ref getRef(String colName) throws SQLException { 3295 return getRef(findColumn(colName)); 3296 } 3297 3298 /** 3299 * Returns the value of the designated column in the current row 3300 * of this rowset's <code>ResultSet</code> object as a <code>Blob</code> object. 3301 * 3302 * @param colName the name of the column from which to retrieve the value 3303 * @return a <code>Blob</code> object representing the SQL <code>BLOB</code> 3304 * value in the specified column 3305 * @throws SQLException if (1) a database access error occurs 3306 * or (2) this rowset does not currently have a valid connection, 3307 * prepared statement, and result set 3308 */ 3309 public Blob getBlob(String colName) throws SQLException { 3310 return getBlob(findColumn(colName)); 3311 } 3312 3313 /** 3314 * Returns the value of the designated column in the current row 3315 * of this rowset's <code>ResultSet</code> object as a <code>Clob</code> object. 3316 * 3317 * @param colName the name of the column from which to retrieve the value 3318 * @return a <code>Clob</code> object representing the SQL <code>CLOB</code> 3319 * value in the specified column 3320 * @throws SQLException if (1) a database access error occurs 3321 * or (2) this rowset does not currently have a valid connection, 3322 * prepared statement, and result set 3323 */ 3324 public Clob getClob(String colName) throws SQLException { 3325 return getClob(findColumn(colName)); 3326 } 3327 3328 /** 3329 * Returns the value of the designated column in the current row 3330 * of this rowset's <code>ResultSet</code> object as an <code>Array</code> object. 3331 * 3332 * @param colName the name of the column from which to retrieve the value 3333 * @return an <code>Array</code> object representing the SQL <code>ARRAY</code> 3334 * value in the specified column 3335 * @throws SQLException if (1) a database access error occurs 3336 * or (2) this rowset does not currently have a valid connection, 3337 * prepared statement, and result set 3338 */ 3339 public Array getArray(String colName) throws SQLException { 3340 return getArray(findColumn(colName)); 3341 } 3342 3343 /** 3344 * Returns the value of the designated column in the current row 3345 * of this rowset's <code>ResultSet</code> object as a <code>java.sql.Date</code> 3346 * object. This method uses the given calendar to construct an appropriate 3347 * millisecond value for the date if the underlying database does not store 3348 * timezone information. 3349 * 3350 * @param columnIndex the first column is 1, the second is 2, and so on 3351 * @param cal the <code>java.util.Calendar</code> object 3352 * to use in constructing the date 3353 * @return the column value as a <code>java.sql.Date</code> object; 3354 * if the value is SQL <code>NULL</code>, 3355 * the value returned is <code>null</code> 3356 * @throws SQLException if (1) a database access error occurs 3357 * or (2) this rowset does not currently have a valid connection, 3358 * prepared statement, and result set 3359 */ 3360 public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLException { 3361 checkState(); 3362 3363 return rs.getDate(columnIndex, cal); 3364 } 3365 3366 /** 3367 * Returns the value of the designated column in the current row 3368 * of this rowset's <code>ResultSet</code> object as a <code>java.sql.Date</code> 3369 * object. This method uses the given calendar to construct an appropriate 3370 * millisecond value for the date if the underlying database does not store 3371 * timezone information. 3372 * 3373 * @param columnName the SQL name of the column from which to retrieve the value 3374 * @param cal the <code>java.util.Calendar</code> object 3375 * to use in constructing the date 3376 * @return the column value as a <code>java.sql.Date</code> object; 3377 * if the value is SQL <code>NULL</code>, 3378 * the value returned is <code>null</code> 3379 * @throws SQLException if a database access error occurs 3380 * or this rowset does not currently have a valid connection, 3381 * prepared statement, and result set 3382 * 3383 */ 3384 public java.sql.Date getDate(String columnName, Calendar cal) throws SQLException { 3385 return getDate(findColumn(columnName), cal); 3386 } 3387 3388 /** 3389 * Returns the value of the designated column in the current row 3390 * of this rowset's <code>ResultSet</code> object as a <code>java.sql.Time</code> 3391 * object. This method uses the given calendar to construct an appropriate 3392 * millisecond value for the date if the underlying database does not store 3393 * timezone information. 3394 * 3395 * @param columnIndex the first column is 1, the second is 2, and so on 3396 * @param cal the <code>java.util.Calendar</code> object 3397 * to use in constructing the time 3398 * @return the column value as a <code>java.sql.Time</code> object; 3399 * if the value is SQL <code>NULL</code>, 3400 * the value returned is <code>null</code> in the Java programming language 3401 * @throws SQLException if a database access error occurs 3402 * or this rowset does not currently have a valid connection, 3403 * prepared statement, and result set 3404 */ 3405 public java.sql.Time getTime(int columnIndex, Calendar cal) throws SQLException { 3406 checkState(); 3407 3408 return rs.getTime(columnIndex, cal); 3409 } 3410 3411 /** 3412 * Returns the value of the designated column in the current row 3413 * of this rowset's <code>ResultSet</code> object as a <code>java.sql.Time</code> 3414 * object. This method uses the given calendar to construct an appropriate 3415 * millisecond value for the date if the underlying database does not store 3416 * timezone information. 3417 * 3418 * @param columnName the SQL name of the column 3419 * @param cal the <code>java.util.Calendar</code> object 3420 * to use in constructing the time 3421 * @return the column value as a <code>java.sql.Time</code> object; 3422 * if the value is SQL <code>NULL</code>, 3423 * the value returned is <code>null</code> in the Java programming language 3424 * @throws SQLException if a database access error occurs 3425 * or this rowset does not currently have a valid connection, 3426 * prepared statement, and result set 3427 */ 3428 public java.sql.Time getTime(String columnName, Calendar cal) throws SQLException { 3429 return getTime(findColumn(columnName), cal); 3430 } 3431 3432 /** 3433 * Returns the value of the designated column in the current row 3434 * of this rowset's <code>ResultSet</code> object as a 3435 * <code>java.sql.Timestamp</code> object. 3436 * This method uses the given calendar to construct an appropriate millisecond 3437 * value for the timestamp if the underlying database does not store 3438 * timezone information. 3439 * 3440 * @param columnIndex the first column is 1, the second is 2, and so on 3441 * @param cal the <code>java.util.Calendar</code> object 3442 * to use in constructing the timestamp 3443 * @return the column value as a <code>java.sql.Timestamp</code> object; 3444 * if the value is SQL <code>NULL</code>, 3445 * the value returned is <code>null</code> 3446 * @throws SQLException if a database access error occurs 3447 * or this rowset does not currently have a valid connection, 3448 * prepared statement, and result set 3449 */ 3450 public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException { 3451 checkState(); 3452 3453 return rs.getTimestamp(columnIndex, cal); 3454 } 3455 3456 /** 3457 * Returns the value of the designated column in the current row 3458 * of this rowset's <code>ResultSet</code> object as a 3459 * <code>java.sql.Timestamp</code> object. 3460 * This method uses the given calendar to construct an appropriate millisecond 3461 * value for the timestamp if the underlying database does not store 3462 * timezone information. 3463 * 3464 * @param columnName the SQL name of the column 3465 * @param cal the <code>java.util.Calendar</code> object 3466 * to use in constructing the timestamp 3467 * @return the column value as a <code>java.sql.Timestamp</code> object; 3468 * if the value is SQL <code>NULL</code>, 3469 * the value returned is <code>null</code> 3470 * @throws SQLException if a database access error occurs 3471 * or this rowset does not currently have a valid connection, 3472 * prepared statement, and result set 3473 */ 3474 public java.sql.Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException { 3475 return getTimestamp(findColumn(columnName), cal); 3476 } 3477 3478 3479 /** 3480 * Sets the designated column in either the current row or the insert 3481 * row of this <code>JdbcRowSetImpl</code> object with the given 3482 * <code>double</code> value. 3483 * 3484 * This method updates a column value in either the current row or 3485 * the insert row of this rowset, but it does not update the 3486 * database. If the cursor is on a row in the rowset, the 3487 * method {@link #updateRow} must be called to update the database. 3488 * If the cursor is on the insert row, the method {@link #insertRow} 3489 * must be called, which will insert the new row into both this rowset 3490 * and the database. Both of these methods must be called before the 3491 * cursor moves to another row. 3492 * 3493 * @param columnIndex the first column is <code>1</code>, the second 3494 * is <code>2</code>, and so on; must be <code>1</code> or larger 3495 * and equal to or less than the number of columns in this rowset 3496 * @param ref the new <code>Ref</code> column value 3497 * @throws SQLException if (1) the given column index is out of bounds, 3498 * (2) the cursor is not on one of this rowset's rows or its 3499 * insert row, or (3) this rowset is 3500 * <code>ResultSet.CONCUR_READ_ONLY</code> 3501 */ 3502 public void updateRef(int columnIndex, java.sql.Ref ref) 3503 throws SQLException { 3504 checkState(); 3505 rs.updateRef(columnIndex, ref); 3506 } 3507 3508 /** 3509 * Sets the designated column in either the current row or the insert 3510 * row of this <code>JdbcRowSetImpl</code> object with the given 3511 * <code>double</code> value. 3512 * 3513 * This method updates a column value in either the current row or 3514 * the insert row of this rowset, but it does not update the 3515 * database. If the cursor is on a row in the rowset, the 3516 * method {@link #updateRow} must be called to update the database. 3517 * If the cursor is on the insert row, the method {@link #insertRow} 3518 * must be called, which will insert the new row into both this rowset 3519 * and the database. Both of these methods must be called before the 3520 * cursor moves to another row. 3521 * 3522 * @param columnName a <code>String</code> object that must match the 3523 * SQL name of a column in this rowset, ignoring case 3524 * @param ref the new column value 3525 * @throws SQLException if (1) the given column name does not match the 3526 * name of a column in this rowset, (2) the cursor is not on 3527 * one of this rowset's rows or its insert row, or (3) this 3528 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> 3529 */ 3530 public void updateRef(String columnName, java.sql.Ref ref) 3531 throws SQLException { 3532 updateRef(findColumn(columnName), ref); 3533 } 3534 3535 /** 3536 * Sets the designated column in either the current row or the insert 3537 * row of this <code>JdbcRowSetImpl</code> object with the given 3538 * <code>double</code> value. 3539 * 3540 * This method updates a column value in either the current row or 3541 * the insert row of this rowset, but it does not update the 3542 * database. If the cursor is on a row in the rowset, the 3543 * method {@link #updateRow} must be called to update the database. 3544 * If the cursor is on the insert row, the method {@link #insertRow} 3545 * must be called, which will insert the new row into both this rowset 3546 * and the database. Both of these methods must be called before the 3547 * cursor moves to another row. 3548 * 3549 * @param columnIndex the first column is <code>1</code>, the second 3550 * is <code>2</code>, and so on; must be <code>1</code> or larger 3551 * and equal to or less than the number of columns in this rowset 3552 * @param c the new column <code>Clob</code> value 3553 * @throws SQLException if (1) the given column index is out of bounds, 3554 * (2) the cursor is not on one of this rowset's rows or its 3555 * insert row, or (3) this rowset is 3556 * <code>ResultSet.CONCUR_READ_ONLY</code> 3557 */ 3558 public void updateClob(int columnIndex, Clob c) throws SQLException { 3559 checkState(); 3560 rs.updateClob(columnIndex, c); 3561 } 3562 3563 3564 /** 3565 * Sets the designated column in either the current row or the insert 3566 * row of this <code>JdbcRowSetImpl</code> object with the given 3567 * <code>double</code> value. 3568 * 3569 * This method updates a column value in either the current row or 3570 * the insert row of this rowset, but it does not update the 3571 * database. If the cursor is on a row in the rowset, the 3572 * method {@link #updateRow} must be called to update the database. 3573 * If the cursor is on the insert row, the method {@link #insertRow} 3574 * must be called, which will insert the new row into both this rowset 3575 * and the database. Both of these methods must be called before the 3576 * cursor moves to another row. 3577 * 3578 * @param columnName a <code>String</code> object that must match the 3579 * SQL name of a column in this rowset, ignoring case 3580 * @param c the new column <code>Clob</code> value 3581 * @throws SQLException if (1) the given column name does not match the 3582 * name of a column in this rowset, (2) the cursor is not on 3583 * one of this rowset's rows or its insert row, or (3) this 3584 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> 3585 */ 3586 public void updateClob(String columnName, Clob c) throws SQLException { 3587 updateClob(findColumn(columnName), c); 3588 } 3589 3590 /** 3591 * Sets the designated column in either the current row or the insert 3592 * row of this <code>JdbcRowSetImpl</code> object with the given 3593 * <code>java.sql.Blob</code> value. 3594 * 3595 * This method updates a column value in either the current row or 3596 * the insert row of this rowset, but it does not update the 3597 * database. If the cursor is on a row in the rowset, the 3598 * method {@link #updateRow} must be called to update the database. 3599 * If the cursor is on the insert row, the method {@link #insertRow} 3600 * must be called, which will insert the new row into both this rowset 3601 * and the database. Both of these methods must be called before the 3602 * cursor moves to another row. 3603 * 3604 * @param columnIndex the first column is <code>1</code>, the second 3605 * is <code>2</code>, and so on; must be <code>1</code> or larger 3606 * and equal to or less than the number of columns in this rowset 3607 * @param b the new column <code>Blob</code> value 3608 * @throws SQLException if (1) the given column index is out of bounds, 3609 * (2) the cursor is not on one of this rowset's rows or its 3610 * insert row, or (3) this rowset is 3611 * <code>ResultSet.CONCUR_READ_ONLY</code> 3612 */ 3613 public void updateBlob(int columnIndex, Blob b) throws SQLException { 3614 checkState(); 3615 rs.updateBlob(columnIndex, b); 3616 } 3617 3618 /** 3619 * Sets the designated column in either the current row or the insert 3620 * row of this <code>JdbcRowSetImpl</code> object with the given 3621 * <code>java.sql.Blob </code> value. 3622 * 3623 * This method updates a column value in either the current row or 3624 * the insert row of this rowset, but it does not update the 3625 * database. If the cursor is on a row in the rowset, the 3626 * method {@link #updateRow} must be called to update the database. 3627 * If the cursor is on the insert row, the method {@link #insertRow} 3628 * must be called, which will insert the new row into both this rowset 3629 * and the database. Both of these methods must be called before the 3630 * cursor moves to another row. 3631 * 3632 * @param columnName a <code>String</code> object that must match the 3633 * SQL name of a column in this rowset, ignoring case 3634 * @param b the new column <code>Blob</code> value 3635 * @throws SQLException if (1) the given column name does not match the 3636 * name of a column in this rowset, (2) the cursor is not on 3637 * one of this rowset's rows or its insert row, or (3) this 3638 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> 3639 */ 3640 public void updateBlob(String columnName, Blob b) throws SQLException { 3641 updateBlob(findColumn(columnName), b); 3642 } 3643 3644 /** 3645 * Sets the designated column in either the current row or the insert 3646 * row of this <code>JdbcRowSetImpl</code> object with the given 3647 * <code>java.sql.Array</code> values. 3648 * 3649 * This method updates a column value in either the current row or 3650 * the insert row of this rowset, but it does not update the 3651 * database. If the cursor is on a row in the rowset, the 3652 * method {@link #updateRow} must be called to update the database. 3653 * If the cursor is on the insert row, the method {@link #insertRow} 3654 * must be called, which will insert the new row into both this rowset 3655 * and the database. Both of these methods must be called before the 3656 * cursor moves to another row. 3657 * 3658 * @param columnIndex the first column is <code>1</code>, the second 3659 * is <code>2</code>, and so on; must be <code>1</code> or larger 3660 * and equal to or less than the number of columns in this rowset 3661 * @param a the new column <code>Array</code> value 3662 * @throws SQLException if (1) the given column index is out of bounds, 3663 * (2) the cursor is not on one of this rowset's rows or its 3664 * insert row, or (3) this rowset is 3665 * <code>ResultSet.CONCUR_READ_ONLY</code> 3666 */ 3667 public void updateArray(int columnIndex, Array a) throws SQLException { 3668 checkState(); 3669 rs.updateArray(columnIndex, a); 3670 } 3671 3672 /** 3673 * Sets the designated column in either the current row or the insert 3674 * row of this <code>JdbcRowSetImpl</code> object with the given 3675 * <code>java.sql.Array</code> value. 3676 * 3677 * This method updates a column value in either the current row or 3678 * the insert row of this rowset, but it does not update the 3679 * database. If the cursor is on a row in the rowset, the 3680 * method {@link #updateRow} must be called to update the database. 3681 * If the cursor is on the insert row, the method {@link #insertRow} 3682 * must be called, which will insert the new row into both this rowset 3683 * and the database. Both of these methods must be called before the 3684 * cursor moves to another row. 3685 * 3686 * @param columnName a <code>String</code> object that must match the 3687 * SQL name of a column in this rowset, ignoring case 3688 * @param a the new column <code>Array</code> value 3689 * @throws SQLException if (1) the given column name does not match the 3690 * name of a column in this rowset, (2) the cursor is not on 3691 * one of this rowset's rows or its insert row, or (3) this 3692 * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> 3693 */ 3694 public void updateArray(String columnName, Array a) throws SQLException { 3695 updateArray(findColumn(columnName), a); 3696 } 3697 3698 /** 3699 * Provide interface coverage for getURL(int) in ResultSet->RowSet 3700 */ 3701 public java.net.URL getURL(int columnIndex) throws SQLException { 3702 checkState(); 3703 return rs.getURL(columnIndex); 3704 } 3705 3706 /** 3707 * Provide interface coverage for getURL(String) in ResultSet->RowSet 3708 */ 3709 public java.net.URL getURL(String columnName) throws SQLException { 3710 return getURL(findColumn(columnName)); 3711 } 3712 3713 /** 3714 * Return the RowSetWarning object for the current row of a 3715 * <code>JdbcRowSetImpl</code> 3716 */ 3717 public RowSetWarning getRowSetWarnings() throws SQLException { 3718 return null; 3719 } 3720 /** 3721 * Unsets the designated parameter to the given int array. 3722 * This was set using <code>setMatchColumn</code> 3723 * as the column which will form the basis of the join. 3724 * <P> 3725 * The parameter value unset by this method should be same 3726 * as was set. 3727 * 3728 * @param columnIdxes the index into this rowset 3729 * object's internal representation of parameter values 3730 * @throws SQLException if an error occurs or the 3731 * parameter index is out of bounds or if the columnIdx is 3732 * not the same as set using <code>setMatchColumn(int [])</code> 3733 */ 3734 public void unsetMatchColumn(int[] columnIdxes) throws SQLException { 3735 3736 int i_val; 3737 for( int j= 0 ;j < columnIdxes.length; j++) { 3738 i_val = (Integer.parseInt(iMatchColumns.get(j).toString())); 3739 if(columnIdxes[j] != i_val) { 3740 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols").toString()); 3741 } 3742 } 3743 3744 for( int i = 0;i < columnIdxes.length ;i++) { 3745 iMatchColumns.set(i,Integer.valueOf(-1)); 3746 } 3747 } 3748 3749 /** 3750 * Unsets the designated parameter to the given String array. 3751 * This was set using <code>setMatchColumn</code> 3752 * as the column which will form the basis of the join. 3753 * <P> 3754 * The parameter value unset by this method should be same 3755 * as was set. 3756 * 3757 * @param columnIdxes the index into this rowset 3758 * object's internal representation of parameter values 3759 * @throws SQLException if an error occurs or the 3760 * parameter index is out of bounds or if the columnName is 3761 * not the same as set using <code>setMatchColumn(String [])</code> 3762 */ 3763 public void unsetMatchColumn(String[] columnIdxes) throws SQLException { 3764 3765 for(int j = 0 ;j < columnIdxes.length; j++) { 3766 if( !columnIdxes[j].equals(strMatchColumns.get(j)) ){ 3767 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols").toString()); 3768 } 3769 } 3770 3771 for(int i = 0 ; i < columnIdxes.length; i++) { 3772 strMatchColumns.set(i,null); 3773 } 3774 } 3775 3776 /** 3777 * Retrieves the column name as <code>String</code> array 3778 * that was set using <code>setMatchColumn(String [])</code> 3779 * for this rowset. 3780 * 3781 * @return a <code>String</code> array object that contains the column names 3782 * for the rowset which has this the match columns 3783 * 3784 * @throws SQLException if an error occurs or column name is not set 3785 */ 3786 public String[] getMatchColumnNames() throws SQLException { 3787 3788 String []str_temp = new String[strMatchColumns.size()]; 3789 3790 if( strMatchColumns.get(0) == null) { 3791 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.setmatchcols").toString()); 3792 } 3793 3794 strMatchColumns.copyInto(str_temp); 3795 return str_temp; 3796 } 3797 3798 /** 3799 * Retrieves the column id as <code>int</code> array that was set using 3800 * <code>setMatchColumn(int [])</code> for this rowset. 3801 * 3802 * @return a <code>int</code> array object that contains the column ids 3803 * for the rowset which has this as the match columns. 3804 * 3805 * @throws SQLException if an error occurs or column index is not set 3806 */ 3807 public int[] getMatchColumnIndexes() throws SQLException { 3808 3809 Integer []int_temp = new Integer[iMatchColumns.size()]; 3810 int [] i_temp = new int[iMatchColumns.size()]; 3811 int i_val; 3812 3813 i_val = iMatchColumns.get(0); 3814 3815 if( i_val == -1 ) { 3816 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.setmatchcols").toString()); 3817 } 3818 3819 3820 iMatchColumns.copyInto(int_temp); 3821 3822 for(int i = 0; i < int_temp.length; i++) { 3823 i_temp[i] = (int_temp[i]).intValue(); 3824 } 3825 3826 return i_temp; 3827 } 3828 3829 /** 3830 * Sets the designated parameter to the given int array. 3831 * This forms the basis of the join for the 3832 * <code>JoinRowSet</code> as the column which will form the basis of the 3833 * join. 3834 * <P> 3835 * The parameter value set by this method is stored internally and 3836 * will be supplied as the appropriate parameter in this rowset's 3837 * command when the method <code>getMatchColumnIndexes</code> is called. 3838 * 3839 * @param columnIdxes the indexes into this rowset 3840 * object's internal representation of parameter values; the 3841 * first parameter is 0, the second is 1, and so on; must be 3842 * <code>0</code> or greater 3843 * @throws SQLException if an error occurs or the 3844 * parameter index is out of bounds 3845 */ 3846 public void setMatchColumn(int[] columnIdxes) throws SQLException { 3847 3848 for(int j = 0 ; j < columnIdxes.length; j++) { 3849 if( columnIdxes[j] < 0 ) { 3850 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols1").toString()); 3851 } 3852 } 3853 for(int i = 0 ;i < columnIdxes.length; i++) { 3854 iMatchColumns.add(i,Integer.valueOf(columnIdxes[i])); 3855 } 3856 } 3857 3858 /** 3859 * Sets the designated parameter to the given String array. 3860 * This forms the basis of the join for the 3861 * <code>JoinRowSet</code> as the column which will form the basis of the 3862 * join. 3863 * <P> 3864 * The parameter value set by this method is stored internally and 3865 * will be supplied as the appropriate parameter in this rowset's 3866 * command when the method <code>getMatchColumn</code> is called. 3867 * 3868 * @param columnNames the name of the column into this rowset 3869 * object's internal representation of parameter values 3870 * @throws SQLException if an error occurs or the 3871 * parameter index is out of bounds 3872 */ 3873 public void setMatchColumn(String[] columnNames) throws SQLException { 3874 3875 for(int j = 0; j < columnNames.length; j++) { 3876 if( columnNames[j] == null || columnNames[j].equals("")) { 3877 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols2").toString()); 3878 } 3879 } 3880 for( int i = 0; i < columnNames.length; i++) { 3881 strMatchColumns.add(i,columnNames[i]); 3882 } 3883 } 3884 3885 3886 /** 3887 * Sets the designated parameter to the given <code>int</code> 3888 * object. This forms the basis of the join for the 3889 * <code>JoinRowSet</code> as the column which will form the basis of the 3890 * join. 3891 * <P> 3892 * The parameter value set by this method is stored internally and 3893 * will be supplied as the appropriate parameter in this rowset's 3894 * command when the method <code>getMatchColumn</code> is called. 3895 * 3896 * @param columnIdx the index into this rowset 3897 * object's internal representation of parameter values; the 3898 * first parameter is 0, the second is 1, and so on; must be 3899 * <code>0</code> or greater 3900 * @throws SQLException if an error occurs or the 3901 * parameter index is out of bounds 3902 */ 3903 public void setMatchColumn(int columnIdx) throws SQLException { 3904 // validate, if col is ok to be set 3905 if(columnIdx < 0) { 3906 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols1").toString()); 3907 } else { 3908 // set iMatchColumn 3909 iMatchColumns.set(0, Integer.valueOf(columnIdx)); 3910 //strMatchColumn = null; 3911 } 3912 } 3913 3914 /** 3915 * Sets the designated parameter to the given <code>String</code> 3916 * object. This forms the basis of the join for the 3917 * <code>JoinRowSet</code> as the column which will form the basis of the 3918 * join. 3919 * <P> 3920 * The parameter value set by this method is stored internally and 3921 * will be supplied as the appropriate parameter in this rowset's 3922 * command when the method <code>getMatchColumn</code> is called. 3923 * 3924 * @param columnName the name of the column into this rowset 3925 * object's internal representation of parameter values 3926 * @throws SQLException if an error occurs or the 3927 * parameter index is out of bounds 3928 */ 3929 public void setMatchColumn(String columnName) throws SQLException { 3930 // validate, if col is ok to be set 3931 if(columnName == null || (columnName= columnName.trim()).equals("")) { 3932 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols2").toString()); 3933 } else { 3934 // set strMatchColumn 3935 strMatchColumns.set(0, columnName); 3936 //iMatchColumn = -1; 3937 } 3938 } 3939 3940 /** 3941 * Unsets the designated parameter to the given <code>int</code> 3942 * object. This was set using <code>setMatchColumn</code> 3943 * as the column which will form the basis of the join. 3944 * <P> 3945 * The parameter value unset by this method should be same 3946 * as was set. 3947 * 3948 * @param columnIdx the index into this rowset 3949 * object's internal representation of parameter values 3950 * @throws SQLException if an error occurs or the 3951 * parameter index is out of bounds or if the columnIdx is 3952 * not the same as set using <code>setMatchColumn(int)</code> 3953 */ 3954 public void unsetMatchColumn(int columnIdx) throws SQLException { 3955 // check if we are unsetting the SAME column 3956 if(! iMatchColumns.get(0).equals(Integer.valueOf(columnIdx) ) ) { 3957 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.unsetmatch").toString()); 3958 } else if(strMatchColumns.get(0) != null) { 3959 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.usecolname").toString()); 3960 } else { 3961 // that is, we are unsetting it. 3962 iMatchColumns.set(0, Integer.valueOf(-1)); 3963 } 3964 } 3965 3966 /** 3967 * Unsets the designated parameter to the given <code>String</code> 3968 * object. This was set using <code>setMatchColumn</code> 3969 * as the column which will form the basis of the join. 3970 * <P> 3971 * The parameter value unset by this method should be same 3972 * as was set. 3973 * 3974 * @param columnName the index into this rowset 3975 * object's internal representation of parameter values 3976 * @throws SQLException if an error occurs or the 3977 * parameter index is out of bounds or if the columnName is 3978 * not the same as set using <code>setMatchColumn(String)</code> 3979 * 3980 */ 3981 public void unsetMatchColumn(String columnName) throws SQLException { 3982 // check if we are unsetting the same column 3983 columnName = columnName.trim(); 3984 3985 if(!((strMatchColumns.get(0)).equals(columnName))) { 3986 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.unsetmatch").toString()); 3987 } else if(iMatchColumns.get(0) > 0) { 3988 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.usecolid").toString()); 3989 } else { 3990 strMatchColumns.set(0, null); // that is, we are unsetting it. 3991 } 3992 } 3993 3994 /** 3995 * Retrieves the <code>DatabaseMetaData</code> associated with 3996 * the connection handle associated with this 3997 * <code>JdbcRowSet</code> object. 3998 * 3999 * @return the <code>DatabaseMetadata</code> associated 4000 * with the rowset's connection. 4001 * @throws SQLException if a database access error occurs 4002 */ 4003 public DatabaseMetaData getDatabaseMetaData() throws SQLException { 4004 Connection con = connect(); 4005 return con.getMetaData(); 4006 } 4007 4008 /** 4009 * Retrieves the <code>ParameterMetaData</code> associated with 4010 * the connection handle associated with this 4011 * <code>JdbcRowSet</code> object. 4012 * 4013 * @return the <code>ParameterMetadata</code> associated 4014 * with the rowset's connection. 4015 * @throws SQLException if a database access error occurs 4016 */ 4017 public ParameterMetaData getParameterMetaData() throws SQLException { 4018 prepare(); 4019 return (ps.getParameterMetaData()); 4020 } 4021 4022 /** 4023 * Commits all updates in this <code>JdbcRowSet</code> object by 4024 * wrapping the internal <code>Connection</code> object and calling 4025 * its <code>commit</code> method. 4026 * This method sets this <code>JdbcRowSet</code> object's private field 4027 * <code>rs</code> to <code>null</code> after saving its value to another 4028 * object, but only if the <code>ResultSet</code> 4029 * constant <code>HOLD_CURSORS_OVER_COMMIT</code> has not been set. 4030 * (The field <code>rs</code> is this <code>JdbcRowSet</code> object's 4031 * <code>ResultSet</code> object.) 4032 * 4033 * @throws SQLException if autoCommit is set to true or if a database 4034 * access error occurs 4035 */ 4036 public void commit() throws SQLException { 4037 conn.commit(); 4038 4039 // Checking the holadbility value and making the result set handle null 4040 // Added as per Rave requirements 4041 4042 if( conn.getHoldability() != HOLD_CURSORS_OVER_COMMIT) { 4043 rs = null; 4044 } 4045 } 4046 4047 /** 4048 * Sets auto-commit on the internal <code>Connection</code> object with this 4049 * <code>JdbcRowSet</code> 4050 * 4051 * @throws SQLException if a database access error occurs 4052 */ 4053 public void setAutoCommit(boolean autoCommit) throws SQLException { 4054 // The connection object should be there 4055 // in order to commit the connection handle on or off. 4056 4057 if(conn != null) { 4058 conn.setAutoCommit(autoCommit); 4059 } else { 4060 // Coming here means the connection object is null. 4061 // So generate a connection handle internally, since 4062 // a JdbcRowSet is always connected to a db, it is fine 4063 // to get a handle to the connection. 4064 4065 // Get hold of a connection handle 4066 // and change the autcommit as passesd. 4067 conn = connect(); 4068 4069 // After setting the below the conn.getAutoCommit() 4070 // should return the same value. 4071 conn.setAutoCommit(autoCommit); 4072 4073 } 4074 } 4075 4076 /** 4077 * Returns the auto-commit status with this <code>JdbcRowSet</code>. 4078 * 4079 * @return true if auto commit is true; false otherwise 4080 * @throws SQLException if a database access error occurs 4081 */ 4082 public boolean getAutoCommit() throws SQLException { 4083 return conn.getAutoCommit(); 4084 } 4085 4086 /** 4087 * Rolls back all the updates in this <code>JdbcRowSet</code> object by 4088 * wrapping the internal <code>Connection</code> object and calling its 4089 * <code>rollback</code> method. 4090 * This method sets this <code>JdbcRowSet</code> object's private field 4091 * <code>rs</code> to <code>null</code> after saving its value to another object. 4092 * (The field <code>rs</code> is this <code>JdbcRowSet</code> object's 4093 * internal <code>ResultSet</code> object.) 4094 * 4095 * @throws SQLException if autoCommit is set to true or a database 4096 * access error occurs 4097 */ 4098 public void rollback() throws SQLException { 4099 conn.rollback(); 4100 4101 // Makes the result ste handle null after rollback 4102 // Added as per Rave requirements 4103 4104 rs = null; 4105 } 4106 4107 4108 /** 4109 * Rollbacks all the updates in the <code>JdbcRowSet</code> back to the 4110 * last <code>Savepoint</code> transaction marker. Wraps the internal 4111 * <code>Connection</code> object and call it's rollback method 4112 * 4113 * @param s the <code>Savepoint</code> transaction marker to roll the 4114 * transaction to. 4115 * @throws SQLException if autoCommit is set to true; or ia a database 4116 * access error occurs 4117 */ 4118 public void rollback(Savepoint s) throws SQLException { 4119 conn.rollback(s); 4120 } 4121 4122 // Setting the ResultSet Type and Concurrency 4123 protected void setParams() throws SQLException { 4124 if(rs == null) { 4125 setType(ResultSet.TYPE_SCROLL_INSENSITIVE); 4126 setConcurrency(ResultSet.CONCUR_UPDATABLE); 4127 } 4128 else { 4129 setType(rs.getType()); 4130 setConcurrency(rs.getConcurrency()); 4131 } 4132 } 4133 4134 4135 // Checking ResultSet Type and Concurrency 4136 private void checkTypeConcurrency() throws SQLException { 4137 if(rs.getType() == TYPE_FORWARD_ONLY || 4138 rs.getConcurrency() == CONCUR_READ_ONLY) { 4139 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.resnotupd").toString()); 4140 } 4141 } 4142 4143 // Returns a Connection Handle 4144 // Added as per Rave requirements 4145 4146 /** 4147 * Gets this <code>JdbcRowSet</code> object's Connection property 4148 * 4149 * 4150 * @return the <code>Connection</code> object associated with this rowset; 4151 */ 4152 4153 protected Connection getConnection() { 4154 return conn; 4155 } 4156 4157 // Sets the connection handle with the parameter 4158 // Added as per rave requirements 4159 4160 /** 4161 * Sets this <code>JdbcRowSet</code> object's connection property 4162 * to the given <code>Connection</code> object. 4163 * 4164 * @param connection the <code>Connection</code> object. 4165 */ 4166 4167 protected void setConnection(Connection connection) { 4168 conn = connection; 4169 } 4170 4171 // Returns a PreparedStatement Handle 4172 // Added as per Rave requirements 4173 4174 /** 4175 * Gets this <code>JdbcRowSet</code> object's PreparedStatement property 4176 * 4177 * 4178 * @return the <code>PreparedStatement</code> object associated with this rowset; 4179 */ 4180 4181 protected PreparedStatement getPreparedStatement() { 4182 return ps; 4183 } 4184 4185 //Sets the prepared statement handle to the parameter 4186 // Added as per Rave requirements 4187 4188 /** 4189 * Sets this <code>JdbcRowSet</code> object's preparedtsatement property 4190 * to the given <code>PreparedStatemennt</code> object. 4191 * 4192 * @param preparedStatement the <code>PreparedStatement</code> object 4193 * 4194 */ 4195 protected void setPreparedStatement(PreparedStatement preparedStatement) { 4196 ps = preparedStatement; 4197 } 4198 4199 // Returns a ResultSet handle 4200 // Added as per Rave requirements 4201 4202 /** 4203 * Gets this <code>JdbcRowSet</code> object's ResultSet property 4204 * 4205 * 4206 * @return the <code>ResultSet</code> object associated with this rowset; 4207 */ 4208 4209 protected ResultSet getResultSet() throws SQLException { 4210 4211 checkState(); 4212 4213 return rs; 4214 } 4215 4216 // Sets the result set handle to the parameter 4217 // Added as per Rave requirements 4218 4219 /** 4220 * Sets this <code>JdbcRowSet</code> object's resultset property 4221 * to the given <code>ResultSet</code> object. 4222 * 4223 * @param resultSet the <code>ResultSet</code> object 4224 * 4225 */ 4226 protected void setResultSet(ResultSet resultSet) { 4227 rs = resultSet; 4228 } 4229 4230 /** 4231 * Sets this <code>JdbcRowSet</code> object's <code>command</code> property to 4232 * the given <code>String</code> object and clears the parameters, if any, 4233 * that were set for the previous command. In addition, 4234 * if the <code>command</code> property has previously been set to a 4235 * non-null value and it is 4236 * different from the <code>String</code> object supplied, 4237 * this method sets this <code>JdbcRowSet</code> object's private fields 4238 * <code>ps</code> and <code>rs</code> to <code>null</code>. 4239 * (The field <code>ps</code> is its <code>PreparedStatement</code> object, and 4240 * the field <code>rs</code> is its <code>ResultSet</code> object.) 4241 * <P> 4242 * The <code>command</code> property may not be needed if the <code>RowSet</code> 4243 * object gets its data from a source that does not support commands, 4244 * such as a spreadsheet or other tabular file. 4245 * Thus, this property is optional and may be <code>null</code>. 4246 * 4247 * @param command a <code>String</code> object containing an SQL query 4248 * that will be set as this <code>RowSet</code> object's command 4249 * property; may be <code>null</code> but may not be an empty string 4250 * @throws SQLException if an empty string is provided as the command value 4251 * @see #getCommand 4252 */ 4253 public void setCommand(String command) throws SQLException { 4254 4255 if (getCommand() != null) { 4256 if(!getCommand().equals(command)) { 4257 super.setCommand(command); 4258 ps = null; 4259 rs = null; 4260 } 4261 } 4262 else { 4263 super.setCommand(command); 4264 } 4265 } 4266 4267 /** 4268 * Sets the <code>dataSourceName</code> property for this <code>JdbcRowSet</code> 4269 * object to the given logical name and sets this <code>JdbcRowSet</code> object's 4270 * Url property to <code>null</code>. In addition, if the <code>dataSourceName</code> 4271 * property has previously been set and is different from the one supplied, 4272 * this method sets this <code>JdbcRowSet</code> object's private fields 4273 * <code>ps</code>, <code>rs</code>, and <code>conn</code> to <code>null</code>. 4274 * (The field <code>ps</code> is its <code>PreparedStatement</code> object, 4275 * the field <code>rs</code> is its <code>ResultSet</code> object, and 4276 * the field <code>conn</code> is its <code>Connection</code> object.) 4277 * <P> 4278 * The name supplied to this method must have been bound to a 4279 * <code>DataSource</code> object in a JNDI naming service so that an 4280 * application can do a lookup using that name to retrieve the 4281 * <code>DataSource</code> object bound to it. The <code>DataSource</code> 4282 * object can then be used to establish a connection to the data source it 4283 * represents. 4284 * <P> 4285 * Users should set either the Url property or the dataSourceName property. 4286 * If both properties are set, the driver will use the property set most recently. 4287 * 4288 * @param dsName a <code>String</code> object with the name that can be supplied 4289 * to a naming service based on JNDI technology to retrieve the 4290 * <code>DataSource</code> object that can be used to get a connection; 4291 * may be <code>null</code> 4292 * @throws SQLException if there is a problem setting the 4293 * <code>dataSourceName</code> property 4294 * @see #getDataSourceName 4295 */ 4296 public void setDataSourceName(String dsName) throws SQLException{ 4297 4298 if(getDataSourceName() != null) { 4299 if(!getDataSourceName().equals(dsName)) { 4300 super.setDataSourceName(dsName); 4301 conn = null; 4302 ps = null; 4303 rs = null; 4304 } 4305 } 4306 else { 4307 super.setDataSourceName(dsName); 4308 } 4309 } 4310 4311 4312 /** 4313 * Sets the Url property for this <code>JdbcRowSet</code> object 4314 * to the given <code>String</code> object and sets the dataSource name 4315 * property to <code>null</code>. In addition, if the Url property has 4316 * previously been set to a non <code>null</code> value and its value 4317 * is different from the value to be set, 4318 * this method sets this <code>JdbcRowSet</code> object's private fields 4319 * <code>ps</code>, <code>rs</code>, and <code>conn</code> to <code>null</code>. 4320 * (The field <code>ps</code> is its <code>PreparedStatement</code> object, 4321 * the field <code>rs</code> is its <code>ResultSet</code> object, and 4322 * the field <code>conn</code> is its <code>Connection</code> object.) 4323 * <P> 4324 * The Url property is a JDBC URL that is used when 4325 * the connection is created using a JDBC technology-enabled driver 4326 * ("JDBC driver") and the <code>DriverManager</code>. 4327 * The correct JDBC URL for the specific driver to be used can be found 4328 * in the driver documentation. Although there are guidelines for how 4329 * a JDBC URL is formed, 4330 * a driver vendor can specify any <code>String</code> object except 4331 * one with a length of <code>0</code> (an empty string). 4332 * <P> 4333 * Setting the Url property is optional if connections are established using 4334 * a <code>DataSource</code> object instead of the <code>DriverManager</code>. 4335 * The driver will use either the URL property or the 4336 * dataSourceName property to create a connection, whichever was 4337 * specified most recently. If an application uses a JDBC URL, it 4338 * must load a JDBC driver that accepts the JDBC URL before it uses the 4339 * <code>RowSet</code> object to connect to a database. The <code>RowSet</code> 4340 * object will use the URL internally to create a database connection in order 4341 * to read or write data. 4342 * 4343 * @param url a <code>String</code> object that contains the JDBC URL 4344 * that will be used to establish the connection to a database for this 4345 * <code>RowSet</code> object; may be <code>null</code> but must not 4346 * be an empty string 4347 * @throws SQLException if an error occurs setting the Url property or the 4348 * parameter supplied is a string with a length of <code>0</code> (an 4349 * empty string) 4350 * @see #getUrl 4351 */ 4352 4353 public void setUrl(String url) throws SQLException { 4354 4355 if(getUrl() != null) { 4356 if(!getUrl().equals(url)) { 4357 super.setUrl(url); 4358 conn = null; 4359 ps = null; 4360 rs = null; 4361 } 4362 } 4363 else { 4364 super.setUrl(url); 4365 } 4366 } 4367 4368 /** 4369 * Sets the username property for this <code>JdbcRowSet</code> object 4370 * to the given user name. Because it 4371 * is not serialized, the username property is set at run time before 4372 * calling the method <code>execute</code>. In addition, 4373 * if the <code>username</code> property is already set with a 4374 * non-null value and that value is different from the <code>String</code> 4375 * object to be set, 4376 * this method sets this <code>JdbcRowSet</code> object's private fields 4377 * <code>ps</code>, <code>rs</code>, and <code>conn</code> to <code>null</code>. 4378 * (The field <code>ps</code> is its <code>PreparedStatement</code> object, 4379 * <code>rs</code> is its <code>ResultSet</code> object, and 4380 * <code>conn</code> is its <code>Connection</code> object.) 4381 * Setting these fields to <code>null</code> ensures that only current 4382 * values will be used. 4383 * 4384 * @param uname the <code>String</code> object containing the user name that 4385 * is supplied to the data source to create a connection. It may be null. 4386 * @see #getUsername 4387 */ 4388 public void setUsername(String uname) { 4389 4390 if( getUsername() != null) { 4391 if(!getUsername().equals(uname)) { 4392 super.setUsername(uname); 4393 conn = null; 4394 ps = null; 4395 rs = null; 4396 } 4397 } 4398 else{ 4399 super.setUsername(uname); 4400 } 4401 } 4402 4403 /** 4404 * Sets the password property for this <code>JdbcRowSet</code> object 4405 * to the given <code>String</code> object. Because it 4406 * is not serialized, the password property is set at run time before 4407 * calling the method <code>execute</code>. Its default valus is 4408 * <code>null</code>. In addition, 4409 * if the <code>password</code> property is already set with a 4410 * non-null value and that value is different from the one being set, 4411 * this method sets this <code>JdbcRowSet</code> object's private fields 4412 * <code>ps</code>, <code>rs</code>, and <code>conn</code> to <code>null</code>. 4413 * (The field <code>ps</code> is its <code>PreparedStatement</code> object, 4414 * <code>rs</code> is its <code>ResultSet</code> object, and 4415 * <code>conn</code> is its <code>Connection</code> object.) 4416 * Setting these fields to <code>null</code> ensures that only current 4417 * values will be used. 4418 * 4419 * @param password the <code>String</code> object that represents the password 4420 * that must be supplied to the database to create a connection 4421 */ 4422 public void setPassword(String password) { 4423 4424 if ( getPassword() != null) { 4425 if(!getPassword().equals(password)) { 4426 super.setPassword(password); 4427 conn = null; 4428 ps = null; 4429 rs = null; 4430 } 4431 } 4432 else{ 4433 super.setPassword(password); 4434 } 4435 } 4436 4437 /** 4438 * Sets the type for this <code>RowSet</code> object to the specified type. 4439 * The default type is <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>. 4440 * 4441 * @param type one of the following constants: 4442 * <code>ResultSet.TYPE_FORWARD_ONLY</code>, 4443 * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or 4444 * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code> 4445 * @throws SQLException if the parameter supplied is not one of the 4446 * following constants: 4447 * <code>ResultSet.TYPE_FORWARD_ONLY</code> or 4448 * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code> 4449 * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code> 4450 * @see #getConcurrency 4451 * @see #getType 4452 */ 4453 4454 public void setType(int type) throws SQLException { 4455 4456 int oldVal; 4457 4458 try { 4459 oldVal = getType(); 4460 }catch(SQLException ex) { 4461 oldVal = 0; 4462 } 4463 4464 if(oldVal != type) { 4465 super.setType(type); 4466 } 4467 4468 } 4469 4470 /** 4471 * Sets the concurrency for this <code>RowSet</code> object to 4472 * the specified concurrency. The default concurrency for any <code>RowSet</code> 4473 * object (connected or disconnected) is <code>ResultSet.CONCUR_UPDATABLE</code>, 4474 * but this method may be called at any time to change the concurrency. 4475 * 4476 * @param concur one of the following constants: 4477 * <code>ResultSet.CONCUR_READ_ONLY</code> or 4478 * <code>ResultSet.CONCUR_UPDATABLE</code> 4479 * @throws SQLException if the parameter supplied is not one of the 4480 * following constants: 4481 * <code>ResultSet.CONCUR_UPDATABLE</code> or 4482 * <code>ResultSet.CONCUR_READ_ONLY</code> 4483 * @see #getConcurrency 4484 * @see #isReadOnly 4485 */ 4486 public void setConcurrency(int concur) throws SQLException { 4487 4488 int oldVal; 4489 4490 try { 4491 oldVal = getConcurrency(); 4492 }catch(NullPointerException ex) { 4493 oldVal = 0; 4494 } 4495 4496 if(oldVal != concur) { 4497 super.setConcurrency(concur); 4498 } 4499 4500 } 4501 4502 /** 4503 * Retrieves the value of the designated <code>SQL XML</code> parameter as a 4504 * <code>SQLXML</code> object in the Java programming language. 4505 * @param columnIndex the first column is 1, the second is 2, ... 4506 * @return a SQLXML object that maps an SQL XML value 4507 * @throws SQLException if a database access error occurs 4508 * @since 1.6 4509 */ 4510 public SQLXML getSQLXML(int columnIndex) throws SQLException { 4511 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4512 } 4513 4514 /** 4515 * Retrieves the value of the designated <code>SQL XML</code> parameter as a 4516 * <code>SQLXML</code> object in the Java programming language. 4517 * @param colName the name of the column from which to retrieve the value 4518 * @return a SQLXML object that maps an SQL XML value 4519 * @throws SQLException if a database access error occurs 4520 */ 4521 public SQLXML getSQLXML(String colName) throws SQLException { 4522 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4523 } 4524 4525 /** 4526 * Retrieves the value of the designated column in the current row of this 4527 * <code>ResultSet</code> object as a java.sql.RowId object in the Java 4528 * programming language. 4529 * 4530 * @param columnIndex the first column is 1, the second 2, ... 4531 * @return the column value if the value is a SQL <code>NULL</code> the 4532 * value returned is <code>null</code> 4533 * @throws SQLException if a database access error occurs 4534 * @since 1.6 4535 */ 4536 public RowId getRowId(int columnIndex) throws SQLException { 4537 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4538 } 4539 4540 /** 4541 * Retrieves the value of the designated column in the current row of this 4542 * <code>ResultSet</code> object as a java.sql.RowId object in the Java 4543 * programming language. 4544 * 4545 * @param columnName the name of the column 4546 * @return the column value if the value is a SQL <code>NULL</code> the 4547 * value returned is <code>null</code> 4548 * @throws SQLException if a database access error occurs 4549 * @since 1.6 4550 */ 4551 public RowId getRowId(String columnName) throws SQLException { 4552 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4553 } 4554 4555 /** 4556 * Updates the designated column with a <code>RowId</code> value. The updater 4557 * methods are used to update column values in the current row or the insert 4558 * row. The updater methods do not update the underlying database; instead 4559 * the <code>updateRow<code> or <code>insertRow</code> methods are called 4560 * to update the database. 4561 * 4562 * @param columnIndex the first column is 1, the second 2, ... 4563 * @param x the column value 4564 * @throws SQLException if a database access occurs 4565 * @since 1.6 4566 */ 4567 public void updateRowId(int columnIndex, RowId x) throws SQLException { 4568 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4569 } 4570 4571 /** 4572 * Updates the designated column with a <code>RowId</code> value. The updater 4573 * methods are used to update column values in the current row or the insert 4574 * row. The updater methods do not update the underlying database; instead 4575 * the <code>updateRow<code> or <code>insertRow</code> methods are called 4576 * to update the database. 4577 * 4578 * @param columnName the name of the column 4579 * @param x the column value 4580 * @throws SQLException if a database access occurs 4581 * @since 1.6 4582 */ 4583 public void updateRowId(String columnName, RowId x) throws SQLException { 4584 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4585 } 4586 4587 /** 4588 * Retrieves the holdability of this ResultSet object 4589 * @return either ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT 4590 * @throws SQLException if a database error occurs 4591 * @since 1.6 4592 */ 4593 public int getHoldability() throws SQLException { 4594 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4595 } 4614 * @since 1.6 4615 */ 4616 public void updateNString(int columnIndex, String nString) throws SQLException { 4617 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4618 } 4619 4620 /** 4621 * This method is used for updating columns that support National Character sets. 4622 * It can be used for updating NCHAR,NVARCHAR and LONGNVARCHAR columns. 4623 * @param columnName name of the Column 4624 * @param nString the value for the column to be updated 4625 * @throws SQLException if a database access error occurs 4626 * @since 1.6 4627 */ 4628 public void updateNString(String columnName, String nString) throws SQLException { 4629 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4630 } 4631 4632 4633 /*o 4634 * This method is used for updating SQL <code>NCLOB</code> type that maps 4635 * to <code>java.sql.Types.NCLOB</code> 4636 * @param columnIndex the first column is 1, the second 2, ... 4637 * @param nClob the value for the column to be updated 4638 * @throws SQLException if a database access error occurs 4639 * @since 1.6 4640 */ 4641 public void updateNClob(int columnIndex, NClob nClob) throws SQLException { 4642 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4643 } 4644 4645 /** 4646 * This method is used for updating SQL <code>NCLOB</code> type that maps 4647 * to <code>java.sql.Types.NCLOB</code> 4648 * @param columnName name of the column 4649 * @param nClob the value for the column to be updated 4650 * @throws SQLException if a database access error occurs 4651 * @since 1.6 4652 */ 4653 public void updateNClob(String columnName, NClob nClob) throws SQLException { 4654 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4655 } 4656 4657 /** 4658 * Retrieves the value of the designated column in the current row 4659 * of this <code>ResultSet</code> object as a <code>NClob</code> object 4660 * in the Java programming language. 4661 * 4662 * @param i the first column is 1, the second is 2, ... 4663 * @return a <code>NClob</code> object representing the SQL 4664 * <code>NCLOB</code> value in the specified column 4665 * @exception SQLException if a database access error occurs 4666 * @since 1.6 4667 */ 4668 public NClob getNClob(int i) throws SQLException { 4669 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4670 } 4671 4672 4673 /** 4674 * Retrieves the value of the designated column in the current row 4675 * of this <code>ResultSet</code> object as a <code>NClob</code> object 4676 * in the Java programming language. 4677 * 4678 * @param colName the name of the column from which to retrieve the value 4679 * @return a <code>NClob</code> object representing the SQL <code>NCLOB</code> 4680 * value in the specified column 4681 * @exception SQLException if a database access error occurs 4682 * @since 1.6 4683 */ 4684 public NClob getNClob(String colName) throws SQLException { 4685 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4686 } 4687 4688 public <T> T unwrap(java.lang.Class<T> iface) throws java.sql.SQLException{ 4689 return null; 4690 } 4691 4692 public boolean isWrapperFor(Class<?> interfaces) throws SQLException { 4693 return false; 4694 } 4695 4696 /** 4697 * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an 4698 * SQL <code>XML</code> value when it sends it to the database. 4699 * @param parameterIndex index of the first parameter is 1, the second is 2, ... 4700 * @param xmlObject a <code>SQLXML</code> object that maps an SQL <code>XML</code> value 4701 * @throws SQLException if a database access error occurs 4702 * @since 1.6 4703 */ 4704 public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException { 4705 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4706 } 4707 4708 /** 4709 * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an 4710 * <code>SQL XML</code> value when it sends it to the database. 4711 * @param parameterName the name of the parameter 4712 * @param xmlObject a <code>SQLXML</code> object that maps an <code>SQL XML</code> value 4713 * @throws SQLException if a database access error occurs 4714 * @since 1.6 4715 */ 4716 public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException { 4717 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4718 } 4719 4720 /** 4721 * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The 4722 * driver converts this to a SQL <code>ROWID</code> value when it sends it 4723 * to the database 4724 * 4725 * @param parameterIndex the first parameter is 1, the second is 2, ... 4726 * @param x the parameter value 4727 * @throws SQLException if a database access error occurs 4728 * 4729 * @since 1.6 4730 */ 4731 public void setRowId(int parameterIndex, RowId x) throws SQLException { 4732 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4733 } 4734 4735 /** 4736 * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The 4737 * driver converts this to a SQL <code>ROWID</code> when it sends it to the 4738 * database. 4739 * 4740 * @param parameterName the name of the parameter 4741 * @param x the parameter value 4742 * @throws SQLException if a database access error occurs 4743 * @since 1.6 4744 */ 4745 public void setRowId(String parameterName, RowId x) throws SQLException { 4746 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4747 } 4748 4749 4750 /** 4751 * Sets the designated parameter to the given <code>String</code> object. 4752 * The driver converts this to a SQL <code>NCHAR</code> or 4753 * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value 4754 * (depending on the argument's 4755 * size relative to the driver's limits on <code>NVARCHAR</code> values) 4756 * when it sends it to the database. 4757 * 4758 * @param parameterIndex of the first parameter is 1, the second is 2, ... 4759 * @param value the parameter value 4760 * @throws SQLException if the driver does not support national 4761 * character sets; if the driver can detect that a data conversion 4762 * error could occur ; or if a database access error occurs 4763 * @since 1.6 4764 */ 4765 public void setNString(int parameterIndex, String value) throws SQLException { 4766 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4767 } 4768 4769 4770 /** 4771 * Sets the designated parameter in this <code>RowSet</code> object's command 4772 * to a <code>Reader</code> object. The 4773 * <code>Reader</code> reads the data till end-of-file is reached. The 4774 * driver does the necessary conversion from Java character format to 4775 * the national character set in the database. 4776 4777 * <P><B>Note:</B> This stream object can either be a standard 4778 * Java stream object or your own subclass that implements the 4779 * standard interface. 4780 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 4781 * it might be more efficient to use a version of 4782 * <code>setNCharacterStream</code> which takes a length parameter. 4783 * 4784 * @param parameterIndex of the first parameter is 1, the second is 2, ... 4785 * @param value the parameter value 4786 * @throws SQLException if the driver does not support national 4787 * character sets; if the driver can detect that a data conversion 4788 * error could occur ; if a database access error occurs; or 4789 * this method is called on a closed <code>PreparedStatement</code> 4790 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 4791 * @since 1.6 4792 */ 4793 public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException { 4794 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4795 } 4796 4797 /** 4798 * Sets the designated parameter to a <code>java.sql.NClob</code> object. The object 4799 * implements the <code>java.sql.NClob</code> interface. This <code>NClob</code> 4800 * object maps to a SQL <code>NCLOB</code>. 4801 * @param parameterName the name of the column to be set 4802 * @param value the parameter value 4803 * @throws SQLException if the driver does not support national 4804 * character sets; if the driver can detect that a data conversion 4805 * error could occur; or if a database access error occurs 4806 * @since 1.6 4807 */ 4808 public void setNClob(String parameterName, NClob value) throws SQLException { 4809 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4810 } 4811 4812 4813 /** 4814 * Retrieves the value of the designated column in the current row 4815 * of this <code>ResultSet</code> object as a 4816 * <code>java.io.Reader</code> object. 4817 * It is intended for use when 4818 * accessing <code>NCHAR</code>,<code>NVARCHAR</code> 4819 * and <code>LONGNVARCHAR</code> columns. 4820 * 4821 * @return a <code>java.io.Reader</code> object that contains the column 4822 * value; if the value is SQL <code>NULL</code>, the value returned is 4823 * <code>null</code> in the Java programming language. 4824 * @param columnIndex the first column is 1, the second is 2, ... 4825 * @exception SQLException if a database access error occurs 4826 * @since 1.6 4827 */ 4828 public java.io.Reader getNCharacterStream(int columnIndex) throws SQLException { 4829 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4830 } 4831 4832 4833 /** 4834 * Retrieves the value of the designated column in the current row 4835 * of this <code>ResultSet</code> object as a 4836 * <code>java.io.Reader</code> object. 4837 * It is intended for use when 4838 * accessing <code>NCHAR</code>,<code>NVARCHAR</code> 4839 * and <code>LONGNVARCHAR</code> columns. 4840 * 4841 * @param columnName the name of the column 4842 * @return a <code>java.io.Reader</code> object that contains the column 4843 * value; if the value is SQL <code>NULL</code>, the value returned is 4844 * <code>null</code> in the Java programming language 4845 * @exception SQLException if a database access error occurs 4846 * @since 1.6 4847 */ 4848 public java.io.Reader getNCharacterStream(String columnName) throws SQLException { 4849 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4850 } 4851 4852 /** 4853 * Updates the designated column with a <code>java.sql.SQLXML</code> value. 4854 * The updater 4855 * methods are used to update column values in the current row or the insert 4856 * row. The updater methods do not update the underlying database; instead 4857 * the <code>updateRow</code> or <code>insertRow</code> methods are called 4858 * to update the database. 4859 * @param columnIndex the first column is 1, the second 2, ... 4860 * @param xmlObject the value for the column to be updated 4861 * @throws SQLException if a database access error occurs 4862 * @since 1.6 4863 */ 4864 public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException { 4865 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4866 } 4867 4868 /** 4869 * Updates the designated column with a <code>java.sql.SQLXML</code> value. 4870 * The updater 4871 * methods are used to update column values in the current row or the insert 4872 * row. The updater methods do not update the underlying database; instead 4873 * the <code>updateRow</code> or <code>insertRow</code> methods are called 4874 * to update the database. 4875 * 4876 * @param columnName the name of the column 4877 * @param xmlObject the column value 4878 * @throws SQLException if a database access occurs 4879 * @since 1.6 4880 */ 4881 public void updateSQLXML(String columnName, SQLXML xmlObject) throws SQLException { 4882 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4883 } 4884 4885 /** 4886 * Retrieves the value of the designated column in the current row 4887 * of this <code>ResultSet</code> object as 4888 * a <code>String</code> in the Java programming language. 4889 * It is intended for use when 4890 * accessing <code>NCHAR</code>,<code>NVARCHAR</code> 4891 * and <code>LONGNVARCHAR</code> columns. 4892 * 4893 * @param columnIndex the first column is 1, the second is 2, ... 4894 * @return the column value; if the value is SQL <code>NULL</code>, the 4895 * value returned is <code>null</code> 4896 * @exception SQLException if a database access error occurs 4897 * @since 1.6 4898 */ 4899 public String getNString(int columnIndex) throws SQLException { 4900 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4901 } 4902 4903 /** 4904 * Retrieves the value of the designated column in the current row 4905 * of this <code>ResultSet</code> object as 4906 * a <code>String</code> in the Java programming language. 4907 * It is intended for use when 4908 * accessing <code>NCHAR</code>,<code>NVARCHAR</code> 4909 * and <code>LONGNVARCHAR</code> columns. 4910 * 4911 * @param columnName the SQL name of the column 4912 * @return the column value; if the value is SQL <code>NULL</code>, the 4913 * value returned is <code>null</code> 4914 * @exception SQLException if a database access error occurs 4915 * @since 1.6 4916 */ 4917 public String getNString(String columnName) throws SQLException { 4918 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4919 } 4920 4921 /** 4922 * Updates the designated column with a character stream value, which will 4923 * have the specified number of bytes. The driver does the necessary conversion 4924 * from Java character format to the national character set in the database. 4925 * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns. 4926 * The updater methods are used to update column values in the current row or 4927 * the insert row. The updater methods do not update the underlying database; 4928 * instead the updateRow or insertRow methods are called to update the database. 4929 * 4930 * @param columnIndex - the first column is 1, the second is 2, ... 4931 * @param x - the new column value 4932 * @param length - the length of the stream 4933 * @exception SQLException if a database access error occurs 4934 * @since 1.6 4935 */ 4936 public void updateNCharacterStream(int columnIndex, 4937 java.io.Reader x, 4938 long length) 4939 throws SQLException { 4940 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4941 } 4942 4943 /** 4944 * Updates the designated column with a character stream value, which will 4945 * have the specified number of bytes. The driver does the necessary conversion 4946 * from Java character format to the national character set in the database. 4947 * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns. 4948 * The updater methods are used to update column values in the current row or 4949 * the insert row. The updater methods do not update the underlying database; 4950 * instead the updateRow or insertRow methods are called to update the database. 4951 * 4952 * @param columnName - name of the Column 4953 * @param x - the new column value 4954 * @param length - the length of the stream 4955 * @exception SQLException if a database access error occurs 4956 * @since 1.6 4957 */ 4958 public void updateNCharacterStream(String columnName, 4959 java.io.Reader x, 4960 long length) 4961 throws SQLException { 4962 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4963 } 4964 4965 /** 4966 * Updates the designated column with a character stream value. The 4967 * driver does the necessary conversion from Java character format to 4968 * the national character set in the database. 4969 * It is intended for use when 4970 * updating <code>NCHAR</code>,<code>NVARCHAR</code> 4971 * and <code>LONGNVARCHAR</code> columns. 4972 * 4973 * The updater methods are used to update column values in the 4974 * current row or the insert row. The updater methods do not 4975 * update the underlying database; instead the <code>updateRow</code> or 4976 * <code>insertRow</code> methods are called to update the database. 4977 * 4978 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 4979 * it might be more efficient to use a version of 4980 * <code>updateNCharacterStream</code> which takes a length parameter. 4981 * 4982 * @param columnIndex the first column is 1, the second is 2, ... 4983 * @param x the new column value 4984 * @exception SQLException if a database access error occurs, 4985 * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set 4986 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 4987 * this method 4988 * @since 1.6 4989 */ 4990 public void updateNCharacterStream(int columnIndex, 4991 java.io.Reader x) throws SQLException { 4992 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4993 } 4994 4995 /** 4996 * Updates the designated column with a character stream value. The 4997 * driver does the necessary conversion from Java character format to 4998 * the national character set in the database. 4999 * It is intended for use when 5000 * updating <code>NCHAR</code>,<code>NVARCHAR</code> 5001 * and <code>LONGNVARCHAR</code> columns. 5002 * 5003 * The updater methods are used to update column values in the 5004 * current row or the insert row. The updater methods do not 5005 * update the underlying database; instead the <code>updateRow</code> or 5006 * <code>insertRow</code> methods are called to update the database. 5007 * 5008 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5009 * it might be more efficient to use a version of 5010 * <code>updateNCharacterStream</code> which takes a length parameter. 5011 * 5012 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la 5013 bel is the name of the column 5014 * @param reader the <code>java.io.Reader</code> object containing 5015 * the new column value 5016 * @exception SQLException if a database access error occurs, 5017 * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set 5018 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5019 * this method 5020 * @since 1.6 5021 */ 5022 public void updateNCharacterStream(String columnLabel, 5023 java.io.Reader reader) throws SQLException { 5024 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5025 } 5026 5027 /** 5028 * Updates the designated column using the given input stream, which 5029 * will have the specified number of bytes. 5030 * When a very large ASCII value is input to a <code>LONGVARCHAR</code> 5031 * parameter, it may be more practical to send it via a 5032 * <code>java.io.InputStream</code>. Data will be read from the stream 5033 * as needed until end-of-file is reached. The JDBC driver will 5034 * do any necessary conversion from ASCII to the database char format. 5035 * 5036 * <P><B>Note:</B> This stream object can either be a standard 5037 * Java stream object or your own subclass that implements the 5038 * standard interface. 5039 * <p> 5040 * The updater methods are used to update column values in the 5041 * current row or the insert row. The updater methods do not 5042 * update the underlying database; instead the <code>updateRow</code> or 5043 * <code>insertRow</code> methods are called to update the database. 5044 * 5045 * @param columnIndex the first column is 1, the second is 2, ... 5046 * @param inputStream An object that contains the data to set the parameter 5047 * value to. 5048 * @param length the number of bytes in the parameter data. 5049 * @exception SQLException if a database access error occurs, 5050 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5051 * or this method is called on a closed result set 5052 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5053 * this method 5054 * @since 1.6 5055 */ 5056 public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException{ 5057 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5058 } 5059 5060 /** 5061 * Updates the designated column using the given input stream, which 5062 * will have the specified number of bytes. 5063 * When a very large ASCII value is input to a <code>LONGVARCHAR</code> 5064 * parameter, it may be more practical to send it via a 5065 * <code>java.io.InputStream</code>. Data will be read from the stream 5066 * as needed until end-of-file is reached. The JDBC driver will 5067 * do any necessary conversion from ASCII to the database char format. 5068 * 5069 * <P><B>Note:</B> This stream object can either be a standard 5070 * Java stream object or your own subclass that implements the 5071 * standard interface. 5072 * <p> 5073 * The updater methods are used to update column values in the 5074 * current row or the insert row. The updater methods do not 5075 * update the underlying database; instead the <code>updateRow</code> or 5076 * <code>insertRow</code> methods are called to update the database. 5077 * 5078 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column 5079 * @param inputStream An object that contains the data to set the parameter 5080 * value to. 5081 * @param length the number of bytes in the parameter data. 5082 * @exception SQLException if a database access error occurs, 5083 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5084 * or this method is called on a closed result set 5085 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5086 * this method 5087 * @since 1.6 5088 */ 5089 public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException { 5090 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5091 } 5092 5093 /** 5094 * Updates the designated column using the given input stream. 5095 * When a very large ASCII value is input to a <code>LONGVARCHAR</code> 5096 * parameter, it may be more practical to send it via a 5097 * <code>java.io.InputStream</code>. Data will be read from the stream 5098 * as needed until end-of-file is reached. The JDBC driver will 5099 * do any necessary conversion from ASCII to the database char format. 5100 * 5101 * <P><B>Note:</B> This stream object can either be a standard 5102 * Java stream object or your own subclass that implements the 5103 * standard interface. 5104 * 5105 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5106 * it might be more efficient to use a version of 5107 * <code>updateBlob</code> which takes a length parameter. 5108 * <p> 5109 * The updater methods are used to update column values in the 5110 * current row or the insert row. The updater methods do not 5111 * update the underlying database; instead the <code>updateRow</code> or 5112 * <code>insertRow</code> methods are called to update the database. 5113 * 5114 * @param columnIndex the first column is 1, the second is 2, ... 5115 * @param inputStream An object that contains the data to set the parameter 5116 * value to. 5117 * @exception SQLException if a database access error occurs, 5118 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5119 * or this method is called on a closed result set 5120 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5121 * this method 5122 * @since 1.6 5123 */ 5124 public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException { 5125 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5126 } 5127 5128 /** 5129 * Updates the designated column using the given input stream. 5130 * When a very large ASCII value is input to a <code>LONGVARCHAR</code> 5131 * parameter, it may be more practical to send it via a 5132 * <code>java.io.InputStream</code>. Data will be read from the stream 5133 * as needed until end-of-file is reached. The JDBC driver will 5134 * do any necessary conversion from ASCII to the database char format. 5135 * 5136 * <P><B>Note:</B> This stream object can either be a standard 5137 * Java stream object or your own subclass that implements the 5138 * standard interface. 5139 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5140 * it might be more efficient to use a version of 5141 * <code>updateBlob</code> which takes a length parameter. 5142 * <p> 5143 * The updater methods are used to update column values in the 5144 * current row or the insert row. The updater methods do not 5145 * update the underlying database; instead the <code>updateRow</code> or 5146 * <code>insertRow</code> methods are called to update the database. 5147 * 5148 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la 5149 bel is the name of the column 5150 * @param inputStream An object that contains the data to set the parameter 5151 * value to. 5152 * @exception SQLException if a database access error occurs, 5153 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5154 * or this method is called on a closed result set 5155 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5156 * this method 5157 * @since 1.6 5158 */ 5159 public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException { 5160 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5161 } 5162 5163 /** 5164 * Updates the designated column using the given <code>Reader</code> 5165 * object, which is the given number of characters long. 5166 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> 5167 * parameter, it may be more practical to send it via a 5168 * <code>java.io.Reader</code> object. The data will be read from the stream 5169 * as needed until end-of-file is reached. The JDBC driver will 5170 * do any necessary conversion from UNICODE to the database char format. 5171 * 5172 * <P><B>Note:</B> This stream object can either be a standard 5173 * Java stream object or your own subclass that implements the 5174 * standard interface. 5175 * <p> 5176 * The updater methods are used to update column values in the 5177 * current row or the insert row. The updater methods do not 5178 * update the underlying database; instead the <code>updateRow</code> or 5179 * <code>insertRow</code> methods are called to update the database. 5180 * 5181 * @param columnIndex the first column is 1, the second is 2, ... 5182 * @param reader An object that contains the data to set the parameter value to. 5183 * @param length the number of characters in the parameter data. 5184 * @exception SQLException if a database access error occurs, 5185 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5186 * or this method is called on a closed result set 5187 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5188 * this method 5189 * @since 1.6 5190 */ 5191 public void updateClob(int columnIndex, Reader reader, long length) throws SQLException { 5192 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5193 } 5194 5195 /** 5196 * Updates the designated column using the given <code>Reader</code> 5197 * object, which is the given number of characters long. 5198 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> 5199 * parameter, it may be more practical to send it via a 5200 * <code>java.io.Reader</code> object. The data will be read from the stream 5201 * as needed until end-of-file is reached. The JDBC driver will 5202 * do any necessary conversion from UNICODE to the database char format. 5203 * 5204 * <P><B>Note:</B> This stream object can either be a standard 5205 * Java stream object or your own subclass that implements the 5206 * standard interface. 5207 * <p> 5208 * The updater methods are used to update column values in the 5209 * current row or the insert row. The updater methods do not 5210 * update the underlying database; instead the <code>updateRow</code> or 5211 * <code>insertRow</code> methods are called to update the database. 5212 * 5213 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column 5214 * @param reader An object that contains the data to set the parameter value to. 5215 * @param length the number of characters in the parameter data. 5216 * @exception SQLException if a database access error occurs, 5217 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5218 * or this method is called on a closed result set 5219 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5220 * this method 5221 * @since 1.6 5222 */ 5223 public void updateClob(String columnLabel, Reader reader, long length) throws SQLException { 5224 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5225 } 5226 5227 /** 5228 * Updates the designated column using the given <code>Reader</code> 5229 * object. 5230 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> 5231 * parameter, it may be more practical to send it via a 5232 * <code>java.io.Reader</code> object. The data will be read from the stream 5233 * as needed until end-of-file is reached. The JDBC driver will 5234 * do any necessary conversion from UNICODE to the database char format. 5235 * 5236 * <P><B>Note:</B> This stream object can either be a standard 5237 * Java stream object or your own subclass that implements the 5238 * standard interface. 5239 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5240 * it might be more efficient to use a version of 5241 * <code>updateClob</code> which takes a length parameter. 5242 * <p> 5243 * The updater methods are used to update column values in the 5244 * current row or the insert row. The updater methods do not 5245 * update the underlying database; instead the <code>updateRow</code> or 5246 * <code>insertRow</code> methods are called to update the database. 5247 * 5248 * @param columnIndex the first column is 1, the second is 2, ... 5249 * @param reader An object that contains the data to set the parameter value to. 5250 * @exception SQLException if a database access error occurs, 5251 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5252 * or this method is called on a closed result set 5253 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5254 * this method 5255 * @since 1.6 5256 */ 5257 public void updateClob(int columnIndex, Reader reader) throws SQLException { 5258 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5259 } 5260 5261 /** 5262 * Updates the designated column using the given <code>Reader</code> 5263 * object. 5264 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> 5265 * parameter, it may be more practical to send it via a 5266 * <code>java.io.Reader</code> object. The data will be read from the stream 5267 * as needed until end-of-file is reached. The JDBC driver will 5268 * do any necessary conversion from UNICODE to the database char format. 5269 * 5270 * <P><B>Note:</B> This stream object can either be a standard 5271 * Java stream object or your own subclass that implements the 5272 * standard interface. 5273 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5274 * it might be more efficient to use a version of 5275 * <code>updateClob</code> which takes a length parameter. 5276 * <p> 5277 * The updater methods are used to update column values in the 5278 * current row or the insert row. The updater methods do not 5279 * update the underlying database; instead the <code>updateRow</code> or 5280 * <code>insertRow</code> methods are called to update the database. 5281 * 5282 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la 5283 bel is the name of the column 5284 * @param reader An object that contains the data to set the parameter value to. 5285 * @exception SQLException if a database access error occurs, 5286 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5287 * or this method is called on a closed result set 5288 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5289 * this method 5290 * @since 1.6 5291 */ 5292 public void updateClob(String columnLabel, Reader reader) throws SQLException { 5293 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5294 } 5295 5296 /** 5297 * Updates the designated column using the given <code>Reader</code> 5298 * object, which is the given number of characters long. 5299 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> 5300 * parameter, it may be more practical to send it via a 5301 * <code>java.io.Reader</code> object. The data will be read from the stream 5302 * as needed until end-of-file is reached. The JDBC driver will 5303 * do any necessary conversion from UNICODE to the database char format. 5304 * 5305 * <P><B>Note:</B> This stream object can either be a standard 5306 * Java stream object or your own subclass that implements the 5307 * standard interface. 5308 * <p> 5309 * The updater methods are used to update column values in the 5310 * current row or the insert row. The updater methods do not 5311 * update the underlying database; instead the <code>updateRow</code> or 5312 * <code>insertRow</code> methods are called to update the database. 5313 * 5314 * @param columnIndex the first column is 1, the second 2, ... 5315 * @param reader An object that contains the data to set the parameter value to. 5316 * @param length the number of characters in the parameter data. 5317 * @throws SQLException if the driver does not support national 5318 * character sets; if the driver can detect that a data conversion 5319 * error could occur; this method is called on a closed result set, 5320 * if a database access error occurs or 5321 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5322 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5323 * this method 5324 * @since 1.6 5325 */ 5326 public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException { 5327 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5328 } 5329 5330 /** 5331 * Updates the designated column using the given <code>Reader</code> 5332 * object, which is the given number of characters long. 5333 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> 5334 * parameter, it may be more practical to send it via a 5335 * <code>java.io.Reader</code> object. The data will be read from the stream 5336 * as needed until end-of-file is reached. The JDBC driver will 5337 * do any necessary conversion from UNICODE to the database char format. 5338 * 5339 * <P><B>Note:</B> This stream object can either be a standard 5340 * Java stream object or your own subclass that implements the 5341 * standard interface. 5342 * <p> 5343 * The updater methods are used to update column values in the 5344 * current row or the insert row. The updater methods do not 5345 * update the underlying database; instead the <code>updateRow</code> or 5346 * <code>insertRow</code> methods are called to update the database. 5347 * 5348 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column 5349 * @param reader An object that contains the data to set the parameter value to. 5350 * @param length the number of characters in the parameter data. 5351 * @throws SQLException if the driver does not support national 5352 * character sets; if the driver can detect that a data conversion 5353 * error could occur; this method is called on a closed result set; 5354 * if a database access error occurs or 5355 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5356 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5357 * this method 5358 * @since 1.6 5359 */ 5360 public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException { 5361 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5362 } 5363 5364 /** 5365 * Updates the designated column using the given <code>Reader</code> 5366 * object. 5367 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> 5368 * parameter, it may be more practical to send it via a 5369 * <code>java.io.Reader</code> object. The data will be read from the stream 5370 * as needed until end-of-file is reached. The JDBC driver will 5371 * do any necessary conversion from UNICODE to the database char format. 5372 * 5373 * <P><B>Note:</B> This stream object can either be a standard 5374 * Java stream object or your own subclass that implements the 5375 * standard interface. 5376 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5377 * it might be more efficient to use a version of 5378 * <code>updateNClob</code> which takes a length parameter. 5379 * <p> 5380 * The updater methods are used to update column values in the 5381 * current row or the insert row. The updater methods do not 5382 * update the underlying database; instead the <code>updateRow</code> or 5383 * <code>insertRow</code> methods are called to update the database. 5384 * 5385 * @param columnIndex the first column is 1, the second 2, ... 5386 * @param reader An object that contains the data to set the parameter value to. 5387 * @throws SQLException if the driver does not support national 5388 * character sets; if the driver can detect that a data conversion 5389 * error could occur; this method is called on a closed result set, 5390 * if a database access error occurs or 5391 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5392 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5393 * this method 5394 * @since 1.6 5395 */ 5396 public void updateNClob(int columnIndex, Reader reader) throws SQLException { 5397 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5398 } 5399 5400 /** 5401 * Updates the designated column using the given <code>Reader</code> 5402 * object. 5403 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> 5404 * parameter, it may be more practical to send it via a 5405 * <code>java.io.Reader</code> object. The data will be read from the stream 5406 * as needed until end-of-file is reached. The JDBC driver will 5407 * do any necessary conversion from UNICODE to the database char format. 5408 * 5409 * <P><B>Note:</B> This stream object can either be a standard 5410 * Java stream object or your own subclass that implements the 5411 * standard interface. 5412 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5413 * it might be more efficient to use a version of 5414 * <code>updateNClob</code> which takes a length parameter. 5415 * <p> 5416 * The updater methods are used to update column values in the 5417 * current row or the insert row. The updater methods do not 5418 * update the underlying database; instead the <code>updateRow</code> or 5419 * <code>insertRow</code> methods are called to update the database. 5420 * 5421 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la 5422 bel is the name of the column 5423 * @param reader An object that contains the data to set the parameter value to. 5424 * @throws SQLException if the driver does not support national 5425 * character sets; if the driver can detect that a data conversion 5426 * error could occur; this method is called on a closed result set; 5427 * if a database access error occurs or 5428 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5429 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5430 * this method 5431 * @since 1.6 5432 */ 5433 public void updateNClob(String columnLabel, Reader reader) throws SQLException { 5434 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5435 } 5436 5437 5438 /** 5439 * Updates the designated column with an ascii stream value, which will have 5440 * the specified number of bytes. 5441 * The updater methods are used to update column values in the 5442 * current row or the insert row. The updater methods do not 5443 * update the underlying database; instead the <code>updateRow</code> or 5444 * <code>insertRow</code> methods are called to update the database. 5445 * 5446 * @param columnIndex the first column is 1, the second is 2, ... 5447 * @param x the new column value 5448 * @param length the length of the stream 5449 * @exception SQLException if a database access error occurs, 5450 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5451 * or this method is called on a closed result set 5452 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5453 * this method 5454 * @since 1.6 5455 */ 5456 public void updateAsciiStream(int columnIndex, 5457 java.io.InputStream x, 5458 long length) throws SQLException { 5459 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5460 } 5461 5462 /** 5463 * Updates the designated column with a binary stream value, which will have 5464 * the specified number of bytes. 5465 * The updater methods are used to update column values in the 5466 * current row or the insert row. The updater methods do not 5467 * update the underlying database; instead the <code>updateRow</code> or 5468 * <code>insertRow</code> methods are called to update the database. 5469 * 5470 * @param columnIndex the first column is 1, the second is 2, ... 5471 * @param x the new column value 5472 * @param length the length of the stream 5473 * @exception SQLException if a database access error occurs, 5474 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5475 * or this method is called on a closed result set 5476 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5477 * this method 5478 * @since 1.6 5479 */ 5480 public void updateBinaryStream(int columnIndex, 5481 java.io.InputStream x, 5482 long length) throws SQLException { 5483 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5484 } 5485 5486 /** 5487 * Updates the designated column with a character stream value, which will have 5488 * the specified number of bytes. 5489 * The updater methods are used to update column values in the 5490 * current row or the insert row. The updater methods do not 5491 * update the underlying database; instead the <code>updateRow</code> or 5492 * <code>insertRow</code> methods are called to update the database. 5493 * 5494 * @param columnIndex the first column is 1, the second is 2, ... 5495 * @param x the new column value 5496 * @param length the length of the stream 5497 * @exception SQLException if a database access error occurs, 5498 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5499 * or this method is called on a closed result set 5500 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5501 * this method 5502 * @since 1.6 5503 */ 5504 public void updateCharacterStream(int columnIndex, 5505 java.io.Reader x, 5506 long length) throws SQLException { 5507 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5508 } 5509 5510 /** 5511 * Updates the designated column with an ascii stream value, which will have 5512 * the specified number of bytes.. 5513 * The updater methods are used to update column values in the 5514 * current row or the insert row. The updater methods do not 5515 * update the underlying database; instead the <code>updateRow</code> or 5516 * <code>insertRow</code> methods are called to update the database. 5517 * 5518 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column 5519 * @param x the new column value 5520 * @param length the length of the stream 5521 * @exception SQLException if a database access error occurs, 5522 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5523 * or this method is called on a closed result set 5524 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5525 * this method 5526 * @since 1.6 5527 */ 5528 public void updateAsciiStream(String columnLabel, 5529 java.io.InputStream x, 5530 long length) throws SQLException { 5531 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5532 } 5533 5534 /** 5535 * Updates the designated column with an ascii stream value. 5536 * The updater methods are used to update column values in the 5537 * current row or the insert row. The updater methods do not 5538 * update the underlying database; instead the <code>updateRow</code> or 5539 * <code>insertRow</code> methods are called to update the database. 5540 * 5541 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5542 * it might be more efficient to use a version of 5543 * <code>updateAsciiStream</code> which takes a length parameter. 5544 * 5545 * @param columnIndex the first column is 1, the second is 2, ... 5546 * @param x the new column value 5547 * @exception SQLException if a database access error occurs, 5548 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5549 * or this method is called on a closed result set 5550 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5551 * this method 5552 * @since 1.6 5553 */ 5554 public void updateAsciiStream(int columnIndex, 5555 java.io.InputStream x) throws SQLException { 5556 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5557 } 5558 5559 /** 5560 * Updates the designated column with an ascii stream value. 5561 * The updater methods are used to update column values in the 5562 * current row or the insert row. The updater methods do not 5563 * update the underlying database; instead the <code>updateRow</code> or 5564 * <code>insertRow</code> methods are called to update the database. 5565 * 5566 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5567 * it might be more efficient to use a version of 5568 * <code>updateAsciiStream</code> which takes a length parameter. 5569 * 5570 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la 5571 bel is the name of the column 5572 * @param x the new column value 5573 * @exception SQLException if a database access error occurs, 5574 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5575 * or this method is called on a closed result set 5576 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5577 * this method 5578 * @since 1.6 5579 */ 5580 public void updateAsciiStream(String columnLabel, 5581 java.io.InputStream x) throws SQLException { 5582 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5583 } 5584 5585 5586 /** 5587 * Updates the designated column with a binary stream value, which will have 5588 * the specified number of bytes. 5589 * The updater methods are used to update column values in the 5590 * current row or the insert row. The updater methods do not 5591 * update the underlying database; instead the <code>updateRow</code> or 5592 * <code>insertRow</code> methods are called to update the database. 5593 * 5594 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column 5595 * @param x the new column value 5596 * @param length the length of the stream 5597 * @exception SQLException if a database access error occurs, 5598 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5599 * or this method is called on a closed result set 5600 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5601 * this method 5602 * @since 1.6 5603 */ 5604 public void updateBinaryStream(String columnLabel, 5605 java.io.InputStream x, 5606 long length) throws SQLException { 5607 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5608 } 5609 5610 /** 5611 * Updates the designated column with a binary stream value. 5612 * The updater methods are used to update column values in the 5613 * current row or the insert row. The updater methods do not 5614 * update the underlying database; instead the <code>updateRow</code> or 5615 * <code>insertRow</code> methods are called to update the database. 5616 * 5617 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5618 * it might be more efficient to use a version of 5619 * <code>updateBinaryStream</code> which takes a length parameter. 5620 * 5621 * @param columnIndex the first column is 1, the second is 2, ... 5622 * @param x the new column value 5623 * @exception SQLException if a database access error occurs, 5624 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5625 * or this method is called on a closed result set 5626 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5627 * this method 5628 * @since 1.6 5629 */ 5630 public void updateBinaryStream(int columnIndex, 5631 java.io.InputStream x) throws SQLException { 5632 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5633 } 5634 5635 5636 /** 5637 * Updates the designated column with a binary stream value. 5638 * The updater methods are used to update column values in the 5639 * current row or the insert row. The updater methods do not 5640 * update the underlying database; instead the <code>updateRow</code> or 5641 * <code>insertRow</code> methods are called to update the database. 5642 * 5643 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5644 * it might be more efficient to use a version of 5645 * <code>updateBinaryStream</code> which takes a length parameter. 5646 * 5647 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la 5648 bel is the name of the column 5649 * @param x the new column value 5650 * @exception SQLException if a database access error occurs, 5651 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5652 * or this method is called on a closed result set 5653 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5654 * this method 5655 * @since 1.6 5656 */ 5657 public void updateBinaryStream(String columnLabel, 5658 java.io.InputStream x) throws SQLException { 5659 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5660 } 5661 5662 5663 /** 5664 * Updates the designated column with a character stream value, which will have 5665 * the specified number of bytes. 5666 * The updater methods are used to update column values in the 5667 * current row or the insert row. The updater methods do not 5668 * update the underlying database; instead the <code>updateRow</code> or 5669 * <code>insertRow</code> methods are called to update the database. 5670 * 5671 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column 5672 * @param reader the <code>java.io.Reader</code> object containing 5673 * the new column value 5674 * @param length the length of the stream 5675 * @exception SQLException if a database access error occurs, 5676 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5677 * or this method is called on a closed result set 5678 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5679 * this method 5680 * @since 1.6 5681 */ 5682 public void updateCharacterStream(String columnLabel, 5683 java.io.Reader reader, 5684 long length) throws SQLException { 5685 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5686 } 5687 5688 /** 5689 * Updates the designated column with a character stream value. 5690 * The updater methods are used to update column values in the 5691 * current row or the insert row. The updater methods do not 5692 * update the underlying database; instead the <code>updateRow</code> or 5693 * <code>insertRow</code> methods are called to update the database. 5694 * 5695 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5696 * it might be more efficient to use a version of 5697 * <code>updateCharacterStream</code> which takes a length parameter. 5698 * 5699 * @param columnIndex the first column is 1, the second is 2, ... 5700 * @param x the new column value 5701 * @exception SQLException if a database access error occurs, 5702 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5703 * or this method is called on a closed result set 5704 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5705 * this method 5706 * @since 1.6 5707 */ 5708 public void updateCharacterStream(int columnIndex, 5709 java.io.Reader x) throws SQLException { 5710 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5711 } 5712 5713 /** 5714 * Updates the designated column with a character stream value. 5715 * The updater methods are used to update column values in the 5716 * current row or the insert row. The updater methods do not 5717 * update the underlying database; instead the <code>updateRow</code> or 5718 * <code>insertRow</code> methods are called to update the database. 5719 * 5720 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5721 * it might be more efficient to use a version of 5722 * <code>updateCharacterStream</code> which takes a length parameter. 5723 * 5724 * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la 5725 bel is the name of the column 5726 * @param reader the <code>java.io.Reader</code> object containing 5727 * the new column value 5728 * @exception SQLException if a database access error occurs, 5729 * the result set concurrency is <code>CONCUR_READ_ONLY</code> 5730 * or this method is called on a closed result set 5731 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5732 * this method 5733 * @since 1.6 5734 */ 5735 public void updateCharacterStream(String columnLabel, 5736 java.io.Reader reader) throws SQLException { 5737 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5738 } 5739 5740 5741 /** 5742 * Sets the designated parameter to the given <code>java.net.URL</code> value. 5743 * The driver converts this to an SQL <code>DATALINK</code> value 5744 * when it sends it to the database. 5745 * 5746 * @param parameterIndex the first parameter is 1, the second is 2, ... 5747 * @param x the <code>java.net.URL</code> object to be set 5748 * @exception SQLException if a database access error occurs or 5749 * this method is called on a closed <code>PreparedStatement</code> 5750 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 5751 * @since 1.4 5752 */ 5753 public void setURL(int parameterIndex, java.net.URL x) throws SQLException{ 5754 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5755 } 5756 5757 5758 /** 5759 * Sets the designated parameter to a <code>Reader</code> object. 5760 * This method differs from the <code>setCharacterStream (int, Reader)</code> method 5761 * because it informs the driver that the parameter value should be sent to 5762 * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the 5763 * driver may have to do extra work to determine whether the parameter 5764 * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code> 5765 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5766 * it might be more efficient to use a version of 5767 * <code>setNClob</code> which takes a length parameter. 5768 * 5769 * @param parameterIndex index of the first parameter is 1, the second is 2, ... 5770 * @param reader An object that contains the data to set the parameter value to. 5771 * @throws SQLException if parameterIndex does not correspond to a parameter 5772 * marker in the SQL statement; 5773 * if the driver does not support national character sets; 5774 * if the driver can detect that a data conversion 5775 * error could occur; if a database access error occurs or 5776 * this method is called on a closed <code>PreparedStatement</code> 5777 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 5778 * 5779 * @since 1.6 5780 */ 5781 public void setNClob(int parameterIndex, Reader reader) 5782 throws SQLException{ 5783 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5784 } 5785 5786 /** 5787 * Sets the designated parameter to a <code>Reader</code> object. The <code>reader</code> must contain the number 5788 * of characters specified by length otherwise a <code>SQLException</code> will be 5789 * generated when the <code>CallableStatement</code> is executed. 5790 * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method 5791 * because it informs the driver that the parameter value should be sent to 5792 * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the 5793 * driver may have to do extra work to determine whether the parameter 5794 * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code> 5795 * 5796 * @param parameterName the name of the parameter to be set 5797 * @param reader An object that contains the data to set the parameter value to. 5798 * @param length the number of characters in the parameter data. 5799 * @throws SQLException if parameterIndex does not correspond to a parameter 5800 * marker in the SQL statement; if the length specified is less than zero; 5801 * if the driver does not support national 5802 * character sets; if the driver can detect that a data conversion 5803 * error could occur; if a database access error occurs or 5804 * this method is called on a closed <code>CallableStatement</code> 5805 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5806 * this method 5807 * @since 1.6 5808 */ 5809 public void setNClob(String parameterName, Reader reader, long length) 5810 throws SQLException{ 5811 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5812 } 5813 5814 5815 /** 5816 * Sets the designated parameter to a <code>Reader</code> object. 5817 * This method differs from the <code>setCharacterStream (int, Reader)</code> method 5818 * because it informs the driver that the parameter value should be sent to 5819 * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the 5820 * driver may have to do extra work to determine whether the parameter 5821 * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code> 5822 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5823 * it might be more efficient to use a version of 5824 * <code>setNClob</code> which takes a length parameter. 5825 * 5826 * @param parameterName the name of the parameter 5827 * @param reader An object that contains the data to set the parameter value to. 5828 * @throws SQLException if the driver does not support national character sets; 5829 * if the driver can detect that a data conversion 5830 * error could occur; if a database access error occurs or 5831 * this method is called on a closed <code>CallableStatement</code> 5832 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 5833 * 5834 * @since 1.6 5835 */ 5836 public void setNClob(String parameterName, Reader reader) 5837 throws SQLException{ 5838 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5839 } 5840 5841 5842 /** 5843 ** of characters specified by length otherwise a <code>SQLException</code> will becontain the number 5844 * generated when the <code>PreparedStatement</code> is executed. 5845 * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method 5846 * because it informs the driver that the parameter value should be sent to 5847 * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the 5848 * driver may have to do extra work to determine whether the parameter 5849 * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code> 5850 * @param parameterIndex index of the first parameter is 1, the second is 2, ... 5851 * @param reader An object that contains the data to set the parameter value to. 5852 * @param length the number of characters in the parameter data. 5853 * @throws SQLException if parameterIndex does not correspond to a parameter 5854 * marker in the SQL statement; if the length specified is less than zero; 5855 * if the driver does not support national character sets; 5856 * if the driver can detect that a data conversion 5857 * error could occur; if a database access error occurs or 5858 * this method is called on a closed <code>PreparedStatement</code> 5859 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 5860 * 5861 * @since 1.6 5862 */ 5863 public void setNClob(int parameterIndex, Reader reader, long length) 5864 throws SQLException{ 5865 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5866 } 5867 5868 5869 /** 5870 * Sets the designated parameter to a <code>java.sql.NClob</code> object. The driver converts this to 5871 a 5872 * SQL <code>NCLOB</code> value when it sends it to the database. 5873 * @param parameterIndex of the first parameter is 1, the second is 2, ... 5874 * @param value the parameter value 5875 * @throws SQLException if the driver does not support national 5876 * character sets; if the driver can detect that a data conversion 5877 * error could occur ; or if a database access error occurs 5878 * @since 1.6 5879 */ 5880 public void setNClob(int parameterIndex, NClob value) throws SQLException{ 5881 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5882 } 5883 5884 5885 /** 5886 * Sets the designated parameter to the given <code>String</code> object. 5887 * The driver converts this to a SQL <code>NCHAR</code> or 5888 * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> 5889 * @param parameterName the name of the column to be set 5890 * @param value the parameter value 5891 * @throws SQLException if the driver does not support national 5892 * character sets; if the driver can detect that a data conversion 5893 * error could occur; or if a database access error occurs 5894 * @since 1.6 5895 */ 5896 public void setNString(String parameterName, String value) 5897 throws SQLException{ 5898 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5899 } 5900 5901 /** 5902 * Sets the designated parameter to a <code>Reader</code> object. The 5903 * <code>Reader</code> reads the data till end-of-file is reached. The 5904 * driver does the necessary conversion from Java character format to 5905 * the national character set in the database. 5906 * @param parameterIndex of the first parameter is 1, the second is 2, ... 5907 * @param value the parameter value 5908 * @param length the number of characters in the parameter data. 5909 * @throws SQLException if the driver does not support national 5910 * character sets; if the driver can detect that a data conversion 5911 * error could occur ; or if a database access error occurs 5912 * @since 1.6 5913 */ 5914 public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException{ 5915 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5916 } 5917 5918 5919 5920 /** 5921 * Sets the designated parameter to a <code>Reader</code> object. The 5922 * <code>Reader</code> reads the data till end-of-file is reached. The 5923 * driver does the necessary conversion from Java character format to 5924 * the national character set in the database. 5925 * @param parameterName the name of the column to be set 5926 * @param value the parameter value 5927 * @param length the number of characters in the parameter data. 5928 * @throws SQLException if the driver does not support national 5929 * character sets; if the driver can detect that a data conversion 5930 * error could occur; or if a database access error occurs 5931 * @since 1.6 5932 */ 5933 public void setNCharacterStream(String parameterName, Reader value, long length) 5934 throws SQLException{ 5935 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5936 } 5937 5938 /** 5939 * Sets the designated parameter to a <code>Reader</code> object. The 5940 * <code>Reader</code> reads the data till end-of-file is reached. The 5941 * driver does the necessary conversion from Java character format to 5942 * the national character set in the database. 5943 5944 * <P><B>Note:</B> This stream object can either be a standard 5945 * Java stream object or your own subclass that implements the 5946 * standard interface. 5947 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5948 * it might be more efficient to use a version of 5949 * <code>setNCharacterStream</code> which takes a length parameter. 5950 * 5951 * @param parameterName the name of the parameter 5952 * @param value the parameter value 5953 * @throws SQLException if the driver does not support national 5954 * character sets; if the driver can detect that a data conversion 5955 * error could occur ; if a database access error occurs; or 5956 * this method is called on a closed <code>CallableStatement</code> 5957 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 5958 * @since 1.6 5959 */ 5960 public void setNCharacterStream(String parameterName, Reader value) throws SQLException{ 5961 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5962 } 5963 5964 /** 5965 * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value, 5966 * using the given <code>Calendar</code> object. The driver uses 5967 * the <code>Calendar</code> object to construct an SQL <code>TIMESTAMP</code> value, 5968 * which the driver then sends to the database. With a 5969 * a <code>Calendar</code> object, the driver can calculate the timestamp 5970 * taking into account a custom timezone. If no 5971 * <code>Calendar</code> object is specified, the driver uses the default 5972 * timezone, which is that of the virtual machine running the application. 5973 * 5974 * @param parameterName the name of the parameter 5975 * @param x the parameter value 5976 * @param cal the <code>Calendar</code> object the driver will use 5977 * to construct the timestamp 5978 * @exception SQLException if a database access error occurs or 5979 * this method is called on a closed <code>CallableStatement</code> 5980 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5981 * this method 5982 * @see #getTimestamp 5983 * @since 1.4 5984 */ 5985 public void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal) 5986 throws SQLException{ 5987 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5988 } 5989 5990 /** 5991 * Sets the designated parameter to a <code>Reader</code> object. The <code>reader</code> must contain the number 5992 * of characters specified by length otherwise a <code>SQLException</code> will be 5993 * generated when the <code>CallableStatement</code> is executed. 5994 * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method 5995 * because it informs the driver that the parameter value should be sent to 5996 * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the 5997 * driver may have to do extra work to determine whether the parameter 5998 * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code> 5999 * @param parameterName the name of the parameter to be set 6000 * @param reader An object that contains the data to set the parameter value to. 6001 * @param length the number of characters in the parameter data. 6002 * @throws SQLException if parameterIndex does not correspond to a parameter 6003 * marker in the SQL statement; if the length specified is less than zero; 6004 * a database access error occurs or 6005 * this method is called on a closed <code>CallableStatement</code> 6006 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6007 * this method 6008 * 6009 * @since 1.6 6010 */ 6011 public void setClob(String parameterName, Reader reader, long length) 6012 throws SQLException{ 6013 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6014 } 6015 6016 6017 6018 /** 6019 * Sets the designated parameter to the given <code>java.sql.Clob</code> object. 6020 * The driver converts this to an SQL <code>CLOB</code> value when it 6021 * sends it to the database. 6022 * 6023 * @param parameterName the name of the parameter 6024 * @param x a <code>Clob</code> object that maps an SQL <code>CLOB</code> value 6025 * @exception SQLException if a database access error occurs or 6026 * this method is called on a closed <code>CallableStatement</code> 6027 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6028 * this method 6029 * @since 1.6 6030 */ 6031 public void setClob (String parameterName, Clob x) throws SQLException{ 6032 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6033 } 6034 6035 /** 6036 * Sets the designated parameter to a <code>Reader</code> object. 6037 * This method differs from the <code>setCharacterStream (int, Reader)</code> method 6038 * because it informs the driver that the parameter value should be sent to 6039 * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the 6040 * driver may have to do extra work to determine whether the parameter 6041 * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code> 6042 * 6043 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 6044 * it might be more efficient to use a version of 6045 * <code>setClob</code> which takes a length parameter. 6046 * 6047 * @param parameterName the name of the parameter 6048 * @param reader An object that contains the data to set the parameter value to. 6049 * @throws SQLException if a database access error occurs or this method is called on 6050 * a closed <code>CallableStatement</code> 6051 * 6052 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6053 * @since 1.6 6054 */ 6055 public void setClob(String parameterName, Reader reader) 6056 throws SQLException{ 6057 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6058 } 6059 6060 6061 /** 6062 * Sets the designated parameter to the given <code>java.sql.Date</code> value 6063 * using the default time zone of the virtual machine that is running 6064 * the application. 6065 * The driver converts this 6066 * to an SQL <code>DATE</code> value when it sends it to the database. 6067 * 6068 * @param parameterName the name of the parameter 6069 * @param x the parameter value 6070 * @exception SQLException if a database access error occurs or 6071 * this method is called on a closed <code>CallableStatement</code> 6072 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6073 * this method 6074 * @see #getDate 6075 * @since 1.4 6076 */ 6077 public void setDate(String parameterName, java.sql.Date x) 6078 throws SQLException{ 6079 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6080 } 6081 6082 /** 6083 * Sets the designated parameter to the given <code>java.sql.Date</code> value, 6084 * using the given <code>Calendar</code> object. The driver uses 6085 * the <code>Calendar</code> object to construct an SQL <code>DATE</code> value, 6086 * which the driver then sends to the database. With a 6087 * a <code>Calendar</code> object, the driver can calculate the date 6088 * taking into account a custom timezone. If no 6089 * <code>Calendar</code> object is specified, the driver uses the default 6090 * timezone, which is that of the virtual machine running the application. 6091 * 6092 * @param parameterName the name of the parameter 6093 * @param x the parameter value 6094 * @param cal the <code>Calendar</code> object the driver will use 6095 * to construct the date 6096 * @exception SQLException if a database access error occurs or 6097 * this method is called on a closed <code>CallableStatement</code> 6098 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6099 * this method 6100 * @see #getDate 6101 * @since 1.4 6102 */ 6103 public void setDate(String parameterName, java.sql.Date x, Calendar cal) 6104 throws SQLException{ 6105 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6106 } 6107 6108 6109 /** 6110 * Sets the designated parameter to the given <code>java.sql.Time</code> value. 6111 * The driver converts this 6112 * to an SQL <code>TIME</code> value when it sends it to the database. 6113 * 6114 * @param parameterName the name of the parameter 6115 * @param x the parameter value 6116 * @exception SQLException if a database access error occurs or 6117 * this method is called on a closed <code>CallableStatement</code> 6118 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6119 * this method 6120 * @see #getTime 6121 * @since 1.4 6122 */ 6123 public void setTime(String parameterName, java.sql.Time x) 6124 throws SQLException{ 6125 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6126 } 6127 6128 /** 6129 * Sets the designated parameter to the given <code>java.sql.Time</code> value, 6130 * using the given <code>Calendar</code> object. The driver uses 6131 * the <code>Calendar</code> object to construct an SQL <code>TIME</code> value, 6132 * which the driver then sends to the database. With a 6133 * a <code>Calendar</code> object, the driver can calculate the time 6134 * taking into account a custom timezone. If no 6135 * <code>Calendar</code> object is specified, the driver uses the default 6136 * timezone, which is that of the virtual machine running the application. 6137 * 6138 * @param parameterName the name of the parameter 6139 * @param x the parameter value 6140 * @param cal the <code>Calendar</code> object the driver will use 6141 * to construct the time 6142 * @exception SQLException if a database access error occurs or 6143 * this method is called on a closed <code>CallableStatement</code> 6144 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6145 * this method 6146 * @see #getTime 6147 * @since 1.4 6148 */ 6149 public void setTime(String parameterName, java.sql.Time x, Calendar cal) 6150 throws SQLException{ 6151 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6152 } 6153 6154 /** 6155 * Sets the designated parameter to a <code>Reader</code> object. 6156 * This method differs from the <code>setCharacterStream (int, Reader)</code> method 6157 * because it informs the driver that the parameter value should be sent to 6158 * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the 6159 * driver may have to do extra work to determine whether the parameter 6160 * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code> 6161 * 6162 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 6163 * it might be more efficient to use a version of 6164 * <code>setClob</code> which takes a length parameter. 6165 * 6166 * @param parameterIndex index of the first parameter is 1, the second is 2, ... 6167 * @param reader An object that contains the data to set the parameter value to. 6168 * @throws SQLException if a database access error occurs, this method is called on 6169 * a closed <code>PreparedStatement</code>or if parameterIndex does not correspond to a parameter 6170 * marker in the SQL statement 6171 * 6172 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6173 * @since 1.6 6174 */ 6175 public void setClob(int parameterIndex, Reader reader) 6176 throws SQLException{ 6177 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6178 } 6179 6180 6181 /** 6182 * Sets the designated parameter to a <code>Reader</code> object. The reader must contain the number 6183 * of characters specified by length otherwise a <code>SQLException</code> will be 6184 * generated when the <code>PreparedStatement</code> is executed. 6185 *This method differs from the <code>setCharacterStream (int, Reader, int)</code> method 6186 * because it informs the driver that the parameter value should be sent to 6187 * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the 6188 * driver may have to do extra work to determine whether the parameter 6189 * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code> 6190 * @param parameterIndex index of the first parameter is 1, the second is 2, ... 6191 * @param reader An object that contains the data to set the parameter value to. 6192 * @param length the number of characters in the parameter data. 6193 * @throws SQLException if a database access error occurs, this method is called on 6194 * a closed <code>PreparedStatement</code>, if parameterIndex does not correspond to a parameter 6195 * marker in the SQL statement, or if the length specified is less than zero. 6196 * 6197 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6198 * @since 1.6 6199 */ 6200 public void setClob(int parameterIndex, Reader reader, long length) 6201 throws SQLException{ 6202 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6203 } 6204 6205 6206 /** 6207 * Sets the designated parameter to a <code>InputStream</code> object. The inputstream must contain the number 6208 * of characters specified by length otherwise a <code>SQLException</code> will be 6209 * generated when the <code>PreparedStatement</code> is executed. 6210 * This method differs from the <code>setBinaryStream (int, InputStream, int)</code> 6211 * method because it informs the driver that the parameter value should be 6212 * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used, 6213 * the driver may have to do extra work to determine whether the parameter 6214 * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code> 6215 * @param parameterIndex index of the first parameter is 1, 6216 * the second is 2, ... 6217 * @param inputStream An object that contains the data to set the parameter 6218 * value to. 6219 * @param length the number of bytes in the parameter data. 6220 * @throws SQLException if a database access error occurs, 6221 * this method is called on a closed <code>PreparedStatement</code>, 6222 * if parameterIndex does not correspond 6223 * to a parameter marker in the SQL statement, if the length specified 6224 * is less than zero or if the number of bytes in the inputstream does not match 6225 * the specified length. 6226 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6227 * 6228 * @since 1.6 6229 */ 6230 public void setBlob(int parameterIndex, InputStream inputStream, long length) 6231 throws SQLException{ 6232 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6233 } 6234 6235 /** 6236 * Sets the designated parameter to a <code>InputStream</code> object. 6237 * This method differs from the <code>setBinaryStream (int, InputStream)</code> 6238 * This method differs from the <code>setBinaryStream (int, InputStream)</code> 6239 * method because it informs the driver that the parameter value should be 6240 * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used, 6241 * the driver may have to do extra work to determine whether the parameter 6242 * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code> 6243 * 6244 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 6245 * it might be more efficient to use a version of 6246 * <code>setBlob</code> which takes a length parameter. 6247 * 6248 * @param parameterIndex index of the first parameter is 1, 6249 * the second is 2, ... 6250 6251 6252 * @param inputStream An object that contains the data to set the parameter 6253 * value to. 6254 * @throws SQLException if a database access error occurs, 6255 * this method is called on a closed <code>PreparedStatement</code> or 6256 * if parameterIndex does not correspond 6257 * to a parameter marker in the SQL statement, 6258 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6259 * 6260 * @since 1.6 6261 */ 6262 public void setBlob(int parameterIndex, InputStream inputStream) 6263 throws SQLException{ 6264 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6265 } 6266 6267 /** 6268 * Sets the designated parameter to a <code>InputStream</code> object. The <code>inputstream</code> must contain the number 6269 * of characters specified by length, otherwise a <code>SQLException</code> will be 6270 * generated when the <code>CallableStatement</code> is executed. 6271 * This method differs from the <code>setBinaryStream (int, InputStream, int)</code> 6272 * method because it informs the driver that the parameter value should be 6273 * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used, 6274 * the driver may have to do extra work to determine whether the parameter 6275 * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code> 6276 * 6277 * @param parameterName the name of the parameter to be set 6278 * the second is 2, ... 6279 * 6280 * @param inputStream An object that contains the data to set the parameter 6281 * value to. 6282 * @param length the number of bytes in the parameter data. 6283 * @throws SQLException if parameterIndex does not correspond 6284 * to a parameter marker in the SQL statement, or if the length specified 6285 * is less than zero; if the number of bytes in the inputstream does not match 6286 * the specified length; if a database access error occurs or 6287 * this method is called on a closed <code>CallableStatement</code> 6288 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6289 * this method 6290 * 6291 * @since 1.6 6292 */ 6293 public void setBlob(String parameterName, InputStream inputStream, long length) 6294 throws SQLException{ 6295 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6296 } 6297 6298 6299 /** 6300 * Sets the designated parameter to the given <code>java.sql.Blob</code> object. 6301 * The driver converts this to an SQL <code>BLOB</code> value when it 6302 * sends it to the database. 6303 * 6304 * @param parameterName the name of the parameter 6305 * @param x a <code>Blob</code> object that maps an SQL <code>BLOB</code> value 6306 * @exception SQLException if a database access error occurs or 6307 * this method is called on a closed <code>CallableStatement</code> 6308 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6309 * this method 6310 * @since 1.6 6311 */ 6312 public void setBlob (String parameterName, Blob x) throws SQLException{ 6313 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6314 } 6315 6316 /** 6317 * Sets the designated parameter to a <code>InputStream</code> object. 6318 * This method differs from the <code>setBinaryStream (int, InputStream)</code> 6319 * method because it informs the driver that the parameter value should be 6320 * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used, 6321 * the driver may have to do extra work to determine whether the parameter 6322 * data should be send to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code> 6323 * 6324 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 6325 * it might be more efficient to use a version of 6326 * <code>setBlob</code> which takes a length parameter. 6327 * 6328 * @param parameterName the name of the parameter 6329 * @param inputStream An object that contains the data to set the parameter 6330 * value to. 6331 * @throws SQLException if a database access error occurs or 6332 * this method is called on a closed <code>CallableStatement</code> 6333 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6334 * 6335 * @since 1.6 6336 */ 6337 public void setBlob(String parameterName, InputStream inputStream) 6338 throws SQLException{ 6339 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6340 } 6341 6342 /** 6343 * Sets the value of the designated parameter with the given object. The second 6344 * argument must be an object type; for integral values, the 6345 * <code>java.lang</code> equivalent objects should be used. 6346 * 6347 * <p>The given Java object will be converted to the given targetSqlType 6348 * before being sent to the database. 6349 * 6350 * If the object has a custom mapping (is of a class implementing the 6351 * interface <code>SQLData</code>), 6352 * the JDBC driver should call the method <code>SQLData.writeSQL</code> to write it 6353 * to the SQL data stream. 6354 * If, on the other hand, the object is of a class implementing 6355 * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>NClob</code>, 6356 * <code>Struct</code>, <code>java.net.URL</code>, 6357 * or <code>Array</code>, the driver should pass it to the database as a 6358 * value of the corresponding SQL type. 6359 * <P> 6360 * Note that this method may be used to pass datatabase- 6361 * specific abstract data types. 6362 * 6363 * @param parameterName the name of the parameter 6364 * @param x the object containing the input parameter value 6365 * @param targetSqlType the SQL type (as defined in java.sql.Types) to be 6366 * sent to the database. The scale argument may further qualify this type. 6367 * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types, 6368 * this is the number of digits after the decimal point. For all other 6369 * types, this value will be ignored. 6370 * @exception SQLException if a database access error occurs or 6371 * this method is called on a closed <code>CallableStatement</code> 6372 * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is 6373 * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>, 6374 * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>, 6375 * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>, 6376 * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code> 6377 * or <code>STRUCT</code> data type and the JDBC driver does not support 6378 * this data type 6379 * @see Types 6380 * @see #getObject 6381 * @since 1.4 6382 */ 6383 public void setObject(String parameterName, Object x, int targetSqlType, int scale) 6384 throws SQLException{ 6385 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6386 } 6387 6388 /** 6389 * Sets the value of the designated parameter with the given object. 6390 * This method is like the method <code>setObject</code> 6391 * above, except that it assumes a scale of zero. 6392 * 6393 * @param parameterName the name of the parameter 6394 * @param x the object containing the input parameter value 6395 * @param targetSqlType the SQL type (as defined in java.sql.Types) to be 6396 * sent to the database 6397 * @exception SQLException if a database access error occurs or 6398 * this method is called on a closed <code>CallableStatement</code> 6399 * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is 6400 * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>, 6401 * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>, 6402 * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>, 6403 * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code> 6404 * or <code>STRUCT</code> data type and the JDBC driver does not support 6405 * this data type 6406 * @see #getObject 6407 * @since 1.4 6408 */ 6409 public void setObject(String parameterName, Object x, int targetSqlType) 6410 throws SQLException{ 6411 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6412 } 6413 6414 /** 6415 * Sets the value of the designated parameter with the given object. 6416 * The second parameter must be of type <code>Object</code>; therefore, the 6417 * <code>java.lang</code> equivalent objects should be used for built-in types. 6418 * 6419 * <p>The JDBC specification specifies a standard mapping from 6420 * Java <code>Object</code> types to SQL types. The given argument 6421 * will be converted to the corresponding SQL type before being 6422 * sent to the database. 6423 * 6424 * <p>Note that this method may be used to pass datatabase- 6425 * specific abstract data types, by using a driver-specific Java 6426 * type. 6427 * 6428 * If the object is of a class implementing the interface <code>SQLData</code>, 6429 * the JDBC driver should call the method <code>SQLData.writeSQL</code> 6430 * to write it to the SQL data stream. 6431 * If, on the other hand, the object is of a class implementing 6432 * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>NClob</code>, 6433 * <code>Struct</code>, <code>java.net.URL</code>, 6434 * or <code>Array</code>, the driver should pass it to the database as a 6435 * value of the corresponding SQL type. 6436 * <P> 6437 * This method throws an exception if there is an ambiguity, for example, if the 6438 * object is of a class implementing more than one of the interfaces named above. 6439 * 6440 * @param parameterName the name of the parameter 6441 * @param x the object containing the input parameter value 6442 * @exception SQLException if a database access error occurs, 6443 * this method is called on a closed <code>CallableStatement</code> or if the given 6444 * <code>Object</code> parameter is ambiguous 6445 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6446 * this method 6447 * @see #getObject 6448 * @since 1.4 6449 */ 6450 public void setObject(String parameterName, Object x) throws SQLException{ 6451 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6452 } 6453 6454 /** 6455 * Sets the designated parameter to the given input stream, which will have 6456 * the specified number of bytes. 6457 * When a very large ASCII value is input to a <code>LONGVARCHAR</code> 6458 * parameter, it may be more practical to send it via a 6459 * <code>java.io.InputStream</code>. Data will be read from the stream 6460 * as needed until end-of-file is reached. The JDBC driver will 6461 * do any necessary conversion from ASCII to the database char format. 6462 * 6463 * <P><B>Note:</B> This stream object can either be a standard 6464 * Java stream object or your own subclass that implements the 6465 * standard interface. 6466 * 6467 * @param parameterName the name of the parameter 6468 * @param x the Java input stream that contains the ASCII parameter value 6469 * @param length the number of bytes in the stream 6470 * @exception SQLException if a database access error occurs or 6471 * this method is called on a closed <code>CallableStatement</code> 6472 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6473 * this method 6474 * @since 1.4 6475 */ 6476 public void setAsciiStream(String parameterName, java.io.InputStream x, int length) 6477 throws SQLException{ 6478 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6479 } 6480 6481 6482 /** 6483 * Sets the designated parameter to the given input stream, which will have 6484 * the specified number of bytes. 6485 * When a very large binary value is input to a <code>LONGVARBINARY</code> 6486 * parameter, it may be more practical to send it via a 6487 * <code>java.io.InputStream</code> object. The data will be read from the stream 6488 * as needed until end-of-file is reached. 6489 * 6490 * <P><B>Note:</B> This stream object can either be a standard 6491 * Java stream object or your own subclass that implements the 6492 * standard interface. 6493 * 6494 * @param parameterName the name of the parameter 6495 * @param x the java input stream which contains the binary parameter value 6496 * @param length the number of bytes in the stream 6497 * @exception SQLException if a database access error occurs or 6498 * this method is called on a closed <code>CallableStatement</code> 6499 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6500 * this method 6501 * @since 1.4 6502 */ 6503 public void setBinaryStream(String parameterName, java.io.InputStream x, 6504 int length) throws SQLException{ 6505 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6506 } 6507 6508 /** 6509 * Sets the designated parameter to the given <code>Reader</code> 6510 * object, which is the given number of characters long. 6511 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> 6512 * parameter, it may be more practical to send it via a 6513 * <code>java.io.Reader</code> object. The data will be read from the stream 6514 * as needed until end-of-file is reached. The JDBC driver will 6515 * do any necessary conversion from UNICODE to the database char format. 6516 * 6517 * <P><B>Note:</B> This stream object can either be a standard 6518 * Java stream object or your own subclass that implements the 6519 * standard interface. 6520 * 6521 * @param parameterName the name of the parameter 6522 * @param reader the <code>java.io.Reader</code> object that 6523 * contains the UNICODE data used as the designated parameter 6524 * @param length the number of characters in the stream 6525 * @exception SQLException if a database access error occurs or 6526 * this method is called on a closed <code>CallableStatement</code> 6527 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6528 * this method 6529 * @since 1.4 6530 */ 6531 public void setCharacterStream(String parameterName, 6532 java.io.Reader reader, 6533 int length) throws SQLException{ 6534 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6535 } 6536 6537 /** 6538 * Sets the designated parameter to the given input stream. 6539 * When a very large ASCII value is input to a <code>LONGVARCHAR</code> 6540 * parameter, it may be more practical to send it via a 6541 * <code>java.io.InputStream</code>. Data will be read from the stream 6542 * as needed until end-of-file is reached. The JDBC driver will 6543 * do any necessary conversion from ASCII to the database char format. 6544 * 6545 * <P><B>Note:</B> This stream object can either be a standard 6546 * Java stream object or your own subclass that implements the 6547 * standard interface. 6548 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 6549 * it might be more efficient to use a version of 6550 * <code>setAsciiStream</code> which takes a length parameter. 6551 * 6552 * @param parameterName the name of the parameter 6553 * @param x the Java input stream that contains the ASCII parameter value 6554 * @exception SQLException if a database access error occurs or 6555 * this method is called on a closed <code>CallableStatement</code> 6556 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6557 * @since 1.6 6558 */ 6559 public void setAsciiStream(String parameterName, java.io.InputStream x) 6560 throws SQLException{ 6561 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6562 } 6563 6564 6565 /** 6566 * Sets the designated parameter to the given input stream. 6567 * When a very large binary value is input to a <code>LONGVARBINARY</code> 6568 * parameter, it may be more practical to send it via a 6569 * <code>java.io.InputStream</code> object. The data will be read from the 6570 * stream as needed until end-of-file is reached. 6571 * 6572 * <P><B>Note:</B> This stream object can either be a standard 6573 * Java stream object or your own subclass that implements the 6574 * standard interface. 6575 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 6576 * it might be more efficient to use a version of 6577 * <code>setBinaryStream</code> which takes a length parameter. 6578 * 6579 * @param parameterName the name of the parameter 6580 * @param x the java input stream which contains the binary parameter value 6581 * @exception SQLException if a database access error occurs or 6582 * this method is called on a closed <code>CallableStatement</code> 6583 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6584 * @since 1.6 6585 */ 6586 public void setBinaryStream(String parameterName, java.io.InputStream x) 6587 throws SQLException{ 6588 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6589 } 6590 6591 /** 6592 * Sets the designated parameter to the given <code>Reader</code> 6593 * object. 6594 * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> 6595 * parameter, it may be more practical to send it via a 6596 * <code>java.io.Reader</code> object. The data will be read from the stream 6597 * as needed until end-of-file is reached. The JDBC driver will 6598 * do any necessary conversion from UNICODE to the database char format. 6599 * 6600 * <P><B>Note:</B> This stream object can either be a standard 6601 * Java stream object or your own subclass that implements the 6602 * standard interface. 6603 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 6604 * it might be more efficient to use a version of 6605 * <code>setCharacterStream</code> which takes a length parameter. 6606 * 6607 * @param parameterName the name of the parameter 6608 * @param reader the <code>java.io.Reader</code> object that contains the 6609 * Unicode data 6610 * @exception SQLException if a database access error occurs or 6611 * this method is called on a closed <code>CallableStatement</code> 6612 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6613 * @since 1.6 6614 */ 6615 public void setCharacterStream(String parameterName, 6616 java.io.Reader reader) throws SQLException{ 6617 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6618 } 6619 6620 /** 6621 * Sets the designated parameter to the given 6622 * <code>java.math.BigDecimal</code> value. 6623 * The driver converts this to an SQL <code>NUMERIC</code> value when 6624 * it sends it to the database. 6625 * 6626 * @param parameterName the name of the parameter 6627 * @param x the parameter value 6628 * @exception SQLException if a database access error occurs or 6629 * this method is called on a closed <code>CallableStatement</code> 6630 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6631 * this method 6632 * @see #getBigDecimal 6633 * @since 1.4 6634 */ 6635 public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException{ 6636 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6637 } 6638 6639 /** 6640 * Sets the designated parameter to the given Java <code>String</code> value. 6641 * The driver converts this 6642 * to an SQL <code>VARCHAR</code> or <code>LONGVARCHAR</code> value 6643 * (depending on the argument's 6644 * size relative to the driver's limits on <code>VARCHAR</code> values) 6645 * when it sends it to the database. 6646 * 6647 * @param parameterName the name of the parameter 6648 * @param x the parameter value 6649 * @exception SQLException if a database access error occurs or 6650 * this method is called on a closed <code>CallableStatement</code> 6651 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6652 * this method 6653 * @see #getString 6654 * @since 1.4 6655 */ 6656 public void setString(String parameterName, String x) throws SQLException{ 6657 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6658 } 6659 6660 6661 6662 /** 6663 * Sets the designated parameter to the given Java array of bytes. 6664 * The driver converts this to an SQL <code>VARBINARY</code> or 6665 * <code>LONGVARBINARY</code> (depending on the argument's size relative 6666 * to the driver's limits on <code>VARBINARY</code> values) when it sends 6667 * it to the database. 6668 * 6669 * @param parameterName the name of the parameter 6670 * @param x the parameter value 6671 * @exception SQLException if a database access error occurs or 6672 * this method is called on a closed <code>CallableStatement</code> 6673 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6674 * this method 6675 * @see #getBytes 6676 * @since 1.4 6677 */ 6678 public void setBytes(String parameterName, byte x[]) throws SQLException{ 6679 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6680 } 6681 6682 /** 6683 * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value. 6684 * The driver 6685 * converts this to an SQL <code>TIMESTAMP</code> value when it sends it to the 6686 * database. 6687 * 6688 * @param parameterName the name of the parameter 6689 * @param x the parameter value 6690 * @exception SQLException if a database access error occurs or 6691 * this method is called on a closed <code>CallableStatement</code> 6692 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6693 * this method 6694 * @see #getTimestamp 6695 * @since 1.4 6696 */ 6697 public void setTimestamp(String parameterName, java.sql.Timestamp x) 6698 throws SQLException{ 6699 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6700 } 6701 6702 /** 6703 * Sets the designated parameter to SQL <code>NULL</code>. 6704 * 6705 * <P><B>Note:</B> You must specify the parameter's SQL type. 6706 * 6707 * @param parameterName the name of the parameter 6708 * @param sqlType the SQL type code defined in <code>java.sql.Types</code> 6709 * @exception SQLException if a database access error occurs or 6710 * this method is called on a closed <code>CallableStatement</code> 6711 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6712 * this method 6713 * @since 1.4 6714 */ 6715 public void setNull(String parameterName, int sqlType) throws SQLException { 6716 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6717 } 6718 6719 /** 6720 * Sets the designated parameter to SQL <code>NULL</code>. 6721 * This version of the method <code>setNull</code> should 6722 * be used for user-defined types and REF type parameters. Examples 6723 * of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and 6724 * named array types. 6725 * 6726 * <P><B>Note:</B> To be portable, applications must give the 6727 * SQL type code and the fully-qualified SQL type name when specifying 6728 * a NULL user-defined or REF parameter. In the case of a user-defined type 6729 * the name is the type name of the parameter itself. For a REF 6730 * parameter, the name is the type name of the referenced type. If 6731 * a JDBC driver does not need the type code or type name information, 6732 * it may ignore it. 6733 * 6734 * Although it is intended for user-defined and Ref parameters, 6735 * this method may be used to set a null parameter of any JDBC type. 6736 * If the parameter does not have a user-defined or REF type, the given 6737 * typeName is ignored. 6738 * 6739 * 6740 * @param parameterName the name of the parameter 6741 * @param sqlType a value from <code>java.sql.Types</code> 6742 * @param typeName the fully-qualified name of an SQL user-defined type; 6743 * ignored if the parameter is not a user-defined type or 6744 * SQL <code>REF</code> value 6745 * @exception SQLException if a database access error occurs or 6746 * this method is called on a closed <code>CallableStatement</code> 6747 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6748 * this method 6749 * @since 1.4 6750 */ 6751 public void setNull (String parameterName, int sqlType, String typeName) 6752 throws SQLException{ 6753 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6754 } 6755 6756 /** 6757 * Sets the designated parameter to the given Java <code>boolean</code> value. 6758 * The driver converts this 6759 * to an SQL <code>BIT</code> or <code>BOOLEAN</code> value when it sends it to the database. 6760 * 6761 * @param parameterName the name of the parameter 6762 * @param x the parameter value 6763 * @exception SQLException if a database access error occurs or 6764 * this method is called on a closed <code>CallableStatement</code> 6765 * @see #getBoolean 6766 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6767 * this method 6768 * @since 1.4 6769 */ 6770 public void setBoolean(String parameterName, boolean x) throws SQLException{ 6771 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6772 } 6773 6774 6775 6776 /** 6777 * Sets the designated parameter to the given Java <code>byte</code> value. 6778 * The driver converts this 6779 * to an SQL <code>TINYINT</code> value when it sends it to the database. 6780 * 6781 * @param parameterName the name of the parameter 6782 * @param x the parameter value 6783 * @exception SQLException if a database access error occurs or 6784 * this method is called on a closed <code>CallableStatement</code> 6785 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6786 * this method 6787 * @see #getByte 6788 * @since 1.4 6789 */ 6790 public void setByte(String parameterName, byte x) throws SQLException{ 6791 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6792 } 6793 6794 6795 /** 6796 * Sets the designated parameter to the given Java <code>short</code> value. 6797 * The driver converts this 6798 * to an SQL <code>SMALLINT</code> value when it sends it to the database. 6799 * 6800 * @param parameterName the name of the parameter 6801 * @param x the parameter value 6802 * @exception SQLException if a database access error occurs or 6803 * this method is called on a closed <code>CallableStatement</code> 6804 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6805 * this method 6806 * @see #getShort 6807 * @since 1.4 6808 */ 6809 public void setShort(String parameterName, short x) throws SQLException{ 6810 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6811 } 6812 6813 6814 /** 6815 * Sets the designated parameter to the given Java <code>int</code> value. 6816 * The driver converts this 6817 * to an SQL <code>INTEGER</code> value when it sends it to the database. 6818 * 6819 * @param parameterName the name of the parameter 6820 * @param x the parameter value 6821 * @exception SQLException if a database access error occurs or 6822 * this method is called on a closed <code>CallableStatement</code> 6823 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6824 * this method 6825 * @see #getInt 6826 * @since 1.4 6827 */ 6828 public void setInt(String parameterName, int x) throws SQLException{ 6829 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6830 } 6831 6832 /** 6833 * Sets the designated parameter to the given Java <code>long</code> value. 6834 * The driver converts this 6835 * to an SQL <code>BIGINT</code> value when it sends it to the database. 6836 * 6837 * @param parameterName the name of the parameter 6838 * @param x the parameter value 6839 * @exception SQLException if a database access error occurs or 6840 * this method is called on a closed <code>CallableStatement</code> 6841 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6842 * this method 6843 * @see #getLong 6844 * @since 1.4 6845 */ 6846 public void setLong(String parameterName, long x) throws SQLException{ 6847 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6848 } 6849 6850 6851 /** 6852 * Sets the designated parameter to the given Java <code>float</code> value. 6853 * The driver converts this 6854 * to an SQL <code>FLOAT</code> value when it sends it to the database. 6855 * 6856 * @param parameterName the name of the parameter 6857 * @param x the parameter value 6858 * @exception SQLException if a database access error occurs or 6859 * this method is called on a closed <code>CallableStatement</code> 6860 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6861 * this method 6862 * @see #getFloat 6863 * @since 1.4 6864 */ 6865 public void setFloat(String parameterName, float x) throws SQLException{ 6866 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6867 } 6868 6869 /** 6870 * Sets the designated parameter to the given Java <code>double</code> value. 6871 * The driver converts this 6872 * to an SQL <code>DOUBLE</code> value when it sends it to the database. 6873 * 6874 * @param parameterName the name of the parameter 6875 * @param x the parameter value 6876 * @exception SQLException if a database access error occurs or 6877 * this method is called on a closed <code>CallableStatement</code> 6878 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6879 * this method 6880 * @see #getDouble 6881 * @since 1.4 6882 */ 6883 public void setDouble(String parameterName, double x) throws SQLException{ 6884 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6885 } 6886 6887 /** 6888 * This method re populates the resBundle 6889 * during the deserialization process 6890 * 6891 */ 6892 private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException { 6893 // Default state initialization happens here 6894 ois.defaultReadObject(); 6895 // Initialization of transient Res Bundle happens here . 6896 try { 6897 resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle(); 6898 } catch(IOException ioe) {} 6899 6900 } 6901 6902 static final long serialVersionUID = -3591946023893483003L; 6903 6904 //------------------------- JDBC 4.1 ----------------------------------- 6905 6906 public <T> T getObject(int columnIndex, Class<T> type) throws SQLException { 6907 throw new SQLFeatureNotSupportedException("Not supported yet."); 6908 } 6909 6910 public <T> T getObject(String columnLabel, Class<T> type) throws SQLException { | 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package com.sun.rowset; 27 28 import java.sql.*; 29 import javax.sql.*; 30 import javax.naming.*; 31 import java.io.*; 32 import java.math.*; 33 import java.util.*; 34 35 import javax.sql.rowset.*; 36 37 /** 38 * The standard implementation of the {@code JdbcRowSet} interface. See the interface 39 * definition for full behavior and implementation requirements. 40 * 41 * @author Jonathan Bruce, Amit Handa 42 */ 43 44 public class JdbcRowSetImpl extends BaseRowSet implements JdbcRowSet, Joinable { 45 46 /** 47 * The {@code Connection} object that is this rowset's 48 * current connection to the database. This field is set 49 * internally when the connection is established. 50 */ 51 private Connection conn; 52 53 /** 54 * The {@code PreparedStatement} object that is this rowset's 55 * current command. This field is set internally when the method 56 * {@code execute} creates the {@code PreparedStatement} 57 * object. 58 */ 59 private PreparedStatement ps; 60 61 /** 62 * The {@code ResultSet} object that is this rowset's 63 * current result set. This field is set internally when the method 64 * {@code execute} executes the rowset's command and thereby 65 * creates the rowset's {@code ResultSet} object. 66 */ 67 private ResultSet rs; 68 69 /** 70 * The {@code RowSetMetaDataImpl} object that is constructed when 71 * a {@code ResultSet} object is passed to the {@code JdbcRowSet} 72 * constructor. This helps in constructing all metadata associated 73 * with the {@code ResultSet} object using the setter methods of 74 * {@code RowSetMetaDataImpl}. 75 */ 76 private RowSetMetaDataImpl rowsMD; 77 78 /** 79 * The {@code ResultSetMetaData} object from which this 80 * {@code RowSetMetaDataImpl} is formed and which helps in getting 81 * the metadata information. 82 */ 83 private ResultSetMetaData resMD; 84 85 86 /** 87 * The Vector holding the Match Columns 88 */ 89 private Vector<Integer> iMatchColumns; 90 91 /** 92 * The Vector that will hold the Match Column names. 93 */ 94 private Vector<String> strMatchColumns; 95 96 97 protected transient JdbcRowSetResourceBundle resBundle; 98 99 /** 100 * Constructs a default {@code JdbcRowSet} object. 101 * The new instance of {@code JdbcRowSet} will serve as a proxy 102 * for the {@code ResultSet} object it creates, and by so doing, 103 * it will make it possible to use the result set as a JavaBeans 104 * component. 105 * <P> 106 * The following is true of a default {@code JdbcRowSet} instance: 107 * <UL> 108 * <LI>Does not show deleted rows 109 * <LI>Has no time limit for how long a driver may take to 110 * execute the rowset's command 111 * <LI>Has no limit for the number of rows it may contain 112 * <LI>Has no limit for the number of bytes a column may contain 113 * <LI>Has a scrollable cursor and does not show changes 114 * made by others 115 * <LI>Will not see uncommitted data (make "dirty" reads) 116 * <LI>Has escape processing turned on 117 * <LI>Has its connection's type map set to {@code null} 118 * <LI>Has an empty {@code Hashtable} object for storing any 119 * parameters that are set 120 * </UL> 121 * A newly created {@code JdbcRowSet} object must have its 122 * {@code execute} method invoked before other public methods 123 * are called on it; otherwise, such method calls will cause an 124 * exception to be thrown. 125 * 126 * @throws SQLException [1] if any of its public methods are called prior 127 * to calling the {@code execute} method; [2] if invalid JDBC driver 128 * properties are set or [3] if no connection to a data source exists. 129 */ 130 public JdbcRowSetImpl() { 131 conn = null; 132 ps = null; 133 rs = null; 134 135 try { 136 resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle(); 137 } catch(IOException ioe) { 138 throw new RuntimeException(ioe); 139 } 140 141 142 initParams(); 143 144 // set the defaults 145 146 try { 147 setShowDeleted(false); 200 setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED); 201 } catch(SQLException sqle){ 202 System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.settransactionisolation").toString() + 203 sqle.getLocalizedMessage()); 204 } 205 206 //Instantiating the vector for MatchColumns 207 208 iMatchColumns = new Vector<Integer>(10); 209 for(int i = 0; i < 10 ; i++) { 210 iMatchColumns.add(i,Integer.valueOf(-1)); 211 } 212 213 strMatchColumns = new Vector<String>(10); 214 for(int j = 0; j < 10; j++) { 215 strMatchColumns.add(j,null); 216 } 217 } 218 219 /** 220 * Constructs a default {@code JdbcRowSet} object given a 221 * valid {@code Connection} object. The new 222 * instance of {@code JdbcRowSet} will serve as a proxy for 223 * the {@code ResultSet} object it creates, and by so doing, 224 * it will make it possible to use the result set as a JavaBeans 225 * component. 226 * <P> 227 * The following is true of a default {@code JdbcRowSet} instance: 228 * <UL> 229 * <LI>Does not show deleted rows 230 * <LI>Has no time limit for how long a driver may take to 231 * execute the rowset's command 232 * <LI>Has no limit for the number of rows it may contain 233 * <LI>Has no limit for the number of bytes a column may contain 234 * <LI>Has a scrollable cursor and does not show changes 235 * made by others 236 * <LI>Will not see uncommitted data (make "dirty" reads) 237 * <LI>Has escape processing turned on 238 * <LI>Has its connection's type map set to {@code null} 239 * <LI>Has an empty {@code Hashtable} object for storing any 240 * parameters that are set 241 * </UL> 242 * A newly created {@code JdbcRowSet} object must have its 243 * {@code execute} method invoked before other public methods 244 * are called on it; otherwise, such method calls will cause an 245 * exception to be thrown. 246 * 247 * @throws SQLException [1] if any of its public methods are called prior 248 * to calling the {@code execute} method, [2] if invalid JDBC driver 249 * properties are set, or [3] if no connection to a data source exists. 250 */ 251 public JdbcRowSetImpl(Connection con) throws SQLException { 252 253 conn = con; 254 ps = null; 255 rs = null; 256 257 try { 258 resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle(); 259 } catch(IOException ioe) { 260 throw new RuntimeException(ioe); 261 } 262 263 264 initParams(); 265 // set the defaults 266 setShowDeleted(false); 267 setQueryTimeout(0); 268 setMaxRows(0); 272 273 setReadOnly(true); 274 setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED); 275 setEscapeProcessing(true); 276 setTypeMap(null); 277 278 //Instantiating the vector for MatchColumns 279 280 iMatchColumns = new Vector<Integer>(10); 281 for(int i = 0; i < 10 ; i++) { 282 iMatchColumns.add(i,Integer.valueOf(-1)); 283 } 284 285 strMatchColumns = new Vector<String>(10); 286 for(int j = 0; j < 10; j++) { 287 strMatchColumns.add(j,null); 288 } 289 } 290 291 /** 292 * Constructs a default {@code JdbcRowSet} object using the 293 * URL, username, and password arguments supplied. The new 294 * instance of {@code JdbcRowSet} will serve as a proxy for 295 * the {@code ResultSet} object it creates, and by so doing, 296 * it will make it possible to use the result set as a JavaBeans 297 * component. 298 * 299 * <P> 300 * The following is true of a default {@code JdbcRowSet} instance: 301 * <UL> 302 * <LI>Does not show deleted rows 303 * <LI>Has no time limit for how long a driver may take to 304 * execute the rowset's command 305 * <LI>Has no limit for the number of rows it may contain 306 * <LI>Has no limit for the number of bytes a column may contain 307 * <LI>Has a scrollable cursor and does not show changes 308 * made by others 309 * <LI>Will not see uncommitted data (make "dirty" reads) 310 * <LI>Has escape processing turned on 311 * <LI>Has its connection's type map set to {@code null} 312 * <LI>Has an empty {@code Hashtable} object for storing any 313 * parameters that are set 314 * </UL> 315 * 316 * @param url a JDBC URL for the database to which this {@code JdbcRowSet} 317 * object will be connected. The form for a JDBC URL is 318 * {@code jdbc:subprotocol:subname}. 319 * @param user the database user on whose behalf the connection 320 * is being made 321 * @param password the user's password 322 * 323 * @throws SQLException if a database access error occurs 324 * 325 */ 326 public JdbcRowSetImpl(String url, String user, String password) throws SQLException { 327 conn = null; 328 ps = null; 329 rs = null; 330 331 try { 332 resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle(); 333 } catch(IOException ioe) { 334 throw new RuntimeException(ioe); 335 } 336 337 338 initParams(); 339 340 // Pass the arguments to BaseRowSet 341 // setter methods now. 355 setReadOnly(true); 356 setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED); 357 setEscapeProcessing(true); 358 setTypeMap(null); 359 360 //Instantiating the vector for MatchColumns 361 362 iMatchColumns = new Vector<Integer>(10); 363 for(int i = 0; i < 10 ; i++) { 364 iMatchColumns.add(i,Integer.valueOf(-1)); 365 } 366 367 strMatchColumns = new Vector<String>(10); 368 for(int j = 0; j < 10; j++) { 369 strMatchColumns.add(j,null); 370 } 371 } 372 373 374 /** 375 * Constructs a {@code JdbcRowSet} object using the given valid 376 * {@code ResultSet} object. The new 377 * instance of {@code JdbcRowSet} will serve as a proxy for 378 * the {@code ResultSet} object, and by so doing, 379 * it will make it possible to use the result set as a JavaBeans 380 * component. 381 * 382 * <P> 383 * The following is true of a default {@code JdbcRowSet} instance: 384 * <UL> 385 * <LI>Does not show deleted rows 386 * <LI>Has no time limit for how long a driver may take to 387 * execute the rowset's command 388 * <LI>Has no limit for the number of rows it may contain 389 * <LI>Has no limit for the number of bytes a column may contain 390 * <LI>Has a scrollable cursor and does not show changes 391 * made by others 392 * <LI>Will not see uncommitted data (make "dirty" reads) 393 * <LI>Has escape processing turned on 394 * <LI>Has its connection's type map set to {@code null} 395 * <LI>Has an empty {@code Hashtable} object for storing any 396 * parameters that are set 397 * </UL> 398 * 399 * @param res a valid {@code ResultSet} object 400 * 401 * @throws SQLException if a database access occurs due to a non 402 * valid ResultSet handle. 403 */ 404 public JdbcRowSetImpl(ResultSet res) throws SQLException { 405 406 // A ResultSet handle encapsulates a connection handle. 407 // But there is no way we can retrieve a Connection handle 408 // from a ResultSet object. 409 // So to avoid any anomalies we keep the conn = null 410 // The passed rs handle will be a wrapper around for 411 // "this" object's all operations. 412 conn = null; 413 414 ps = null; 415 416 rs = res; 417 418 try { 419 resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle(); 443 resMD = rs.getMetaData(); 444 445 rowsMD = new RowSetMetaDataImpl(); 446 447 initMetaData(rowsMD, resMD); 448 449 //Instantiating the vector for MatchColumns 450 451 iMatchColumns = new Vector<Integer>(10); 452 for(int i = 0; i < 10 ; i++) { 453 iMatchColumns.add(i,Integer.valueOf(-1)); 454 } 455 456 strMatchColumns = new Vector<String>(10); 457 for(int j = 0; j < 10; j++) { 458 strMatchColumns.add(j,null); 459 } 460 } 461 462 /** 463 * Initializes the given {@code RowSetMetaData} object with the values 464 * in the given {@code ResultSetMetaData} object. 465 * 466 * @param md the {@code RowSetMetaData} object for this 467 * {@code JdbcRowSetImpl} object, which will be set with 468 * values from rsmd 469 * @param rsmd the {@code ResultSetMetaData} object from which new 470 * values for md will be read 471 * @throws SQLException if an error occurs 472 */ 473 protected void initMetaData(RowSetMetaData md, ResultSetMetaData rsmd) throws SQLException { 474 int numCols = rsmd.getColumnCount(); 475 476 md.setColumnCount(numCols); 477 for (int col=1; col <= numCols; col++) { 478 md.setAutoIncrement(col, rsmd.isAutoIncrement(col)); 479 md.setCaseSensitive(col, rsmd.isCaseSensitive(col)); 480 md.setCurrency(col, rsmd.isCurrency(col)); 481 md.setNullable(col, rsmd.isNullable(col)); 482 md.setSigned(col, rsmd.isSigned(col)); 483 md.setSearchable(col, rsmd.isSearchable(col)); 484 md.setColumnDisplaySize(col, rsmd.getColumnDisplaySize(col)); 485 md.setColumnLabel(col, rsmd.getColumnLabel(col)); 486 md.setColumnName(col, rsmd.getColumnName(col)); 487 md.setSchemaName(col, rsmd.getSchemaName(col)); 488 md.setPrecision(col, rsmd.getPrecision(col)); 489 md.setScale(col, rsmd.getScale(col)); 494 } 495 } 496 497 498 protected void checkState() throws SQLException { 499 500 // If all the three i.e. conn, ps & rs are 501 // simultaneously null implies we are not connected 502 // to the db, implies undesirable state so throw exception 503 504 if (conn == null && ps == null && rs == null ) { 505 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.invalstate").toString()); 506 } 507 } 508 509 //--------------------------------------------------------------------- 510 // Reading and writing data 511 //--------------------------------------------------------------------- 512 513 /** 514 * Creates the internal {@code ResultSet} object for which this 515 * {@code JdbcRowSet} object is a wrapper, effectively 516 * making the result set a JavaBeans component. 517 * <P> 518 * Certain properties must have been set before this method is called 519 * so that it can establish a connection to a database and execute the 520 * query that will create the result set. If a {@code DataSource} 521 * object will be used to create the connection, properties for the 522 * data source name, user name, and password must be set. If the 523 * {@code DriverManager} will be used, the properties for the 524 * URL, user name, and password must be set. In either case, the 525 * property for the command must be set. If the command has placeholder 526 * parameters, those must also be set. This method throws 527 * an exception if the required properties are not set. 528 * <P> 529 * Other properties have default values that may optionally be set 530 * to new values. The {@code execute} method will use the value 531 * for the command property to create a {@code PreparedStatement} 532 * object and set its properties (escape processing, maximum field 533 * size, maximum number of rows, and query timeout limit) to be those 534 * of this rowset. 535 * 536 * @throws SQLException if (1) a database access error occurs, 537 * (2) any required JDBC properties are not set, or (3) if an 538 * invalid connection exists. 539 */ 540 public void execute() throws SQLException { 541 /* 542 * To execute based on the properties: 543 * i) determine how to get a connection 544 * ii) prepare the statement 545 * iii) set the properties of the statement 546 * iv) parse the params. and set them 547 * v) execute the statement 548 * 549 * During all of this try to tolerate as many errors 550 * as possible, many drivers will not support all of 551 * the properties and will/should throw SQLException 767 ((Integer)param[2]).intValue()); 768 continue; 769 } 770 771 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.paramtype").toString()); 772 773 } else { 774 // common case - this catches all SQL92 types 775 ps.setObject(i + 1, params[i]); 776 continue; 777 } 778 } else { 779 // Try to get all the params to be set here 780 ps.setObject(i + 1, params[i]); 781 782 } 783 } 784 } 785 786 /** 787 * Moves the cursor for this rowset's {@code ResultSet} 788 * object down one row from its current position. 789 * A {@code ResultSet} cursor is initially positioned 790 * before the first row; the first call to the method 791 * {@code next} makes the first row the current row; the 792 * second call makes the second row the current row, and so on. 793 * 794 * <P>If an input stream is open for the current row, a call 795 * to the method {@code next} will 796 * implicitly close it. A {@code ResultSet} object's 797 * warning chain is cleared when a new row is read. 798 * 799 * @return {@code true} if the new current row is valid; 800 * {@code false} if there are no more rows 801 * @throws SQLException if a database access error occurs 802 * or this rowset does not currently have a valid connection, 803 * prepared statement, and result set 804 */ 805 public boolean next() throws SQLException { 806 checkState(); 807 808 boolean b = rs.next(); 809 notifyCursorMoved(); 810 return b; 811 } 812 813 /** 814 * Releases this rowset's {@code ResultSet} object's database and 815 * JDBC resources immediately instead of waiting for 816 * this to happen when it is automatically closed. 817 * 818 * <P><B>Note:</B> A {@code ResultSet} object 819 * is automatically closed by the 820 * {@code Statement} object that generated it when 821 * that {@code Statement} object is closed, 822 * re-executed, or is used to retrieve the next result from a 823 * sequence of multiple results. A {@code ResultSet} object 824 * is also automatically closed when it is garbage collected. 825 * 826 * @throws SQLException if a database access error occurs 827 */ 828 public void close() throws SQLException { 829 if (rs != null) 830 rs.close(); 831 if (ps != null) 832 ps.close(); 833 if (conn != null) 834 conn.close(); 835 } 836 837 /** 838 * Reports whether the last column read from this rowset's 839 * {@code ResultSet} object had a value of SQL {@code NULL}. 840 * Note that you must first call one of the {@code getXXX} methods 841 * on a column to try to read its value and then call 842 * the method {@code wasNull} to see if the value read was 843 * SQL {@code NULL}. 844 * 845 * @return {@code true} if the last column value read was SQL 846 * {@code NULL} and {@code false} otherwise 847 * @throws SQLException if a database access error occurs 848 * or this rowset does not have a currently valid connection, 849 * prepared statement, and result set 850 */ 851 public boolean wasNull() throws SQLException { 852 checkState(); 853 854 return rs.wasNull(); 855 } 856 857 //====================================================================== 858 // Methods for accessing results by column index 859 //====================================================================== 860 861 /** 862 * Gets the value of the designated column in the current row 863 * of this rowset's {@code ResultSet} object as 864 * a {@code String}. 865 * 866 * @param columnIndex the first column is 1, the second is 2, and so on 867 * @return the column value; if the value is SQL {@code NULL}, the 868 * value returned is {@code null} 869 * @throws SQLException if (1) a database access error occurs 870 * or (2) this rowset does not currently have a valid connection, 871 * prepared statement, and result set 872 */ 873 public String getString(int columnIndex) throws SQLException { 874 checkState(); 875 876 return rs.getString(columnIndex); 877 } 878 879 /** 880 * Gets the value of the designated column in the current row 881 * of this rowset's {@code ResultSet} object as 882 * a {@code boolean}. 883 * 884 * @param columnIndex the first column is 1, the second is 2, and so on 885 * @return the column value; if the value is SQL {@code NULL}, the 886 * value returned is {@code false} 887 * @throws SQLException if (1) a database access error occurs 888 * or (2) this rowset does not have a currently valid connection, 889 * prepared statement, and result set 890 */ 891 public boolean getBoolean(int columnIndex) throws SQLException { 892 checkState(); 893 894 return rs.getBoolean(columnIndex); 895 } 896 897 /** 898 * Gets the value of the designated column in the current row 899 * of this rowset's {@code ResultSet} object as 900 * a {@code byte}. 901 * 902 * @param columnIndex the first column is 1, the second is 2, and so on 903 * @return the column value; if the value is SQL {@code NULL}, the 904 * value returned is {@code 0} 905 * @throws SQLException if (1) a database access error occurs 906 * or (2) this rowset does not have a currently valid connection, 907 * prepared statement, and result set 908 */ 909 public byte getByte(int columnIndex) throws SQLException { 910 checkState(); 911 912 return rs.getByte(columnIndex); 913 } 914 915 /** 916 * Gets the value of the designated column in the current row 917 * of this rowset's {@code ResultSet} object as 918 * a {@code short}. 919 * 920 * @param columnIndex the first column is 1, the second is 2, and so on 921 * @return the column value; if the value is SQL {@code NULL}, the 922 * value returned is {@code 0} 923 * @throws SQLException if (1) a database access error occurs 924 * or (2) this rowset does not have a currently valid connection, 925 * prepared statement, and result set 926 */ 927 public short getShort(int columnIndex) throws SQLException { 928 checkState(); 929 930 return rs.getShort(columnIndex); 931 } 932 933 /** 934 * Gets the value of the designated column in the current row 935 * of this rowset's {@code ResultSet} object as 936 * an {@code int}. 937 * 938 * @param columnIndex the first column is 1, the second is 2, and so on 939 * @return the column value; if the value is SQL {@code NULL}, the 940 * value returned is {@code 0} 941 * @throws SQLException if (1) a database access error occurs 942 * or (2) this rowset does not have a currently valid connection, 943 * prepared statement, and result set 944 */ 945 public int getInt(int columnIndex) throws SQLException { 946 checkState(); 947 948 return rs.getInt(columnIndex); 949 } 950 951 /** 952 * Gets the value of the designated column in the current row 953 * of this rowset's {@code ResultSet} object as 954 * a {@code long}. 955 * 956 * @param columnIndex the first column is 1, the second is 2, and so on 957 * @return the column value; if the value is SQL {@code NULL}, the 958 * value returned is {@code 0} 959 * @throws SQLException if (1) a database access error occurs 960 * or (2) this rowset does not have a currently valid connection, 961 * prepared statement, and result set 962 */ 963 public long getLong(int columnIndex) throws SQLException { 964 checkState(); 965 966 return rs.getLong(columnIndex); 967 } 968 969 /** 970 * Gets the value of the designated column in the current row 971 * of this rowset's {@code ResultSet} object as 972 * a {@code float}. 973 * 974 * @param columnIndex the first column is 1, the second is 2, and so on 975 * @return the column value; if the value is SQL {@code NULL}, the 976 * value returned is {@code 0} 977 * @throws SQLException if (1) a database access error occurs 978 * or (2) this rowset does not have a currently valid connection, 979 * prepared statement, and result set 980 */ 981 public float getFloat(int columnIndex) throws SQLException { 982 checkState(); 983 984 return rs.getFloat(columnIndex); 985 } 986 987 /** 988 * Gets the value of the designated column in the current row 989 * of this rowset's {@code ResultSet} object as 990 * a {@code double}. 991 * 992 * @param columnIndex the first column is 1, the second is 2, and so on 993 * @return the column value; if the value is SQL {@code NULL}, the 994 * value returned is {@code 0} 995 * @throws SQLException if (1) a database access error occurs 996 * or (2) this rowset does not have a currently valid connection, 997 * prepared statement, and result set 998 */ 999 public double getDouble(int columnIndex) throws SQLException { 1000 checkState(); 1001 1002 return rs.getDouble(columnIndex); 1003 } 1004 1005 /** 1006 * Gets the value of the designated column in the current row 1007 * of this rowset's {@code ResultSet} object as 1008 * a {@code java.sql.BigDecimal}. 1009 * 1010 * @param columnIndex the first column is 1, the second is 2, and so on 1011 * @param scale the number of digits to the right of the decimal point 1012 * @return the column value; if the value is SQL {@code NULL}, the 1013 * value returned is {@code null} 1014 * @throws SQLException if (1) database access error occurs 1015 * or (2) this rowset does not have a currently valid connection, 1016 * prepared statement, and result set 1017 * @deprecated 1018 */ 1019 @Deprecated 1020 public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException { 1021 checkState(); 1022 1023 return rs.getBigDecimal(columnIndex, scale); 1024 } 1025 1026 /** 1027 * Gets the value of the designated column in the current row 1028 * of this rowset's {@code ResultSet} object as 1029 * a {@code byte} array in the Java programming language. 1030 * The bytes represent the raw values returned by the driver. 1031 * 1032 * @param columnIndex the first column is 1, the second is 2, and so on 1033 * @return the column value; if the value is SQL {@code NULL}, the 1034 * value returned is {@code null} 1035 * @throws SQLException if (1) a database access error occurs 1036 * or (2) this rowset does not have a currently valid connection, 1037 * prepared statement, and result set 1038 */ 1039 public byte[] getBytes(int columnIndex) throws SQLException { 1040 checkState(); 1041 1042 return rs.getBytes(columnIndex); 1043 } 1044 1045 /** 1046 * Gets the value of the designated column in the current row 1047 * of this rowset's {@code ResultSet} object as 1048 * a {@code java.sql.Date} object in the Java programming language. 1049 * 1050 * @param columnIndex the first column is 1, the second is 2, and so on 1051 * @return the column value; if the value is SQL {@code NULL}, the 1052 * value returned is {@code null} 1053 * @throws SQLException if (1) a database access error occurs 1054 * or (2) this rowset does not have a currently valid connection, 1055 * prepared statement, and result set 1056 */ 1057 public java.sql.Date getDate(int columnIndex) throws SQLException { 1058 checkState(); 1059 1060 return rs.getDate(columnIndex); 1061 } 1062 1063 /** 1064 * Gets the value of the designated column in the current row 1065 * of this rowset's {@code ResultSet} object as 1066 * a {@code java.sql.Time} object in the Java programming language. 1067 * 1068 * @param columnIndex the first column is 1, the second is 2, and so on 1069 * @return the column value; if the value is SQL {@code NULL}, the 1070 * value returned is {@code null} 1071 * @throws SQLException if (1) a database access error occurs 1072 * or (2) this rowset does not have a currently valid connection, 1073 * prepared statement, and result set 1074 */ 1075 public java.sql.Time getTime(int columnIndex) throws SQLException { 1076 checkState(); 1077 1078 return rs.getTime(columnIndex); 1079 } 1080 1081 /** 1082 * Gets the value of the designated column in the current row 1083 * of this rowset's {@code ResultSet} object as 1084 * a {@code java.sql.Timestamp} object in the Java programming language. 1085 * 1086 * @param columnIndex the first column is 1, the second is 2, and so on 1087 * @return the column value; if the value is SQL {@code NULL}, the 1088 * value returned is {@code null} 1089 * @throws SQLException if (1) a database access error occurs 1090 * or (2) this rowset does not have a currently valid connection, 1091 * prepared statement, and result set 1092 */ 1093 public java.sql.Timestamp getTimestamp(int columnIndex) throws SQLException { 1094 checkState(); 1095 1096 return rs.getTimestamp(columnIndex); 1097 } 1098 1099 /** 1100 * Gets the value of the designated column in the current row 1101 * of this rowset's {@code ResultSet} object as 1102 * a stream of ASCII characters. The value can then be read in chunks from the 1103 * stream. This method is particularly 1104 * suitable for retrieving large {@code LONGVARCHAR} values. 1105 * The JDBC driver will 1106 * do any necessary conversion from the database format into ASCII. 1107 * 1108 * <P><B>Note:</B> All the data in the returned stream must be 1109 * read prior to getting the value of any other column. The next 1110 * call to a {@code getXXX} method implicitly closes the stream. Also, a 1111 * stream may return {@code 0} when the method 1112 * {@code InputStream.available} 1113 * is called whether there is data available or not. 1114 * 1115 * @param columnIndex the first column is 1, the second is 2, and so on 1116 * @return a Java input stream that delivers the database column value 1117 * as a stream of one-byte ASCII characters; 1118 * if the value is SQL {@code NULL}, the 1119 * value returned is {@code null} 1120 * @throws SQLException if (1) database access error occurs 1121 * (2) this rowset does not have a currently valid connection, 1122 * prepared statement, and result set 1123 */ 1124 public java.io.InputStream getAsciiStream(int columnIndex) throws SQLException { 1125 checkState(); 1126 1127 return rs.getAsciiStream(columnIndex); 1128 } 1129 1130 /** 1131 * Gets the value of the designated column in the current row 1132 * of this rowset's {@code ResultSet} object as 1133 * as a stream of Unicode characters. 1134 * The value can then be read in chunks from the 1135 * stream. This method is particularly 1136 * suitable for retrieving large{@code LONGVARCHAR}values. The JDBC driver will 1137 * do any necessary conversion from the database format into Unicode. 1138 * The byte format of the Unicode stream must be Java UTF-8, 1139 * as specified in the Java virtual machine specification. 1140 * 1141 * <P><B>Note:</B> All the data in the returned stream must be 1142 * read prior to getting the value of any other column. The next 1143 * call to a {@code getXXX} method implicitly closes the stream. Also, a 1144 * stream may return {@code 0} when the method 1145 * {@code InputStream.available} 1146 * is called whether there is data available or not. 1147 * 1148 * @param columnIndex the first column is 1, the second is 2, and so on 1149 * @return a Java input stream that delivers the database column value 1150 * as a stream in Java UTF-8 byte format; 1151 * if the value is SQL {@code NULL}, the value returned is {@code null} 1152 * @throws SQLException if (1) a database access error occurs 1153 * or (2) this rowset does not have a currently valid connection, 1154 * prepared statement, and result set 1155 * @deprecated use {@code getCharacterStream} in place of 1156 * {@code getUnicodeStream} 1157 */ 1158 @Deprecated 1159 public java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException { 1160 checkState(); 1161 1162 return rs.getUnicodeStream(columnIndex); 1163 } 1164 1165 /** 1166 * Gets the value of a column in the current row as a stream of 1167 * the value of the designated column in the current row 1168 * of this rowset's {@code ResultSet} object as a binary stream of 1169 * uninterpreted bytes. The value can then be read in chunks from the 1170 * stream. This method is particularly 1171 * suitable for retrieving large {@code LONGVARBINARY} values. 1172 * 1173 * <P><B>Note:</B> All the data in the returned stream must be 1174 * read prior to getting the value of any other column. The next 1175 * call to a {@code getXXX} method implicitly closes the stream. Also, a 1176 * stream may return {@code 0} when the method 1177 * {@code InputStream.available} 1178 * is called whether there is data available or not. 1179 * 1180 * @param columnIndex the first column is 1, the second is 2, and so on 1181 * @return a Java input stream that delivers the database column value 1182 * as a stream of uninterpreted bytes; 1183 * if the value is SQL {@code NULL}, the value returned is {@code null} 1184 * @throws SQLException if (1) a database access error occurs 1185 * or (2) this rowset does not have a currently valid connection, 1186 * prepared statement, and result set 1187 */ 1188 public java.io.InputStream getBinaryStream(int columnIndex) throws SQLException { 1189 checkState(); 1190 1191 return rs.getBinaryStream(columnIndex); 1192 } 1193 1194 1195 //====================================================================== 1196 // Methods for accessing results by column name 1197 //====================================================================== 1198 1199 /** 1200 * Gets the value of the designated column in the current row 1201 * of this rowset's {@code ResultSet} object as 1202 * a {@code String}. 1203 * 1204 * @param columnName the SQL name of the column 1205 * @return the column value; if the value is SQL {@code NULL}, the 1206 * value returned is {@code null} 1207 * @throws SQLException if (1) a database access error occurs 1208 * or (2) this rowset does not have a currently valid connection, 1209 * prepared statement, and result set 1210 */ 1211 public String getString(String columnName) throws SQLException { 1212 return getString(findColumn(columnName)); 1213 } 1214 1215 /** 1216 * Gets the value of the designated column in the current row 1217 * of this rowset's {@code ResultSet} object as 1218 * a {@code boolean}. 1219 * 1220 * @param columnName the SQL name of the column 1221 * @return the column value; if the value is SQL {@code NULL}, the 1222 * value returned is {@code false} 1223 * @throws SQLException if (1) a database access error occurs 1224 * or (2) this rowset does not have a currently valid connection, 1225 * prepared statement, and result set 1226 */ 1227 public boolean getBoolean(String columnName) throws SQLException { 1228 return getBoolean(findColumn(columnName)); 1229 } 1230 1231 /** 1232 * Gets the value of the designated column in the current row 1233 * of this rowset's {@code ResultSet} object as 1234 * a {@code byte}. 1235 * 1236 * @param columnName the SQL name of the column 1237 * @return the column value; if the value is SQL {@code NULL}, the 1238 * value returned is {@code 0} 1239 * @throws SQLException if (1) a database access error occurs 1240 * or (2) this rowset does not have a currently valid connection, 1241 * prepared statement, and result set 1242 */ 1243 public byte getByte(String columnName) throws SQLException { 1244 return getByte(findColumn(columnName)); 1245 } 1246 1247 /** 1248 * Gets the value of the designated column in the current row 1249 * of this rowset's {@code ResultSet} object as 1250 * a {@code short}. 1251 * 1252 * @param columnName the SQL name of the column 1253 * @return the column value; if the value is SQL {@code NULL}, the 1254 * value returned is {@code 0} 1255 * @throws SQLException if (1) a database access error occurs 1256 * or (2) this rowset does not have a currently valid connection, 1257 * prepared statement, and result set 1258 */ 1259 public short getShort(String columnName) throws SQLException { 1260 return getShort(findColumn(columnName)); 1261 } 1262 1263 /** 1264 * Gets the value of the designated column in the current row 1265 * of this rowset's {@code ResultSet} object as 1266 * an {@code int}. 1267 * 1268 * @param columnName the SQL name of the column 1269 * @return the column value; if the value is SQL {@code NULL}, the 1270 * value returned is {@code 0} 1271 * @throws SQLException if (1) a database access error occurs 1272 * or (2) this rowset does not have a currently valid connection, 1273 * prepared statement, and result set 1274 */ 1275 public int getInt(String columnName) throws SQLException { 1276 return getInt(findColumn(columnName)); 1277 } 1278 1279 /** 1280 * Gets the value of the designated column in the current row 1281 * of this rowset's {@code ResultSet} object as 1282 * a {@code long}. 1283 * 1284 * @param columnName the SQL name of the column 1285 * @return the column value; if the value is SQL {@code NULL}, the 1286 * value returned is {@code 0} 1287 * @throws SQLException if a database access error occurs 1288 * or this rowset does not have a currently valid connection, 1289 * prepared statement, and result set 1290 */ 1291 public long getLong(String columnName) throws SQLException { 1292 return getLong(findColumn(columnName)); 1293 } 1294 1295 /** 1296 * Gets the value of the designated column in the current row 1297 * of this rowset's {@code ResultSet} object as 1298 * a {@code float}. 1299 * 1300 * @param columnName the SQL name of the column 1301 * @return the column value; if the value is SQL {@code NULL}, the 1302 * value returned is {@code 0} 1303 * @throws SQLException if (1) a database access error occurs 1304 * or (2) this rowset does not have a currently valid connection, 1305 * prepared statement, and result set 1306 */ 1307 public float getFloat(String columnName) throws SQLException { 1308 return getFloat(findColumn(columnName)); 1309 } 1310 1311 /** 1312 * Gets the value of the designated column in the current row 1313 * of this rowset's {@code ResultSet} object as 1314 * a {@code double}. 1315 * 1316 * @param columnName the SQL name of the column 1317 * @return the column value; if the value is SQL {@code NULL}, the 1318 * value returned is {@code 0} 1319 * @throws SQLException if (1) a database access error occurs 1320 * or (2) this rowset does not have a currently valid connection, 1321 * prepared statement, and result set 1322 */ 1323 public double getDouble(String columnName) throws SQLException { 1324 return getDouble(findColumn(columnName)); 1325 } 1326 1327 /** 1328 * Gets the value of the designated column in the current row 1329 * of this rowset's {@code ResultSet} object as 1330 * a {@code java.math.BigDecimal}. 1331 * 1332 * @param columnName the SQL name of the column 1333 * @param scale the number of digits to the right of the decimal point 1334 * @return the column value; if the value is SQL {@code NULL}, the 1335 * value returned is {@code null} 1336 * @throws SQLException if (1) adatabase access error occurs 1337 * or (2) this rowset does not have a currently valid connection, 1338 * prepared statement, and result set 1339 * @deprecated 1340 */ 1341 @Deprecated 1342 public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException { 1343 return getBigDecimal(findColumn(columnName), scale); 1344 } 1345 1346 /** 1347 * Gets the value of the designated column in the current row 1348 * of this rowset's {@code ResultSet} object as 1349 * a {@code byte} array in the Java programming language. 1350 * The bytes represent the raw values returned by the driver. 1351 * 1352 * @param columnName the SQL name of the column 1353 * @return the column value; if the value is SQL {@code NULL}, the 1354 * value returned is {@code null} 1355 * @throws SQLException if (1) a database access error occurs 1356 * or (2) this rowset does not have a currently valid connection, 1357 * prepared statement, and result set 1358 */ 1359 public byte[] getBytes(String columnName) throws SQLException { 1360 return getBytes(findColumn(columnName)); 1361 } 1362 1363 /** 1364 * Gets the value of the designated column in the current row 1365 * of this rowset's {@code ResultSet} object as 1366 * a {@code java.sql.Date} object in the Java programming language. 1367 * 1368 * @param columnName the SQL name of the column 1369 * @return the column value; if the value is SQL {@code NULL}, the 1370 * value returned is {@code null} 1371 * @throws SQLException if (1) a database access error occurs 1372 * or (2) this rowset does not have a currently valid connection, 1373 * prepared statement, and result set 1374 */ 1375 public java.sql.Date getDate(String columnName) throws SQLException { 1376 return getDate(findColumn(columnName)); 1377 } 1378 1379 /** 1380 * Gets the value of the designated column in the current row 1381 * of this rowset's {@code ResultSet} object as 1382 * a {@code java.sql.Time} object in the Java programming language. 1383 * 1384 * @param columnName the SQL name of the column 1385 * @return the column value; 1386 * if the value is SQL {@code NULL}, 1387 * the value returned is {@code null} 1388 * @throws SQLException if (1) a database access error occurs 1389 * or (2) this rowset does not have a currently valid connection, 1390 * prepared statement, and result set 1391 */ 1392 public java.sql.Time getTime(String columnName) throws SQLException { 1393 return getTime(findColumn(columnName)); 1394 } 1395 1396 /** 1397 * Gets the value of the designated column in the current row 1398 * of this rowset's {@code ResultSet} object as 1399 * a {@code java.sql.Timestamp} object. 1400 * 1401 * @param columnName the SQL name of the column 1402 * @return the column value; if the value is SQL {@code NULL}, the 1403 * value returned is {@code null} 1404 * @throws SQLException if (1) a database access error occurs 1405 * or (2) this rowset does not have a currently valid connection, 1406 * prepared statement, and result set 1407 */ 1408 public java.sql.Timestamp getTimestamp(String columnName) throws SQLException { 1409 return getTimestamp(findColumn(columnName)); 1410 } 1411 1412 /** 1413 * Gets the value of the designated column in the current row 1414 * of this rowset's {@code ResultSet} object as a stream of 1415 * ASCII characters. The value can then be read in chunks from the 1416 * stream. This method is particularly 1417 * suitable for retrieving large {@code LONGVARCHAR} values. 1418 * The JDBC driver will 1419 * do any necessary conversion from the database format into ASCII. 1420 * 1421 * <P><B>Note:</B> All the data in the returned stream must be 1422 * read prior to getting the value of any other column. The next 1423 * call to a {@code getXXX} method implicitly closes the stream. Also, a 1424 * stream may return {@code 0} when the method {@code available} 1425 * is called whether there is data available or not. 1426 * 1427 * @param columnName the SQL name of the column 1428 * @return a Java input stream that delivers the database column value 1429 * as a stream of one-byte ASCII characters. 1430 * If the value is SQL {@code NULL}, 1431 * the value returned is {@code null}. 1432 * @throws SQLException if (1) a database access error occurs 1433 * or (2) this rowset does not have a currently valid connection, 1434 * prepared statement, and result set 1435 */ 1436 public java.io.InputStream getAsciiStream(String columnName) throws SQLException { 1437 return getAsciiStream(findColumn(columnName)); 1438 } 1439 1440 /** 1441 * Gets the value of the designated column in the current row 1442 * of this rowset's {@code ResultSet} object as a stream of 1443 * Unicode characters. The value can then be read in chunks from the 1444 * stream. This method is particularly 1445 * suitable for retrieving large {@code LONGVARCHAR} values. 1446 * The JDBC driver will 1447 * do any necessary conversion from the database format into Unicode. 1448 * The byte format of the Unicode stream must be Java UTF-8, 1449 * as defined in the Java virtual machine specification. 1450 * 1451 * <P><B>Note:</B> All the data in the returned stream must be 1452 * read prior to getting the value of any other column. The next 1453 * call to a {@code getXXX} method implicitly closes the stream. Also, a 1454 * stream may return {@code 0} when the method {@code available} 1455 * is called whether there is data available or not. 1456 * 1457 * @param columnName the SQL name of the column 1458 * @return a Java input stream that delivers the database column value 1459 * as a stream of two-byte Unicode characters. 1460 * If the value is SQL {@code NULL}, 1461 * the value returned is {@code null}. 1462 * @throws SQLException if (1) a database access error occurs 1463 * or (2) this rowset does not have a currently valid connection, 1464 * prepared statement, and result set 1465 * @deprecated 1466 */ 1467 @Deprecated 1468 public java.io.InputStream getUnicodeStream(String columnName) throws SQLException { 1469 return getUnicodeStream(findColumn(columnName)); 1470 } 1471 1472 /** 1473 * Gets the value of the designated column in the current row 1474 * of this rowset's {@code ResultSet} object as a stream of uninterpreted 1475 * {@code byte}s. 1476 * The value can then be read in chunks from the 1477 * stream. This method is particularly 1478 * suitable for retrieving large {@code LONGVARBINARY} 1479 * values. 1480 * 1481 * <P><B>Note:</B> All the data in the returned stream must be 1482 * read prior to getting the value of any other column. The next 1483 * call to a {@code getXXX} method implicitly closes the stream. Also, a 1484 * stream may return {@code 0} when the method {@code available} 1485 * is called whether there is data available or not. 1486 * 1487 * @param columnName the SQL name of the column 1488 * @return a Java input stream that delivers the database column value 1489 * as a stream of uninterpreted bytes; 1490 * if the value is SQL {@code NULL}, the result is {@code null} 1491 * @throws SQLException if (1) a database access error occurs 1492 * or (2) this rowset does not have a currently valid connection, 1493 * prepared statement, and result set 1494 */ 1495 public java.io.InputStream getBinaryStream(String columnName) throws SQLException { 1496 return getBinaryStream(findColumn(columnName)); 1497 } 1498 1499 1500 //===================================================================== 1501 // Advanced features: 1502 //===================================================================== 1503 1504 /** 1505 * Returns the first warning reported by calls on this rowset's 1506 * {@code ResultSet} object. 1507 * Subsequent warnings on this rowset's {@code ResultSet} object 1508 * will be chained to the {@code SQLWarning} object that 1509 * this method returns. 1510 * 1511 * <P>The warning chain is automatically cleared each time a new 1512 * row is read. 1513 * 1514 * <P><B>Note:</B> This warning chain only covers warnings caused 1515 * by {@code ResultSet} methods. Any warning caused by 1516 * {@code Statement} methods 1517 * (such as reading OUT parameters) will be chained on the 1518 * {@code Statement} object. 1519 * 1520 * @return the first {@code SQLWarning} object reported or {@code null} 1521 * @throws SQLException if (1) a database access error occurs 1522 * or (2) this rowset does not have a currently valid connection, 1523 * prepared statement, and result set 1524 */ 1525 public SQLWarning getWarnings() throws SQLException { 1526 checkState(); 1527 1528 return rs.getWarnings(); 1529 } 1530 1531 /** 1532 * Clears all warnings reported on this rowset's {@code ResultSet} object. 1533 * After this method is called, the method {@code getWarnings} 1534 * returns {@code null} until a new warning is 1535 * reported for this rowset's {@code ResultSet} object. 1536 * 1537 * @throws SQLException if (1) a database access error occurs 1538 * or (2) this rowset does not have a currently valid connection, 1539 * prepared statement, and result set 1540 */ 1541 public void clearWarnings() throws SQLException { 1542 checkState(); 1543 1544 rs.clearWarnings(); 1545 } 1546 1547 /** 1548 * Gets the name of the SQL cursor used by this rowset's {@code ResultSet} 1549 * object. 1550 * 1551 * <P>In SQL, a result table is retrieved through a cursor that is 1552 * named. The current row of a result set can be updated or deleted 1553 * using a positioned update/delete statement that references the 1554 * cursor name. To insure that the cursor has the proper isolation 1555 * level to support update, the cursor's {@code select} statement should be 1556 * of the form 'select for update'. If the 'for update' clause is 1557 * omitted, the positioned updates may fail. 1558 * 1559 * <P>The JDBC API supports this SQL feature by providing the name of the 1560 * SQL cursor used by a {@code ResultSet} object. 1561 * The current row of a {@code ResultSet} object 1562 * is also the current row of this SQL cursor. 1563 * 1564 * <P><B>Note:</B> If positioned update is not supported, a 1565 * {@code SQLException} is thrown. 1566 * 1567 * @return the SQL name for this rowset's {@code ResultSet} object's cursor 1568 * @throws SQLException if (1) a database access error occurs 1569 * or (2) xthis rowset does not have a currently valid connection, 1570 * prepared statement, and result set 1571 */ 1572 public String getCursorName() throws SQLException { 1573 checkState(); 1574 1575 return rs.getCursorName(); 1576 } 1577 1578 /** 1579 * Retrieves the number, types and properties of 1580 * this rowset's {@code ResultSet} object's columns. 1581 * 1582 * @return the description of this rowset's {@code ResultSet} 1583 * object's columns 1584 * @throws SQLException if (1) a database access error occurs 1585 * or (2) this rowset does not have a currently valid connection, 1586 * prepared statement, and result set 1587 */ 1588 public ResultSetMetaData getMetaData() throws SQLException { 1589 1590 checkState(); 1591 1592 // It may be the case that JdbcRowSet might not have been 1593 // initialized with ResultSet handle and may be by PreparedStatement 1594 // internally when we set JdbcRowSet.setCommand(). 1595 // We may require all the basic properties of setEscapeProcessing 1596 // setMaxFieldSize etc. which an application can use before we call 1597 // execute. 1598 try { 1599 checkState(); 1600 } catch(SQLException sqle) { 1601 prepare(); 1602 // will return ResultSetMetaData 1603 return ps.getMetaData(); 1604 } 1605 return rs.getMetaData(); 1606 } 1607 1608 /** 1609 * <p>Gets the value of the designated column in the current row 1610 * of this rowset's {@code ResultSet} object as 1611 * an {@code Object}. 1612 * 1613 * <p>This method will return the value of the given column as a 1614 * Java object. The type of the Java object will be the default 1615 * Java object type corresponding to the column's SQL type, 1616 * following the mapping for built-in types specified in the JDBC 1617 * specification. 1618 * 1619 * <p>This method may also be used to read datatabase-specific 1620 * abstract data types. 1621 * 1622 * In the JDBC 3.0 API, the behavior of method 1623 * {@code getObject} is extended to materialize 1624 * data of SQL user-defined types. When a column contains 1625 * a structured or distinct value, the behavior of this method is as 1626 * if it were a call to: {@code getObject(columnIndex, 1627 * this.getStatement().getConnection().getTypeMap())}. 1628 * 1629 * @param columnIndex the first column is 1, the second is 2, and so on 1630 * @return a {@code java.lang.Object} holding the column value 1631 * @throws SQLException if (1) a database access error occurs 1632 * or (2) this rowset does not currently have a valid connection, 1633 * prepared statement, and result set 1634 */ 1635 public Object getObject(int columnIndex) throws SQLException { 1636 checkState(); 1637 1638 return rs.getObject(columnIndex); 1639 } 1640 1641 /** 1642 * <p>Gets the value of the designated column in the current row 1643 * of this rowset's {@code ResultSet} object as 1644 * an {@code Object}. 1645 * 1646 * <p>This method will return the value of the given column as a 1647 * Java object. The type of the Java object will be the default 1648 * Java object type corresponding to the column's SQL type, 1649 * following the mapping for built-in types specified in the JDBC 1650 * specification. 1651 * 1652 * <p>This method may also be used to read datatabase-specific 1653 * abstract data types. 1654 * 1655 * In the JDBC 3.0 API, the behavior of the method 1656 * {@code getObject} is extended to materialize 1657 * data of SQL user-defined types. When a column contains 1658 * a structured or distinct value, the behavior of this method is as 1659 * if it were a call to: {@code getObject(columnIndex, 1660 * this.getStatement().getConnection().getTypeMap())}. 1661 * 1662 * @param columnName the SQL name of the column 1663 * @return a {@code java.lang.Object} holding the column value 1664 * @throws SQLException if (1) a database access error occurs 1665 * or (2) this rowset does not currently have a valid connection, 1666 * prepared statement, and result set 1667 */ 1668 public Object getObject(String columnName) throws SQLException { 1669 return getObject(findColumn(columnName)); 1670 } 1671 1672 //---------------------------------------------------------------- 1673 1674 /** 1675 * Maps the given {@code JdbcRowSetImpl} column name to its 1676 * {@code JdbcRowSetImpl} column index and reflects this on 1677 * the internal {@code ResultSet} object. 1678 * 1679 * @param columnName the name of the column 1680 * @return the column index of the given column name 1681 * @throws SQLException if (1) a database access error occurs 1682 * (2) this rowset does not have a currently valid connection, 1683 * prepared statement, and result set 1684 */ 1685 public int findColumn(String columnName) throws SQLException { 1686 checkState(); 1687 1688 return rs.findColumn(columnName); 1689 } 1690 1691 1692 //--------------------------JDBC 2.0----------------------------------- 1693 1694 //--------------------------------------------------------------------- 1695 // Getters and Setters 1696 //--------------------------------------------------------------------- 1697 1698 /** 1699 * Gets the value of the designated column in the current row 1700 * of this rowset's {@code ResultSet} object as a 1701 * {@code java.io.Reader} object. 1702 * @return a {@code java.io.Reader} object that contains the column 1703 * value; if the value is SQL {@code NULL}, the value returned is 1704 * {@code null}. 1705 * @param columnIndex the first column is 1, the second is 2, and so on 1706 * 1707 */ 1708 public java.io.Reader getCharacterStream(int columnIndex) throws SQLException { 1709 checkState(); 1710 1711 return rs.getCharacterStream(columnIndex); 1712 } 1713 1714 /** 1715 * Gets the value of the designated column in the current row 1716 * of this rowset's {@code ResultSet} object as a 1717 * {@code java.io.Reader} object. 1718 * 1719 * @return a {@code java.io.Reader} object that contains the column 1720 * value; if the value is SQL {@code NULL}, the value returned is 1721 * {@code null}. 1722 * @param columnName the name of the column 1723 * @return the value in the specified column as a {@code java.io.Reader} 1724 * 1725 */ 1726 public java.io.Reader getCharacterStream(String columnName) throws SQLException { 1727 return getCharacterStream(findColumn(columnName)); 1728 } 1729 1730 /** 1731 * Gets the value of the designated column in the current row 1732 * of this rowset's {@code ResultSet} object as a 1733 * {@code java.math.BigDecimal} with full precision. 1734 * 1735 * @param columnIndex the first column is 1, the second is 2, and so on 1736 * @return the column value (full precision); 1737 * if the value is SQL {@code NULL}, the value returned is 1738 * {@code null}. 1739 * @throws SQLException if a database access error occurs 1740 * or this rowset does not currently have a valid 1741 * connection, prepared statement, and result set 1742 */ 1743 public BigDecimal getBigDecimal(int columnIndex) throws SQLException { 1744 checkState(); 1745 1746 return rs.getBigDecimal(columnIndex); 1747 } 1748 1749 /** 1750 * Gets the value of the designated column in the current row 1751 * of this rowset's {@code ResultSet} object as a 1752 * {@code java.math.BigDecimal} with full precision. 1753 * 1754 * @param columnName the column name 1755 * @return the column value (full precision); 1756 * if the value is SQL {@code NULL}, the value returned is 1757 * {@code null}. 1758 * @throws SQLException if a database access error occurs 1759 * or this rowset does not currently have a valid 1760 * connection, prepared statement, and result set 1761 */ 1762 public BigDecimal getBigDecimal(String columnName) throws SQLException { 1763 return getBigDecimal(findColumn(columnName)); 1764 } 1765 1766 //--------------------------------------------------------------------- 1767 // Traversal/Positioning 1768 //--------------------------------------------------------------------- 1769 1770 /** 1771 * Indicates whether the cursor is before the first row in 1772 * this rowset's {@code ResultSet} object. 1773 * 1774 * @return {@code true} if the cursor is before the first row; 1775 * {@code false} if the cursor is at any other position or the 1776 * result set contains no rows 1777 * @throws SQLException if a database access error occurs 1778 * or this rowset does not currently have a valid 1779 * connection, prepared statement, and result set 1780 */ 1781 public boolean isBeforeFirst() throws SQLException { 1782 checkState(); 1783 1784 return rs.isBeforeFirst(); 1785 } 1786 1787 /** 1788 * Indicates whether the cursor is after the last row in 1789 * this rowset's {@code ResultSet} object. 1790 * 1791 * @return {@code true} if the cursor is after the last row; 1792 * {@code false} if the cursor is at any other position or the 1793 * result set contains no rows 1794 * @throws SQLException if a database access error occurs 1795 * or this rowset does not currently have a valid 1796 * connection, prepared statement, and result set 1797 */ 1798 public boolean isAfterLast() throws SQLException { 1799 checkState(); 1800 1801 return rs.isAfterLast(); 1802 } 1803 1804 /** 1805 * Indicates whether the cursor is on the first row of 1806 * this rowset's {@code ResultSet} object. 1807 * 1808 * @return {@code true} if the cursor is on the first row; 1809 * {@code false} otherwise 1810 * @throws SQLException if a database access error occurs 1811 * or this rowset does not currently have a valid 1812 * connection, prepared statement, and result set 1813 */ 1814 public boolean isFirst() throws SQLException { 1815 checkState(); 1816 1817 return rs.isFirst(); 1818 } 1819 1820 /** 1821 * Indicates whether the cursor is on the last row of 1822 * this rowset's {@code ResultSet} object. 1823 * Note: Calling the method {@code isLast} may be expensive 1824 * because the JDBC driver 1825 * might need to fetch ahead one row in order to determine 1826 * whether the current row is the last row in the result set. 1827 * 1828 * @return {@code true} if the cursor is on the last row; 1829 * {@code false} otherwise 1830 * @throws SQLException if a database access error occurs 1831 * or this rowset does not currently have a valid 1832 * connection, prepared statement, and result set 1833 * 1834 */ 1835 public boolean isLast() throws SQLException { 1836 checkState(); 1837 1838 return rs.isLast(); 1839 } 1840 1841 /** 1842 * Moves the cursor to the front of 1843 * this rowset's {@code ResultSet} object, just before the 1844 * first row. This method has no effect if the result set contains no rows. 1845 * 1846 * @throws SQLException if (1) a database access error occurs, 1847 * (2) the result set type is {@code TYPE_FORWARD_ONLY}, 1848 * or (3) this rowset does not currently have a valid 1849 * connection, prepared statement, and result set 1850 */ 1851 public void beforeFirst() throws SQLException { 1852 checkState(); 1853 1854 rs.beforeFirst(); 1855 notifyCursorMoved(); 1856 } 1857 1858 /** 1859 * Moves the cursor to the end of 1860 * this rowset's {@code ResultSet} object, just after the 1861 * last row. This method has no effect if the result set contains no rows. 1862 * @throws SQLException if (1) a database access error occurs, 1863 * (2) the result set type is {@code TYPE_FORWARD_ONLY}, 1864 * or (3) this rowset does not currently have a valid 1865 * connection, prepared statement, and result set 1866 */ 1867 public void afterLast() throws SQLException { 1868 checkState(); 1869 1870 rs.afterLast(); 1871 notifyCursorMoved(); 1872 } 1873 1874 /** 1875 * Moves the cursor to the first row in 1876 * this rowset's {@code ResultSet} object. 1877 * 1878 * @return {@code true} if the cursor is on a valid row; 1879 * {@code false} if there are no rows in the result set 1880 * @throws SQLException if (1) a database access error occurs, 1881 * (2) the result set type is {@code TYPE_FORWARD_ONLY}, 1882 * or (3) this rowset does not currently have a valid 1883 * connection, prepared statement, and result set 1884 */ 1885 public boolean first() throws SQLException { 1886 checkState(); 1887 1888 boolean b = rs.first(); 1889 notifyCursorMoved(); 1890 return b; 1891 1892 } 1893 1894 /** 1895 * Moves the cursor to the last row in 1896 * this rowset's {@code ResultSet} object. 1897 * 1898 * @return {@code true} if the cursor is on a valid row; 1899 * {@code false} if there are no rows in the result set 1900 * @throws SQLException if (1) a database access error occurs, 1901 * (2) the result set type is {@code TYPE_FORWARD_ONLY}, 1902 * or (3) this rowset does not currently have a valid 1903 * connection, prepared statement, and result set 1904 */ 1905 public boolean last() throws SQLException { 1906 checkState(); 1907 1908 boolean b = rs.last(); 1909 notifyCursorMoved(); 1910 return b; 1911 } 1912 1913 /** 1914 * Retrieves the current row number. The first row is number 1, the 1915 * second is number 2, and so on. 1916 * 1917 * @return the current row number; {@code 0} if there is no current row 1918 * @throws SQLException if a database access error occurs 1919 * or this rowset does not currently have a valid connection, 1920 * prepared statement, and result set 1921 */ 1922 public int getRow() throws SQLException { 1923 checkState(); 1924 1925 return rs.getRow(); 1926 } 1927 1928 /** 1929 * Moves the cursor to the given row number in 1930 * this rowset's internal {@code ResultSet} object. 1931 * 1932 * <p>If the row number is positive, the cursor moves to 1933 * the given row number with respect to the 1934 * beginning of the result set. The first row is row 1, the second 1935 * is row 2, and so on. 1936 * 1937 * <p>If the given row number is negative, the cursor moves to 1938 * an absolute row position with respect to 1939 * the end of the result set. For example, calling the method 1940 * {@code absolute(-1)} positions the 1941 * cursor on the last row, calling the method {@code absolute(-2)} 1942 * moves the cursor to the next-to-last row, and so on. 1943 * 1944 * <p>An attempt to position the cursor beyond the first/last row in 1945 * the result set leaves the cursor before the first row or after 1946 * the last row. 1947 * 1948 * <p><B>Note:</B> Calling {@code absolute(1)} is the same 1949 * as calling {@code first()}. Calling {@code absolute(-1)} 1950 * is the same as calling {@code last()}. 1951 * 1952 * @return {@code true} if the cursor is on the result set; 1953 * {@code false} otherwise 1954 * @throws SQLException if (1) a database access error occurs, 1955 * (2) the row is {@code 0}, (3) the result set 1956 * type is {@code TYPE_FORWARD_ONLY}, or (4) this 1957 * rowset does not currently have a valid connection, 1958 * prepared statement, and result set 1959 */ 1960 public boolean absolute(int row) throws SQLException { 1961 checkState(); 1962 1963 boolean b = rs.absolute(row); 1964 notifyCursorMoved(); 1965 return b; 1966 } 1967 1968 /** 1969 * Moves the cursor a relative number of rows, either positive or negative. 1970 * Attempting to move beyond the first/last row in the 1971 * result set positions the cursor before/after the 1972 * the first/last row. Calling {@code relative(0)} is valid, but does 1973 * not change the cursor position. 1974 * 1975 * <p>Note: Calling the method {@code relative(1)} 1976 * is different from calling the method {@code next()} 1977 * because is makes sense to call {@code next()} when there 1978 * is no current row, 1979 * for example, when the cursor is positioned before the first row 1980 * or after the last row of the result set. 1981 * 1982 * @return {@code true} if the cursor is on a row; 1983 * {@code false} otherwise 1984 * @throws SQLException if (1) a database access error occurs, 1985 * (2) there is no current row, (3) the result set 1986 * type is {@code TYPE_FORWARD_ONLY}, or (4) this 1987 * rowset does not currently have a valid connection, 1988 * prepared statement, and result set 1989 */ 1990 public boolean relative(int rows) throws SQLException { 1991 checkState(); 1992 1993 boolean b = rs.relative(rows); 1994 notifyCursorMoved(); 1995 return b; 1996 } 1997 1998 /** 1999 * Moves the cursor to the previous row in this 2000 * {@code ResultSet} object. 2001 * 2002 * <p><B>Note:</B> Calling the method {@code previous()} is not the same as 2003 * calling the method {@code relative(-1)} because it 2004 * makes sense to call {@code previous()} when there is no current row. 2005 * 2006 * @return {@code true} if the cursor is on a valid row; 2007 * {@code false} if it is off the result set 2008 * @throws SQLException if (1) a database access error occurs, 2009 * (2) the result set type is {@code TYPE_FORWARD_ONLY}, 2010 * or (3) this rowset does not currently have a valid 2011 * connection, prepared statement, and result set 2012 */ 2013 public boolean previous() throws SQLException { 2014 checkState(); 2015 2016 boolean b = rs.previous(); 2017 notifyCursorMoved(); 2018 return b; 2019 } 2020 2021 /** 2022 * Gives a hint as to the direction in which the rows in this 2023 * {@code ResultSet} object will be processed. 2024 * The initial value is determined by the 2025 * {@code Statement} object 2026 * that produced this rowset's {@code ResultSet} object. 2027 * The fetch direction may be changed at any time. 2028 * 2029 * @throws SQLException if (1) a database access error occurs, 2030 * (2) the result set type is {@code TYPE_FORWARD_ONLY} 2031 * and the fetch direction is not {@code FETCH_FORWARD}, 2032 * or (3) this rowset does not currently have a valid 2033 * connection, prepared statement, and result set 2034 * @see java.sql.Statement#setFetchDirection 2035 */ 2036 public void setFetchDirection(int direction) throws SQLException { 2037 checkState(); 2038 2039 rs.setFetchDirection(direction); 2040 } 2041 2042 /** 2043 * Returns the fetch direction for this 2044 * {@code ResultSet} object. 2045 * 2046 * @return the current fetch direction for this rowset's 2047 * {@code ResultSet} object 2048 * @throws SQLException if a database access error occurs 2049 * or this rowset does not currently have a valid connection, 2050 * prepared statement, and result set 2051 */ 2052 public int getFetchDirection() throws SQLException { 2053 try { 2054 checkState(); 2055 } catch(SQLException sqle) { 2056 super.getFetchDirection(); 2057 } 2058 return rs.getFetchDirection(); 2059 } 2060 2061 /** 2062 * Gives the JDBC driver a hint as to the number of rows that should 2063 * be fetched from the database when more rows are needed for this 2064 * {@code ResultSet} object. 2065 * If the fetch size specified is zero, the JDBC driver 2066 * ignores the value and is free to make its own best guess as to what 2067 * the fetch size should be. The default value is set by the 2068 * {@code Statement} object 2069 * that created the result set. The fetch size may be changed at any time. 2070 * 2071 * @param rows the number of rows to fetch 2072 * @throws SQLException if (1) a database access error occurs, (2) the 2073 * condition {@code 0 <= rows <= this.getMaxRows()} is not 2074 * satisfied, or (3) this rowset does not currently have a valid 2075 * connection, prepared statement, and result set 2076 * 2077 */ 2078 public void setFetchSize(int rows) throws SQLException { 2079 checkState(); 2080 2081 rs.setFetchSize(rows); 2082 } 2083 2084 /** 2085 * 2086 * Returns the fetch size for this 2087 * {@code ResultSet} object. 2088 * 2089 * @return the current fetch size for this rowset's {@code ResultSet} object 2090 * @throws SQLException if a database access error occurs 2091 * or this rowset does not currently have a valid connection, 2092 * prepared statement, and result set 2093 */ 2094 public int getType() throws SQLException { 2095 try { 2096 checkState(); 2097 } catch(SQLException sqle) { 2098 return super.getType(); 2099 } 2100 2101 // If the ResultSet has not been created, then return the default type 2102 // otherwise return the type from the ResultSet. 2103 if(rs == null) { 2104 return super.getType(); 2105 } else { 2106 int rstype = rs.getType(); 2107 return rstype; 2108 } 2109 2110 2111 } 2112 2113 /** 2114 * Returns the concurrency mode of this rowset's {@code ResultSet} object. 2115 * The concurrency used is determined by the 2116 * {@code Statement} object that created the result set. 2117 * 2118 * @return the concurrency type, either {@code CONCUR_READ_ONLY} 2119 * or {@code CONCUR_UPDATABLE} 2120 * @throws SQLException if (1) a database access error occurs 2121 * or (2) this rowset does not currently have a valid connection, 2122 * prepared statement, and result set 2123 */ 2124 public int getConcurrency() throws SQLException { 2125 try { 2126 checkState(); 2127 } catch(SQLException sqle) { 2128 super.getConcurrency(); 2129 } 2130 return rs.getConcurrency(); 2131 } 2132 2133 //--------------------------------------------------------------------- 2134 // Updates 2135 //--------------------------------------------------------------------- 2136 2137 /** 2138 * Indicates whether the current row has been updated. The value returned 2139 * depends on whether or not the result set can detect updates. 2140 * 2141 * @return {@code true} if the row has been visibly updated 2142 * by the owner or another, and updates are detected 2143 * @throws SQLException if a database access error occurs 2144 * or this rowset does not currently have a valid connection, 2145 * prepared statement, and result set 2146 * @see java.sql.DatabaseMetaData#updatesAreDetected 2147 */ 2148 public boolean rowUpdated() throws SQLException { 2149 checkState(); 2150 2151 return rs.rowUpdated(); 2152 } 2153 2154 /** 2155 * Indicates whether the current row has had an insertion. 2156 * The value returned depends on whether or not this 2157 * {@code ResultSet} object can detect visible inserts. 2158 * 2159 * @return {@code true} if a row has had an insertion 2160 * and insertions are detected; {@code false} otherwise 2161 * @throws SQLException if a database access error occurs 2162 * or this rowset does not currently have a valid connection, 2163 * prepared statement, and result set 2164 * @see java.sql.DatabaseMetaData#insertsAreDetected 2165 * 2166 */ 2167 public boolean rowInserted() throws SQLException { 2168 checkState(); 2169 2170 return rs.rowInserted(); 2171 } 2172 2173 /** 2174 * Indicates whether a row has been deleted. A deleted row may leave 2175 * a visible "hole" in a result set. This method can be used to 2176 * detect holes in a result set. The value returned depends on whether 2177 * or not this rowset's {@code ResultSet} object can detect deletions. 2178 * 2179 * @return {@code true} if a row was deleted and deletions are detected; 2180 * {@code false} otherwise 2181 * @throws SQLException if a database access error occurs 2182 * or this rowset does not currently have a valid connection, 2183 * prepared statement, and result set 2184 * @see java.sql.DatabaseMetaData#deletesAreDetected 2185 */ 2186 public boolean rowDeleted() throws SQLException { 2187 checkState(); 2188 2189 return rs.rowDeleted(); 2190 } 2191 2192 /** 2193 * Gives a nullable column a null value. 2194 * 2195 * The {@code updateXXX} methods are used to update column values in the 2196 * current row or the insert row. The {@code updateXXX} methods do not 2197 * update the underlying database; instead the {@code updateRow} 2198 * or {@code insertRow} methods are called to update the database. 2199 * 2200 * @param columnIndex the first column is 1, the second is 2, and so on 2201 * @throws SQLException if a database access error occurs 2202 * or this rowset does not currently have a valid connection, 2203 * prepared statement, and result set 2204 */ 2205 public void updateNull(int columnIndex) throws SQLException { 2206 checkState(); 2207 2208 // To check the type and concurrency of the ResultSet 2209 // to verify whether updates are possible or not 2210 checkTypeConcurrency(); 2211 2212 rs.updateNull(columnIndex); 2213 } 2214 2215 /** 2216 * Updates the designated column with a {@code boolean} value. 2217 * The {@code updateXXX} methods are used to update column values in the 2218 * current row or the insert row. The {@code updateXXX} methods do not 2219 * update the underlying database; instead the {@code updateRow} or 2220 * {@code insertRow} methods are called to update the database. 2221 * 2222 * @param columnIndex the first column is 1, the second is 2, and so on 2223 * @param x the new column value 2224 * @throws SQLException if a database access error occurs 2225 * or this rowset does not currently have a valid connection, 2226 * prepared statement, and result set 2227 * 2228 */ 2229 public void updateBoolean(int columnIndex, boolean x) throws SQLException { 2230 checkState(); 2231 2232 // To check the type and concurrency of the ResultSet 2233 // to verify whether updates are possible or not 2234 checkTypeConcurrency(); 2235 2236 rs.updateBoolean(columnIndex, x); 2237 } 2238 2239 /** 2240 * Updates the designated column with a {@code byte} value. 2241 * The {@code updateXXX} methods are used to update column values in the 2242 * current row or the insert row. The {@code updateXXX} methods do not 2243 * update the underlying database; instead the {@code updateRow} or 2244 * {@code insertRow} methods are called to update the database. 2245 * 2246 * 2247 * @param columnIndex the first column is 1, the second is 2, and so on 2248 * @param x the new column value 2249 * @throws SQLException if a database access error occurs 2250 * or this rowset does not currently have a valid connection, 2251 * prepared statement, and result set 2252 * 2253 */ 2254 public void updateByte(int columnIndex, byte x) throws SQLException { 2255 checkState(); 2256 2257 // To check the type and concurrency of the ResultSet 2258 // to verify whether updates are possible or not 2259 checkTypeConcurrency(); 2260 2261 rs.updateByte(columnIndex, x); 2262 } 2263 2264 /** 2265 * Updates the designated column with a {@code short} value. 2266 * The {@code updateXXX} methods are used to update column values in the 2267 * current row or the insert row. The {@code updateXXX} methods do not 2268 * update the underlying database; instead the {@code updateRow} or 2269 * {@code insertRow} methods are called to update the database. 2270 * 2271 * @param columnIndex the first column is 1, the second is 2, and so on 2272 * @param x the new column value 2273 * @throws SQLException if a database access error occurs 2274 * or this rowset does not currently have a valid connection, 2275 * prepared statement, and result set 2276 * 2277 */ 2278 public void updateShort(int columnIndex, short x) throws SQLException { 2279 checkState(); 2280 2281 // To check the type and concurrency of the ResultSet 2282 // to verify whether updates are possible or not 2283 checkTypeConcurrency(); 2284 2285 rs.updateShort(columnIndex, x); 2286 } 2287 2288 /** 2289 * Updates the designated column with an {@code int} value. 2290 * The {@code updateXXX} methods are used to update column values in the 2291 * current row or the insert row. The {@code updateXXX} methods do not 2292 * update the underlying database; instead the {@code updateRow} or 2293 * {@code insertRow} methods are called to update the database. 2294 * 2295 * @param columnIndex the first column is 1, the second is 2, and so on 2296 * @param x the new column value 2297 * @throws SQLException if a database access error occurs 2298 * or this rowset does not currently have a valid connection, 2299 * prepared statement, and result set 2300 */ 2301 public void updateInt(int columnIndex, int x) throws SQLException { 2302 checkState(); 2303 2304 // To check the type and concurrency of the ResultSet 2305 // to verify whether updates are possible or not 2306 checkTypeConcurrency(); 2307 2308 rs.updateInt(columnIndex, x); 2309 } 2310 2311 /** 2312 * Updates the designated column with a {@code long} value. 2313 * The {@code updateXXX} methods are used to update column values in the 2314 * current row or the insert row. The {@code updateXXX} methods do not 2315 * update the underlying database; instead the {@code updateRow} or 2316 * {@code insertRow} methods are called to update the database. 2317 * 2318 * @param columnIndex the first column is 1, the second is 2, and so on 2319 * @param x the new column value 2320 * @throws SQLException if a database access error occurs 2321 * or this rowset does not currently have a valid connection, 2322 * prepared statement, and result set 2323 * 2324 */ 2325 public void updateLong(int columnIndex, long x) throws SQLException { 2326 checkState(); 2327 2328 // To check the type and concurrency of the ResultSet 2329 // to verify whether updates are possible or not 2330 checkTypeConcurrency(); 2331 2332 rs.updateLong(columnIndex, x); 2333 } 2334 2335 /** 2336 * Updates the designated column with a {@code float} value. 2337 * The {@code updateXXX} methods are used to update column values in the 2338 * current row or the insert row. The {@code updateXXX} methods do not 2339 * update the underlying database; instead the {@code updateRow} or 2340 * {@code insertRow} methods are called to update the database. 2341 * 2342 * @param columnIndex the first column is 1, the second is 2, and so on 2343 * @param x the new column value 2344 * @throws SQLException if a database access error occurs 2345 * or this rowset does not currently have a valid connection, 2346 * prepared statement, and result set 2347 * 2348 */ 2349 public void updateFloat(int columnIndex, float x) throws SQLException { 2350 checkState(); 2351 2352 // To check the type and concurrency of the ResultSet 2353 // to verify whether updates are possible or not 2354 checkTypeConcurrency(); 2355 2356 rs.updateFloat(columnIndex, x); 2357 } 2358 2359 /** 2360 * Updates the designated column with a {@code double} value. 2361 * The {@code updateXXX} methods are used to update column values in the 2362 * current row or the insert row. The {@code updateXXX} methods do not 2363 * update the underlying database; instead the {@code updateRow} or 2364 * {@code insertRow} methods are called to update the database. 2365 * 2366 * @param columnIndex the first column is 1, the second is 2, and so on 2367 * @param x the new column value 2368 * @throws SQLException if a database access error occurs 2369 * or this rowset does not currently have a valid connection, 2370 * prepared statement, and result set 2371 * 2372 */ 2373 public void updateDouble(int columnIndex, double x) throws SQLException { 2374 checkState(); 2375 2376 // To check the type and concurrency of the ResultSet 2377 // to verify whether updates are possible or not 2378 checkTypeConcurrency(); 2379 2380 rs.updateDouble(columnIndex, x); 2381 } 2382 2383 /** 2384 * Updates the designated column with a {@code java.math.BigDecimal} 2385 * value. 2386 * The {@code updateXXX} methods are used to update column values in the 2387 * current row or the insert row. The {@code updateXXX} methods do not 2388 * update the underlying database; instead the {@code updateRow} or 2389 * {@code insertRow} methods are called to update the database. 2390 * 2391 * @param columnIndex the first column is 1, the second is 2, and so on 2392 * @param x the new column value 2393 * @throws SQLException if a database access error occurs 2394 * or this rowset does not currently have a valid connection, 2395 * prepared statement, and result set 2396 * 2397 */ 2398 public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException { 2399 checkState(); 2400 2401 // To check the type and concurrency of the ResultSet 2402 // to verify whether updates are possible or not 2403 checkTypeConcurrency(); 2404 2405 rs.updateBigDecimal(columnIndex, x); 2406 } 2407 2408 /** 2409 * Updates the designated column with a {@code String} value. 2410 * The {@code updateXXX} methods are used to update column values in the 2411 * current row or the insert row. The {@code updateXXX} methods do not 2412 * update the underlying database; instead the {@code updateRow} or 2413 * {@code insertRow} methods are called to update the database. 2414 * 2415 * @param columnIndex the first column is 1, the second is 2, and so on 2416 * @param x the new column value 2417 * @throws SQLException if a database access error occurs 2418 * or this rowset does not currently have a valid connection, 2419 * prepared statement, and result set 2420 * 2421 */ 2422 public void updateString(int columnIndex, String x) throws SQLException { 2423 checkState(); 2424 2425 // To check the type and concurrency of the ResultSet 2426 // to verify whether updates are possible or not 2427 checkTypeConcurrency(); 2428 2429 rs.updateString(columnIndex, x); 2430 } 2431 2432 /** 2433 * Updates the designated column with a {@code byte} array value. 2434 * The {@code updateXXX} methods are used to update column values in the 2435 * current row or the insert row. The {@code updateXXX} methods do not 2436 * update the underlying database; instead the {@code updateRow} or 2437 * {@code insertRow} methods are called to update the database. 2438 * 2439 * @param columnIndex the first column is 1, the second is 2, and so on 2440 * @param x the new column value 2441 * @throws SQLException if a database access error occurs 2442 * or this rowset does not currently have a valid connection, 2443 * prepared statement, and result set 2444 * 2445 */ 2446 public void updateBytes(int columnIndex, byte x[]) throws SQLException { 2447 checkState(); 2448 2449 // To check the type and concurrency of the ResultSet 2450 // to verify whether updates are possible or not 2451 checkTypeConcurrency(); 2452 2453 rs.updateBytes(columnIndex, x); 2454 } 2455 2456 /** 2457 * Updates the designated column with a {@code java.sql.Date} value. 2458 * The {@code updateXXX} methods are used to update column values in the 2459 * current row or the insert row. The {@code updateXXX} methods do not 2460 * update the underlying database; instead the {@code updateRow} or 2461 * {@code insertRow} methods are called to update the database. 2462 * 2463 * @param columnIndex the first column is 1, the second is 2, and so on 2464 * @param x the new column value 2465 * @throws SQLException if a database access error occurs 2466 * or this rowset does not currently have a valid connection, 2467 * prepared statement, and result set 2468 * 2469 */ 2470 public void updateDate(int columnIndex, java.sql.Date x) throws SQLException { 2471 checkState(); 2472 2473 // To check the type and concurrency of the ResultSet 2474 // to verify whether updates are possible or not 2475 checkTypeConcurrency(); 2476 2477 rs.updateDate(columnIndex, x); 2478 } 2479 2480 2481 /** 2482 * Updates the designated column with a {@code java.sql.Time} value. 2483 * The {@code updateXXX} methods are used to update column values in the 2484 * current row or the insert row. The {@code updateXXX} methods do not 2485 * update the underlying database; instead the {@code updateRow} or 2486 * {@code insertRow} methods are called to update the database. 2487 * 2488 * @param columnIndex the first column is 1, the second is 2, and so on 2489 * @param x the new column value 2490 * @throws SQLException if a database access error occurs 2491 * or this rowset does not currently have a valid connection, 2492 * prepared statement, and result set 2493 * 2494 */ 2495 public void updateTime(int columnIndex, java.sql.Time x) throws SQLException { 2496 checkState(); 2497 2498 // To check the type and concurrency of the ResultSet 2499 // to verify whether updates are possible or not 2500 checkTypeConcurrency(); 2501 2502 rs.updateTime(columnIndex, x); 2503 } 2504 2505 /** 2506 * Updates the designated column with a {@code java.sql.Timestamp} 2507 * value. 2508 * The {@code updateXXX} methods are used to update column values in the 2509 * current row or the insert row. The {@code updateXXX} methods do not 2510 * update the underlying database; instead the {@code updateRow} or 2511 * {@code insertRow} methods are called to update the database. 2512 * 2513 * @param columnIndex the first column is 1, the second is 2, and so on 2514 * @param x the new column value 2515 * @throws SQLException if a database access error occurs 2516 * or this rowset does not currently have a valid connection, 2517 * prepared statement, and result set 2518 * 2519 */ 2520 public void updateTimestamp(int columnIndex, java.sql.Timestamp x) throws SQLException { 2521 checkState(); 2522 2523 // To check the type and concurrency of the ResultSet 2524 // to verify whether updates are possible or not 2525 checkTypeConcurrency(); 2526 2527 rs.updateTimestamp(columnIndex, x); 2528 } 2529 2530 /** 2531 * Updates the designated column with an ascii stream value. 2532 * The {@code updateXXX} methods are used to update column values in the 2533 * current row or the insert row. The {@code updateXXX} methods do not 2534 * update the underlying database; instead the {@code updateRow} or 2535 * {@code insertRow} methods are called to update the database. 2536 * 2537 * @param columnIndex the first column is 1, the second is 2, and so on 2538 * @param x the new column value 2539 * @param length the length of the stream 2540 * @throws SQLException if (1) a database access error occurs 2541 * (2) or this rowset does not currently have a valid connection, 2542 * prepared statement, and result set 2543 * 2544 */ 2545 public void updateAsciiStream(int columnIndex, java.io.InputStream x, int length) throws SQLException { 2546 checkState(); 2547 2548 // To check the type and concurrency of the ResultSet 2549 // to verify whether updates are possible or not 2550 checkTypeConcurrency(); 2551 2552 rs.updateAsciiStream(columnIndex, x, length); 2553 } 2554 2555 /** 2556 * Updates the designated column with a binary stream value. 2557 * The {@code updateXXX} methods are used to update column values in the 2558 * current row or the insert row. The {@code updateXXX} methods do not 2559 * update the underlying database; instead the {@code updateRow} or 2560 * {@code insertRow} methods are called to update the database. 2561 * 2562 * @param columnIndex the first column is 1, the second is 2, and so on 2563 * @param x the new column value 2564 * @param length the length of the stream 2565 * @throws SQLException if a database access error occurs 2566 * or this rowset does not currently have a valid connection, 2567 * prepared statement, and result set 2568 * 2569 */ 2570 public void updateBinaryStream(int columnIndex, java.io.InputStream x, int length) throws SQLException { 2571 checkState(); 2572 2573 // To check the type and concurrency of the ResultSet 2574 // to verify whether updates are possible or not 2575 checkTypeConcurrency(); 2576 2577 rs.updateBinaryStream(columnIndex, x, length); 2578 } 2579 2580 /** 2581 * Updates the designated column with a character stream value. 2582 * The {@code updateXXX} methods are used to update column values in the 2583 * current row or the insert row. The {@code updateXXX} methods do not 2584 * update the underlying database; instead the {@code updateRow} or 2585 * {@code insertRow} methods are called to update the database. 2586 * 2587 * @param columnIndex the first column is 1, the second is 2, and so on 2588 * @param x the new column value 2589 * @param length the length of the stream 2590 * @throws SQLException if a database access error occurs 2591 * or this rowset does not currently have a valid connection, 2592 * prepared statement, and result set 2593 * 2594 */ 2595 public void updateCharacterStream(int columnIndex, java.io.Reader x, int length) throws SQLException { 2596 checkState(); 2597 2598 // To check the type and concurrency of the ResultSet 2599 // to verify whether updates are possible or not 2600 checkTypeConcurrency(); 2601 2602 rs.updateCharacterStream(columnIndex, x, length); 2603 } 2604 2605 /** 2606 * Updates the designated column with an {@code Object} value. 2607 * The {@code updateXXX} methods are used to update column values in the 2608 * current row or the insert row. The {@code updateXXX} methods do not 2609 * update the underlying database; instead the {@code updateRow} or 2610 * {@code insertRow} methods are called to update the database. 2611 * 2612 * @param columnIndex the first column is 1, the second is 2, and so on 2613 * @param x the new column value 2614 * @param scale for {@code java.sql.Types.DECIMAl} 2615 * or {@code java.sql.Types.NUMERIC} types, 2616 * this is the number of digits after the decimal point. For all other 2617 * types this value will be ignored. 2618 * @throws SQLException if a database access error occurs 2619 * or this rowset does not currently have a valid connection, 2620 * prepared statement, and result set 2621 * 2622 */ 2623 public void updateObject(int columnIndex, Object x, int scale) throws SQLException { 2624 checkState(); 2625 2626 // To check the type and concurrency of the ResultSet 2627 // to verify whether updates are possible or not 2628 checkTypeConcurrency(); 2629 2630 rs.updateObject(columnIndex, x, scale); 2631 } 2632 2633 /** 2634 * Updates the designated column with an {@code Object} value. 2635 * The {@code updateXXX} methods are used to update column values in the 2636 * current row or the insert row. The {@code updateXXX} methods do not 2637 * update the underlying database; instead the {@code updateRow} or 2638 * {@code insertRow} methods are called to update the database. 2639 * 2640 * @param columnIndex the first column is 1, the second is 2, and so on 2641 * @param x the new column value 2642 * @throws SQLException if a database access error occurs 2643 * or this rowset does not currently have a valid connection, 2644 * prepared statement, and result set 2645 * 2646 */ 2647 public void updateObject(int columnIndex, Object x) throws SQLException { 2648 checkState(); 2649 2650 // To check the type and concurrency of the ResultSet 2651 // to verify whether updates are possible or not 2652 checkTypeConcurrency(); 2653 2654 rs.updateObject(columnIndex, x); 2655 } 2656 2657 /** 2658 * Updates the designated column with a {@code null} value. 2659 * The {@code updateXXX} methods are used to update column values in the 2660 * current row or the insert row. The {@code updateXXX} methods do not 2661 * update the underlying database; instead the {@code updateRow} or 2662 * {@code insertRow} methods are called to update the database. 2663 * 2664 * @param columnName the name of the column 2665 * @throws SQLException if a database access error occurs 2666 * or this rowset does not currently have a valid connection, 2667 * prepared statement, and result set 2668 * 2669 */ 2670 public void updateNull(String columnName) throws SQLException { 2671 updateNull(findColumn(columnName)); 2672 } 2673 2674 /** 2675 * Updates the designated column with a {@code boolean} value. 2676 * The {@code updateXXX} methods are used to update column values in the 2677 * current row or the insert row. The {@code updateXXX} methods do not 2678 * update the underlying database; instead the {@code updateRow} or 2679 * {@code insertRow} methods are called to update the database. 2680 * 2681 * @param columnName the name of the column 2682 * @param x the new column value 2683 * @throws SQLException if a database access error occurs 2684 * 2685 */ 2686 public void updateBoolean(String columnName, boolean x) throws SQLException { 2687 updateBoolean(findColumn(columnName), x); 2688 } 2689 2690 /** 2691 * Updates the designated column with a {@code byte} value. 2692 * The {@code updateXXX} methods are used to update column values in the 2693 * current row or the insert row. The {@code updateXXX} methods do not 2694 * update the underlying database; instead the {@code updateRow} or 2695 * {@code insertRow} methods are called to update the database. 2696 * 2697 * @param columnName the name of the column 2698 * @param x the new column value 2699 * @throws SQLException if a database access error occurs 2700 * 2701 */ 2702 public void updateByte(String columnName, byte x) throws SQLException { 2703 updateByte(findColumn(columnName), x); 2704 } 2705 2706 /** 2707 * Updates the designated column with a {@code short} value. 2708 * The {@code updateXXX} methods are used to update column values in the 2709 * current row or the insert row. The {@code updateXXX} methods do not 2710 * update the underlying database; instead the {@code updateRow} or 2711 * {@code insertRow} methods are called to update the database. 2712 * 2713 * @param columnName the name of the column 2714 * @param x the new column value 2715 * @throws SQLException if a database access error occurs 2716 * 2717 */ 2718 public void updateShort(String columnName, short x) throws SQLException { 2719 updateShort(findColumn(columnName), x); 2720 } 2721 2722 /** 2723 * Updates the designated column with an {@code int} value. 2724 * The {@code updateXXX} methods are used to update column values in the 2725 * current row or the insert row. The {@code updateXXX} methods do not 2726 * update the underlying database; instead the {@code updateRow} or 2727 * {@code insertRow} methods are called to update the database. 2728 * 2729 * @param columnName the name of the column 2730 * @param x the new column value 2731 * @throws SQLException if a database access error occurs 2732 * 2733 */ 2734 public void updateInt(String columnName, int x) throws SQLException { 2735 updateInt(findColumn(columnName), x); 2736 } 2737 2738 /** 2739 * Updates the designated column with a {@code long} value. 2740 * The {@code updateXXX} methods are used to update column values in the 2741 * current row or the insert row. The {@code updateXXX} methods do not 2742 * update the underlying database; instead the {@code updateRow} or 2743 * {@code insertRow} methods are called to update the database. 2744 * 2745 * @param columnName the name of the column 2746 * @param x the new column value 2747 * @throws SQLException if a database access error occurs 2748 * 2749 */ 2750 public void updateLong(String columnName, long x) throws SQLException { 2751 updateLong(findColumn(columnName), x); 2752 } 2753 2754 /** 2755 * Updates the designated column with a {@code float } value. 2756 * The {@code updateXXX} methods are used to update column values in the 2757 * current row or the insert row. The {@code updateXXX} methods do not 2758 * update the underlying database; instead the {@code updateRow} or 2759 * {@code insertRow} methods are called to update the database. 2760 * 2761 * @param columnName the name of the column 2762 * @param x the new column value 2763 * @throws SQLException if a database access error occurs 2764 * 2765 */ 2766 public void updateFloat(String columnName, float x) throws SQLException { 2767 updateFloat(findColumn(columnName), x); 2768 } 2769 2770 /** 2771 * Updates the designated column with a {@code double} value. 2772 * The {@code updateXXX} methods are used to update column values in the 2773 * current row or the insert row. The {@code updateXXX} methods do not 2774 * update the underlying database; instead the {@code updateRow} or 2775 * {@code insertRow} methods are called to update the database. 2776 * 2777 * @param columnName the name of the column 2778 * @param x the new column value 2779 * @throws SQLException if a database access error occurs 2780 * 2781 */ 2782 public void updateDouble(String columnName, double x) throws SQLException { 2783 updateDouble(findColumn(columnName), x); 2784 } 2785 2786 /** 2787 * Updates the designated column with a {@code java.sql.BigDecimal} 2788 * value. 2789 * The {@code updateXXX} methods are used to update column values in the 2790 * current row or the insert row. The {@code updateXXX} methods do not 2791 * update the underlying database; instead the {@code updateRow} or 2792 * {@code insertRow} methods are called to update the database. 2793 * 2794 * @param columnName the name of the column 2795 * @param x the new column value 2796 * @throws SQLException if a database access error occurs 2797 * 2798 */ 2799 public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException { 2800 updateBigDecimal(findColumn(columnName), x); 2801 } 2802 2803 /** 2804 * Updates the designated column with a {@code String} value. 2805 * The {@code updateXXX} methods are used to update column values in the 2806 * current row or the insert row. The {@code updateXXX} methods do not 2807 * update the underlying database; instead the {@code updateRow} or 2808 * {@code insertRow} methods are called to update the database. 2809 * 2810 * @param columnName the name of the column 2811 * @param x the new column value 2812 * @throws SQLException if a database access error occurs 2813 * 2814 */ 2815 public void updateString(String columnName, String x) throws SQLException { 2816 updateString(findColumn(columnName), x); 2817 } 2818 2819 /** 2820 * Updates the designated column with a {@code boolean} value. 2821 * The {@code updateXXX} methods are used to update column values in the 2822 * current row or the insert row. The {@code updateXXX} methods do not 2823 * update the underlying database; instead the {@code updateRow} or 2824 * {@code insertRow} methods are called to update the database. 2825 * 2826 * JDBC 2.0 2827 * 2828 * Updates a column with a byte array value. 2829 * 2830 * The {@code updateXXX} methods are used to update column values in the 2831 * current row, or the insert row. The {@code updateXXX} methods do not 2832 * update the underlying database; instead the {@code updateRow} or {@code insertRow} 2833 * methods are called to update the database. 2834 * 2835 * @param columnName the name of the column 2836 * @param x the new column value 2837 * @throws SQLException if a database access error occurs 2838 * 2839 */ 2840 public void updateBytes(String columnName, byte x[]) throws SQLException { 2841 updateBytes(findColumn(columnName), x); 2842 } 2843 2844 /** 2845 * Updates the designated column with a {@code java.sql.Date} value. 2846 * The {@code updateXXX} methods are used to update column values in the 2847 * current row or the insert row. The {@code updateXXX} methods do not 2848 * update the underlying database; instead the {@code updateRow} or 2849 * {@code insertRow} methods are called to update the database. 2850 * 2851 * @param columnName the name of the column 2852 * @param x the new column value 2853 * @throws SQLException if a database access error occurs 2854 * 2855 */ 2856 public void updateDate(String columnName, java.sql.Date x) throws SQLException { 2857 updateDate(findColumn(columnName), x); 2858 } 2859 2860 /** 2861 * Updates the designated column with a {@code java.sql.Time} value. 2862 * The {@code updateXXX} methods are used to update column values in the 2863 * current row or the insert row. The {@code updateXXX} methods do not 2864 * update the underlying database; instead the {@code updateRow} or 2865 * {@code insertRow} methods are called to update the database. 2866 * 2867 * @param columnName the name of the column 2868 * @param x the new column value 2869 * @throws SQLException if a database access error occurs 2870 * 2871 */ 2872 public void updateTime(String columnName, java.sql.Time x) throws SQLException { 2873 updateTime(findColumn(columnName), x); 2874 } 2875 2876 /** 2877 * Updates the designated column with a {@code java.sql.Timestamp} 2878 * value. 2879 * The {@code updateXXX} methods are used to update column values in the 2880 * current row or the insert row. The {@code updateXXX} methods do not 2881 * update the underlying database; instead the {@code updateRow} or 2882 * {@code insertRow} methods are called to update the database. 2883 * 2884 * @param columnName the name of the column 2885 * @param x the new column value 2886 * @throws SQLException if a database access error occurs 2887 * 2888 */ 2889 public void updateTimestamp(String columnName, java.sql.Timestamp x) throws SQLException { 2890 updateTimestamp(findColumn(columnName), x); 2891 } 2892 2893 /** 2894 * Updates the designated column with an ascii stream value. 2895 * The {@code updateXXX} methods are used to update column values in the 2896 * current row or the insert row. The {@code updateXXX} methods do not 2897 * update the underlying database; instead the {@code updateRow} or 2898 * {@code insertRow} methods are called to update the database. 2899 * 2900 * @param columnName the name of the column 2901 * @param x the new column value 2902 * @param length the length of the stream 2903 * @throws SQLException if a database access error occurs 2904 * 2905 */ 2906 public void updateAsciiStream(String columnName, java.io.InputStream x, int length) throws SQLException { 2907 updateAsciiStream(findColumn(columnName), x, length); 2908 } 2909 2910 /** 2911 * Updates the designated column with a binary stream value. 2912 * The {@code updateXXX} methods are used to update column values in the 2913 * current row or the insert row. The {@code updateXXX} methods do not 2914 * update the underlying database; instead the {@code updateRow} or 2915 * {@code insertRow} methods are called to update the database. 2916 * 2917 * @param columnName the name of the column 2918 * @param x the new column value 2919 * @param length the length of the stream 2920 * @throws SQLException if a database access error occurs 2921 * 2922 */ 2923 public void updateBinaryStream(String columnName, java.io.InputStream x, int length) throws SQLException { 2924 updateBinaryStream(findColumn(columnName), x, length); 2925 } 2926 2927 /** 2928 * Updates the designated column with a character stream value. 2929 * The {@code updateXXX} methods are used to update column values 2930 * in the current row or the insert row. The {@code updateXXX} 2931 * methods do not update the underlying database; instead the 2932 * {@code updateRow} or {@code insertRow} methods are called 2933 * to update the database. 2934 * 2935 * @param columnName the name of the column 2936 * @param reader the new column {@code Reader} stream value 2937 * @param length the length of the stream 2938 * @throws SQLException if a database access error occurs 2939 * 2940 */ 2941 public void updateCharacterStream(String columnName, java.io.Reader reader, int length) throws SQLException { 2942 updateCharacterStream(findColumn(columnName), reader, length); 2943 } 2944 2945 /** 2946 * Updates the designated column with an {@code Object} value. 2947 * The {@code updateXXX} methods are used to update column values in the 2948 * current row or the insert row. The {@code updateXXX} methods do not 2949 * update the underlying database; instead the {@code updateRow} or 2950 * {@code insertRow} methods are called to update the database. 2951 * 2952 * @param columnName the name of the column 2953 * @param x the new column value 2954 * @param scale for {@code java.sql.Types.DECIMAL} 2955 * or {@code java.sql.Types.NUMERIC} types, 2956 * this is the number of digits after the decimal point. For all other 2957 * types this value will be ignored. 2958 * @throws SQLException if a database access error occurs 2959 * 2960 */ 2961 public void updateObject(String columnName, Object x, int scale) throws SQLException { 2962 updateObject(findColumn(columnName), x, scale); 2963 } 2964 2965 /** 2966 * Updates the designated column with an {@code Object} value. 2967 * The {@code updateXXX} methods are used to update column values in the 2968 * current row or the insert row. The {@code updateXXX} methods do not 2969 * update the underlying database; instead the {@code updateRow} or 2970 * {@code insertRow} methods are called to update the database. 2971 * 2972 * @param columnName the name of the column 2973 * @param x the new column value 2974 * @throws SQLException if a database access error occurs 2975 * 2976 */ 2977 public void updateObject(String columnName, Object x) throws SQLException { 2978 updateObject(findColumn(columnName), x); 2979 } 2980 2981 /** 2982 * Inserts the contents of the insert row into this 2983 * {@code ResultSet} object and into the database 2984 * and also notifies listeners that a row has changed. 2985 * The cursor must be on the insert row when this method is called. 2986 * 2987 * @throws SQLException if (1) a database access error occurs, 2988 * (2) this method is called when the cursor is not 2989 * on the insert row, (3) not all non-nullable columns in 2990 * the insert row have been given a value, or (4) this 2991 * rowset does not currently have a valid connection, 2992 * prepared statement, and result set 2993 */ 2994 public void insertRow() throws SQLException { 2995 checkState(); 2996 2997 rs.insertRow(); 2998 notifyRowChanged(); 2999 } 3000 3001 /** 3002 * Updates the underlying database with the new contents of the 3003 * current row of this rowset's {@code ResultSet} object 3004 * and notifies listeners that a row has changed. 3005 * This method cannot be called when the cursor is on the insert row. 3006 * 3007 * @throws SQLException if (1) a database access error occurs, 3008 * (2) this method is called when the cursor is 3009 * on the insert row, (3) the concurrency of the result 3010 * set is {@code ResultSet.CONCUR_READ_ONLY}, or 3011 * (4) this rowset does not currently have a valid connection, 3012 * prepared statement, and result set 3013 */ 3014 public void updateRow() throws SQLException { 3015 checkState(); 3016 3017 rs.updateRow(); 3018 notifyRowChanged(); 3019 } 3020 3021 /** 3022 * Deletes the current row from this rowset's {@code ResultSet} object 3023 * and from the underlying database and also notifies listeners that a row 3024 * has changed. This method cannot be called when the cursor is on the insert 3025 * row. 3026 * 3027 * @throws SQLException if a database access error occurs 3028 * or if this method is called when the cursor is on the insert row 3029 * @throws SQLException if (1) a database access error occurs, 3030 * (2) this method is called when the cursor is before the 3031 * first row, after the last row, or on the insert row, 3032 * (3) the concurrency of this rowset's result 3033 * set is {@code ResultSet.CONCUR_READ_ONLY}, or 3034 * (4) this rowset does not currently have a valid connection, 3035 * prepared statement, and result set 3036 */ 3037 public void deleteRow() throws SQLException { 3038 checkState(); 3039 3040 rs.deleteRow(); 3041 notifyRowChanged(); 3042 } 3043 3044 /** 3045 * Refreshes the current row of this rowset's {@code ResultSet} 3046 * object with its most recent value in the database. This method 3047 * cannot be called when the cursor is on the insert row. 3048 * 3049 * <P>The {@code refreshRow} method provides a way for an 3050 * application to explicitly tell the JDBC driver to refetch 3051 * a row(s) from the database. An application may want to call 3052 * {@code refreshRow} when caching or prefetching is being 3053 * done by the JDBC driver to fetch the latest value of a row 3054 * from the database. The JDBC driver may actually refresh multiple 3055 * rows at once if the fetch size is greater than one. 3056 * 3057 * <P> All values are refetched subject to the transaction isolation 3058 * level and cursor sensitivity. If {@code refreshRow} is called after 3059 * calling an {@code updateXXX} method, but before calling 3060 * the method {@code updateRow}, then the 3061 * updates made to the row are lost. Calling the method 3062 * {@code refreshRow} frequently will likely slow performance. 3063 * 3064 * @throws SQLException if (1) a database access error occurs, 3065 * (2) this method is called when the cursor is 3066 * on the insert row, or (3) this rowset does not 3067 * currently have a valid connection, prepared statement, 3068 * and result set 3069 * 3070 */ 3071 public void refreshRow() throws SQLException { 3072 checkState(); 3073 3074 rs.refreshRow(); 3075 } 3076 3077 /** 3078 * Cancels the updates made to the current row in this 3079 * {@code ResultSet} object and notifies listeners that a row 3080 * has changed. This method may be called after calling an 3081 * {@code updateXXX} method(s) and before calling 3082 * the method {@code updateRow} to roll back 3083 * the updates made to a row. If no updates have been made or 3084 * {@code updateRow} has already been called, this method has no 3085 * effect. 3086 * 3087 * @throws SQLException if (1) a database access error occurs, 3088 * (2) this method is called when the cursor is 3089 * on the insert row, or (3) this rowset does not 3090 * currently have a valid connection, prepared statement, 3091 * and result set 3092 */ 3093 public void cancelRowUpdates() throws SQLException { 3094 checkState(); 3095 3096 rs.cancelRowUpdates(); 3097 3098 notifyRowChanged(); 3099 } 3100 3101 /** 3102 * Moves the cursor to the insert row. The current cursor position is 3103 * remembered while the cursor is positioned on the insert row. 3104 * 3105 * The insert row is a special row associated with an updatable 3106 * result set. It is essentially a buffer where a new row may 3107 * be constructed by calling the {@code updateXXX} methods prior to 3108 * inserting the row into the result set. 3109 * 3110 * Only the {@code updateXXX}, {@code getXXX}, 3111 * and {@code insertRow} methods may be 3112 * called when the cursor is on the insert row. All of the columns in 3113 * a result set must be given a value each time this method is 3114 * called before calling {@code insertRow}. 3115 * An {@code updateXXX} method must be called before a 3116 * {@code getXXX} method can be called on a column value. 3117 * 3118 * @throws SQLException if (1) a database access error occurs, 3119 * (2) this rowset's {@code ResultSet} object is 3120 * not updatable, or (3) this rowset does not 3121 * currently have a valid connection, prepared statement, 3122 * and result set 3123 * 3124 */ 3125 public void moveToInsertRow() throws SQLException { 3126 checkState(); 3127 3128 rs.moveToInsertRow(); 3129 } 3130 3131 /** 3132 * Moves the cursor to the remembered cursor position, usually the 3133 * current row. This method has no effect if the cursor is not on 3134 * the insert row. 3135 * 3136 * @throws SQLException if (1) a database access error occurs, 3137 * (2) this rowset's {@code ResultSet} object is 3138 * not updatable, or (3) this rowset does not 3139 * currently have a valid connection, prepared statement, 3140 * and result set 3141 */ 3142 public void moveToCurrentRow() throws SQLException { 3143 checkState(); 3144 3145 rs.moveToCurrentRow(); 3146 } 3147 3148 /** 3149 * Returns the {@code Statement} object that produced this 3150 * {@code ResultSet} object. 3151 * If the result set was generated some other way, such as by a 3152 * {@code DatabaseMetaData} method, this method returns 3153 * {@code null}. 3154 * 3155 * @return the {@code Statement} object that produced 3156 * this rowset's {@code ResultSet} object or {@code null} 3157 * if the result set was produced some other way 3158 * @throws SQLException if a database access error occurs 3159 */ 3160 public java.sql.Statement getStatement() throws SQLException { 3161 3162 if(rs != null) 3163 { 3164 return rs.getStatement(); 3165 } else { 3166 return null; 3167 } 3168 } 3169 3170 /** 3171 * Returns the value of the designated column in the current row 3172 * of this rowset's {@code ResultSet} object as an {@code Object}. 3173 * This method uses the given {@code Map} object 3174 * for the custom mapping of the 3175 * SQL structured or distinct type that is being retrieved. 3176 * 3177 * @param i the first column is 1, the second is 2, and so on 3178 * @param map a {@code java.util.Map} object that contains the mapping 3179 * from SQL type names to classes in the Java programming language 3180 * @return an {@code Object} in the Java programming language 3181 * representing the SQL value 3182 * @throws SQLException if (1) a database access error occurs 3183 * or (2) this rowset does not currently have a valid connection, 3184 * prepared statement, and result set 3185 */ 3186 public Object getObject(int i, java.util.Map<String,Class<?>> map) 3187 throws SQLException 3188 { 3189 checkState(); 3190 3191 return rs.getObject(i, map); 3192 } 3193 3194 /** 3195 * Returns the value of the designated column in the current row 3196 * of this rowset's {@code ResultSet} object as a {@code Ref} object. 3197 * 3198 * @param i the first column is 1, the second is 2, and so on 3199 * @return a {@code Ref} object representing an SQL {@code REF} value 3200 * @throws SQLException if (1) a database access error occurs 3201 * or (2) this rowset does not currently have a valid connection, 3202 * prepared statement, and result set 3203 */ 3204 public Ref getRef(int i) throws SQLException { 3205 checkState(); 3206 3207 return rs.getRef(i); 3208 } 3209 3210 3211 /** 3212 * Returns the value of the designated column in the current row 3213 * of this rowset's {@code ResultSet} object as a {@code Blob} object. 3214 * 3215 * @param i the first column is 1, the second is 2, and so on 3216 * @return a {@code Blob} object representing the SQL {@code BLOB} 3217 * value in the specified column 3218 * @throws SQLException if (1) a database access error occurs 3219 * or (2) this rowset does not currently have a valid connection, 3220 * prepared statement, and result set 3221 */ 3222 public Blob getBlob(int i) throws SQLException { 3223 checkState(); 3224 3225 return rs.getBlob(i); 3226 } 3227 3228 /** 3229 * Returns the value of the designated column in the current row 3230 * of this rowset's {@code ResultSet} object as a {@code Clob} object. 3231 * 3232 * @param i the first column is 1, the second is 2, and so on 3233 * @return a {@code Clob} object representing the SQL {@code CLOB} 3234 * value in the specified column 3235 * @throws SQLException if (1) a database access error occurs 3236 * or (2) this rowset does not currently have a valid connection, 3237 * prepared statement, and result set 3238 */ 3239 public Clob getClob(int i) throws SQLException { 3240 checkState(); 3241 3242 return rs.getClob(i); 3243 } 3244 3245 /** 3246 * Returns the value of the designated column in the current row 3247 * of this rowset's {@code ResultSet} object as an {@code Array} object. 3248 * 3249 * @param i the first column is 1, the second is 2, and so on. 3250 * @return an {@code Array} object representing the SQL {@code ARRAY} 3251 * value in the specified column 3252 * @throws SQLException if (1) a database access error occurs 3253 * or (2) this rowset does not currently have a valid connection, 3254 * prepared statement, and result set 3255 */ 3256 public Array getArray(int i) throws SQLException { 3257 checkState(); 3258 3259 return rs.getArray(i); 3260 } 3261 3262 /** 3263 * Returns the value of the designated column in the current row 3264 * of this rowset's {@code ResultSet} object as an {@code Object}. 3265 * This method uses the specified {@code Map} object for 3266 * custom mapping if appropriate. 3267 * 3268 * @param colName the name of the column from which to retrieve the value 3269 * @param map a {@code java.util.Map} object that contains the mapping 3270 * from SQL type names to classes in the Java programming language 3271 * @return an {@code Object} representing the SQL 3272 * value in the specified column 3273 * @throws SQLException if (1) a database access error occurs 3274 * or (2) this rowset does not currently have a valid connection, 3275 * prepared statement, and result set 3276 */ 3277 public Object getObject(String colName, java.util.Map<String,Class<?>> map) 3278 throws SQLException 3279 { 3280 return getObject(findColumn(colName), map); 3281 } 3282 3283 /** 3284 * Returns the value of the designated column in the current row 3285 * of this rowset's {@code ResultSet} object as a {@code Ref} object. 3286 * 3287 * @param colName the column name 3288 * @return a {@code Ref} object representing the SQL {@code REF} value in 3289 * the specified column 3290 * @throws SQLException if (1) a database access error occurs 3291 * or (2) this rowset does not currently have a valid connection, 3292 * prepared statement, and result set 3293 */ 3294 public Ref getRef(String colName) throws SQLException { 3295 return getRef(findColumn(colName)); 3296 } 3297 3298 /** 3299 * Returns the value of the designated column in the current row 3300 * of this rowset's {@code ResultSet} object as a {@code Blob} object. 3301 * 3302 * @param colName the name of the column from which to retrieve the value 3303 * @return a {@code Blob} object representing the SQL {@code BLOB} 3304 * value in the specified column 3305 * @throws SQLException if (1) a database access error occurs 3306 * or (2) this rowset does not currently have a valid connection, 3307 * prepared statement, and result set 3308 */ 3309 public Blob getBlob(String colName) throws SQLException { 3310 return getBlob(findColumn(colName)); 3311 } 3312 3313 /** 3314 * Returns the value of the designated column in the current row 3315 * of this rowset's {@code ResultSet} object as a {@code Clob} object. 3316 * 3317 * @param colName the name of the column from which to retrieve the value 3318 * @return a {@code Clob} object representing the SQL {@code CLOB} 3319 * value in the specified column 3320 * @throws SQLException if (1) a database access error occurs 3321 * or (2) this rowset does not currently have a valid connection, 3322 * prepared statement, and result set 3323 */ 3324 public Clob getClob(String colName) throws SQLException { 3325 return getClob(findColumn(colName)); 3326 } 3327 3328 /** 3329 * Returns the value of the designated column in the current row 3330 * of this rowset's {@code ResultSet} object as an {@code Array} object. 3331 * 3332 * @param colName the name of the column from which to retrieve the value 3333 * @return an {@code Array} object representing the SQL {@code ARRAY} 3334 * value in the specified column 3335 * @throws SQLException if (1) a database access error occurs 3336 * or (2) this rowset does not currently have a valid connection, 3337 * prepared statement, and result set 3338 */ 3339 public Array getArray(String colName) throws SQLException { 3340 return getArray(findColumn(colName)); 3341 } 3342 3343 /** 3344 * Returns the value of the designated column in the current row 3345 * of this rowset's {@code ResultSet} object as a {@code java.sql.Date} 3346 * object. This method uses the given calendar to construct an appropriate 3347 * millisecond value for the date if the underlying database does not store 3348 * timezone information. 3349 * 3350 * @param columnIndex the first column is 1, the second is 2, and so on 3351 * @param cal the {@code java.util.Calendar} object 3352 * to use in constructing the date 3353 * @return the column value as a {@code java.sql.Date} object; 3354 * if the value is SQL {@code NULL}, 3355 * the value returned is {@code null} 3356 * @throws SQLException if (1) a database access error occurs 3357 * or (2) this rowset does not currently have a valid connection, 3358 * prepared statement, and result set 3359 */ 3360 public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLException { 3361 checkState(); 3362 3363 return rs.getDate(columnIndex, cal); 3364 } 3365 3366 /** 3367 * Returns the value of the designated column in the current row 3368 * of this rowset's {@code ResultSet} object as a {@code java.sql.Date} 3369 * object. This method uses the given calendar to construct an appropriate 3370 * millisecond value for the date if the underlying database does not store 3371 * timezone information. 3372 * 3373 * @param columnName the SQL name of the column from which to retrieve the value 3374 * @param cal the {@code java.util.Calendar} object 3375 * to use in constructing the date 3376 * @return the column value as a {@code java.sql.Date} object; 3377 * if the value is SQL {@code NULL}, 3378 * the value returned is {@code null} 3379 * @throws SQLException if a database access error occurs 3380 * or this rowset does not currently have a valid connection, 3381 * prepared statement, and result set 3382 * 3383 */ 3384 public java.sql.Date getDate(String columnName, Calendar cal) throws SQLException { 3385 return getDate(findColumn(columnName), cal); 3386 } 3387 3388 /** 3389 * Returns the value of the designated column in the current row 3390 * of this rowset's {@code ResultSet} object as a {@code java.sql.Time} 3391 * object. This method uses the given calendar to construct an appropriate 3392 * millisecond value for the date if the underlying database does not store 3393 * timezone information. 3394 * 3395 * @param columnIndex the first column is 1, the second is 2, and so on 3396 * @param cal the {@code java.util.Calendar} object 3397 * to use in constructing the time 3398 * @return the column value as a {@code java.sql.Time} object; 3399 * if the value is SQL {@code NULL}, 3400 * the value returned is {@code null} in the Java programming language 3401 * @throws SQLException if a database access error occurs 3402 * or this rowset does not currently have a valid connection, 3403 * prepared statement, and result set 3404 */ 3405 public java.sql.Time getTime(int columnIndex, Calendar cal) throws SQLException { 3406 checkState(); 3407 3408 return rs.getTime(columnIndex, cal); 3409 } 3410 3411 /** 3412 * Returns the value of the designated column in the current row 3413 * of this rowset's {@code ResultSet} object as a {@code java.sql.Time} 3414 * object. This method uses the given calendar to construct an appropriate 3415 * millisecond value for the date if the underlying database does not store 3416 * timezone information. 3417 * 3418 * @param columnName the SQL name of the column 3419 * @param cal the {@code java.util.Calendar} object 3420 * to use in constructing the time 3421 * @return the column value as a {@code java.sql.Time} object; 3422 * if the value is SQL {@code NULL}, 3423 * the value returned is {@code null} in the Java programming language 3424 * @throws SQLException if a database access error occurs 3425 * or this rowset does not currently have a valid connection, 3426 * prepared statement, and result set 3427 */ 3428 public java.sql.Time getTime(String columnName, Calendar cal) throws SQLException { 3429 return getTime(findColumn(columnName), cal); 3430 } 3431 3432 /** 3433 * Returns the value of the designated column in the current row 3434 * of this rowset's {@code ResultSet} object as a 3435 * {@code java.sql.Timestamp} object. 3436 * This method uses the given calendar to construct an appropriate millisecond 3437 * value for the timestamp if the underlying database does not store 3438 * timezone information. 3439 * 3440 * @param columnIndex the first column is 1, the second is 2, and so on 3441 * @param cal the {@code java.util.Calendar} object 3442 * to use in constructing the timestamp 3443 * @return the column value as a {@code java.sql.Timestamp} object; 3444 * if the value is SQL {@code NULL}, 3445 * the value returned is {@code null} 3446 * @throws SQLException if a database access error occurs 3447 * or this rowset does not currently have a valid connection, 3448 * prepared statement, and result set 3449 */ 3450 public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException { 3451 checkState(); 3452 3453 return rs.getTimestamp(columnIndex, cal); 3454 } 3455 3456 /** 3457 * Returns the value of the designated column in the current row 3458 * of this rowset's {@code ResultSet} object as a 3459 * {@code java.sql.Timestamp} object. 3460 * This method uses the given calendar to construct an appropriate millisecond 3461 * value for the timestamp if the underlying database does not store 3462 * timezone information. 3463 * 3464 * @param columnName the SQL name of the column 3465 * @param cal the {@code java.util.Calendar} object 3466 * to use in constructing the timestamp 3467 * @return the column value as a {@code java.sql.Timestamp} object; 3468 * if the value is SQL {@code NULL}, 3469 * the value returned is {@code null} 3470 * @throws SQLException if a database access error occurs 3471 * or this rowset does not currently have a valid connection, 3472 * prepared statement, and result set 3473 */ 3474 public java.sql.Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException { 3475 return getTimestamp(findColumn(columnName), cal); 3476 } 3477 3478 3479 /** 3480 * Sets the designated column in either the current row or the insert 3481 * row of this {@code JdbcRowSetImpl} object with the given 3482 * {@code double} value. 3483 * 3484 * This method updates a column value in either the current row or 3485 * the insert row of this rowset, but it does not update the 3486 * database. If the cursor is on a row in the rowset, the 3487 * method {@link #updateRow} must be called to update the database. 3488 * If the cursor is on the insert row, the method {@link #insertRow} 3489 * must be called, which will insert the new row into both this rowset 3490 * and the database. Both of these methods must be called before the 3491 * cursor moves to another row. 3492 * 3493 * @param columnIndex the first column is {@code 1}, the second 3494 * is {@code 2}, and so on; must be {@code 1} or larger 3495 * and equal to or less than the number of columns in this rowset 3496 * @param ref the new {@code Ref} column value 3497 * @throws SQLException if (1) the given column index is out of bounds, 3498 * (2) the cursor is not on one of this rowset's rows or its 3499 * insert row, or (3) this rowset is 3500 * {@code ResultSet.CONCUR_READ_ONLY} 3501 */ 3502 public void updateRef(int columnIndex, java.sql.Ref ref) 3503 throws SQLException { 3504 checkState(); 3505 rs.updateRef(columnIndex, ref); 3506 } 3507 3508 /** 3509 * Sets the designated column in either the current row or the insert 3510 * row of this {@code JdbcRowSetImpl} object with the given 3511 * {@code double} value. 3512 * 3513 * This method updates a column value in either the current row or 3514 * the insert row of this rowset, but it does not update the 3515 * database. If the cursor is on a row in the rowset, the 3516 * method {@link #updateRow} must be called to update the database. 3517 * If the cursor is on the insert row, the method {@link #insertRow} 3518 * must be called, which will insert the new row into both this rowset 3519 * and the database. Both of these methods must be called before the 3520 * cursor moves to another row. 3521 * 3522 * @param columnName a {@code String} object that must match the 3523 * SQL name of a column in this rowset, ignoring case 3524 * @param ref the new column value 3525 * @throws SQLException if (1) the given column name does not match the 3526 * name of a column in this rowset, (2) the cursor is not on 3527 * one of this rowset's rows or its insert row, or (3) this 3528 * rowset is {@code ResultSet.CONCUR_READ_ONLY} 3529 */ 3530 public void updateRef(String columnName, java.sql.Ref ref) 3531 throws SQLException { 3532 updateRef(findColumn(columnName), ref); 3533 } 3534 3535 /** 3536 * Sets the designated column in either the current row or the insert 3537 * row of this {@code JdbcRowSetImpl} object with the given 3538 * {@code double} value. 3539 * 3540 * This method updates a column value in either the current row or 3541 * the insert row of this rowset, but it does not update the 3542 * database. If the cursor is on a row in the rowset, the 3543 * method {@link #updateRow} must be called to update the database. 3544 * If the cursor is on the insert row, the method {@link #insertRow} 3545 * must be called, which will insert the new row into both this rowset 3546 * and the database. Both of these methods must be called before the 3547 * cursor moves to another row. 3548 * 3549 * @param columnIndex the first column is {@code 1}, the second 3550 * is {@code 2}, and so on; must be {@code 1} or larger 3551 * and equal to or less than the number of columns in this rowset 3552 * @param c the new column {@code Clob} value 3553 * @throws SQLException if (1) the given column index is out of bounds, 3554 * (2) the cursor is not on one of this rowset's rows or its 3555 * insert row, or (3) this rowset is 3556 * {@code ResultSet.CONCUR_READ_ONLY} 3557 */ 3558 public void updateClob(int columnIndex, Clob c) throws SQLException { 3559 checkState(); 3560 rs.updateClob(columnIndex, c); 3561 } 3562 3563 3564 /** 3565 * Sets the designated column in either the current row or the insert 3566 * row of this {@code JdbcRowSetImpl} object with the given 3567 * {@code double} value. 3568 * 3569 * This method updates a column value in either the current row or 3570 * the insert row of this rowset, but it does not update the 3571 * database. If the cursor is on a row in the rowset, the 3572 * method {@link #updateRow} must be called to update the database. 3573 * If the cursor is on the insert row, the method {@link #insertRow} 3574 * must be called, which will insert the new row into both this rowset 3575 * and the database. Both of these methods must be called before the 3576 * cursor moves to another row. 3577 * 3578 * @param columnName a {@code String} object that must match the 3579 * SQL name of a column in this rowset, ignoring case 3580 * @param c the new column {@code Clob} value 3581 * @throws SQLException if (1) the given column name does not match the 3582 * name of a column in this rowset, (2) the cursor is not on 3583 * one of this rowset's rows or its insert row, or (3) this 3584 * rowset is {@code ResultSet.CONCUR_READ_ONLY} 3585 */ 3586 public void updateClob(String columnName, Clob c) throws SQLException { 3587 updateClob(findColumn(columnName), c); 3588 } 3589 3590 /** 3591 * Sets the designated column in either the current row or the insert 3592 * row of this {@code JdbcRowSetImpl} object with the given 3593 * {@code java.sql.Blob} value. 3594 * 3595 * This method updates a column value in either the current row or 3596 * the insert row of this rowset, but it does not update the 3597 * database. If the cursor is on a row in the rowset, the 3598 * method {@link #updateRow} must be called to update the database. 3599 * If the cursor is on the insert row, the method {@link #insertRow} 3600 * must be called, which will insert the new row into both this rowset 3601 * and the database. Both of these methods must be called before the 3602 * cursor moves to another row. 3603 * 3604 * @param columnIndex the first column is {@code 1}, the second 3605 * is {@code 2}, and so on; must be {@code 1} or larger 3606 * and equal to or less than the number of columns in this rowset 3607 * @param b the new column {@code Blob} value 3608 * @throws SQLException if (1) the given column index is out of bounds, 3609 * (2) the cursor is not on one of this rowset's rows or its 3610 * insert row, or (3) this rowset is 3611 * {@code ResultSet.CONCUR_READ_ONLY} 3612 */ 3613 public void updateBlob(int columnIndex, Blob b) throws SQLException { 3614 checkState(); 3615 rs.updateBlob(columnIndex, b); 3616 } 3617 3618 /** 3619 * Sets the designated column in either the current row or the insert 3620 * row of this {@code JdbcRowSetImpl} object with the given 3621 * {@code java.sql.Blob } value. 3622 * 3623 * This method updates a column value in either the current row or 3624 * the insert row of this rowset, but it does not update the 3625 * database. If the cursor is on a row in the rowset, the 3626 * method {@link #updateRow} must be called to update the database. 3627 * If the cursor is on the insert row, the method {@link #insertRow} 3628 * must be called, which will insert the new row into both this rowset 3629 * and the database. Both of these methods must be called before the 3630 * cursor moves to another row. 3631 * 3632 * @param columnName a {@code String} object that must match the 3633 * SQL name of a column in this rowset, ignoring case 3634 * @param b the new column {@code Blob} value 3635 * @throws SQLException if (1) the given column name does not match the 3636 * name of a column in this rowset, (2) the cursor is not on 3637 * one of this rowset's rows or its insert row, or (3) this 3638 * rowset is {@code ResultSet.CONCUR_READ_ONLY} 3639 */ 3640 public void updateBlob(String columnName, Blob b) throws SQLException { 3641 updateBlob(findColumn(columnName), b); 3642 } 3643 3644 /** 3645 * Sets the designated column in either the current row or the insert 3646 * row of this {@code JdbcRowSetImpl} object with the given 3647 * {@code java.sql.Array} values. 3648 * 3649 * This method updates a column value in either the current row or 3650 * the insert row of this rowset, but it does not update the 3651 * database. If the cursor is on a row in the rowset, the 3652 * method {@link #updateRow} must be called to update the database. 3653 * If the cursor is on the insert row, the method {@link #insertRow} 3654 * must be called, which will insert the new row into both this rowset 3655 * and the database. Both of these methods must be called before the 3656 * cursor moves to another row. 3657 * 3658 * @param columnIndex the first column is {@code 1}, the second 3659 * is {@code 2}, and so on; must be {@code 1} or larger 3660 * and equal to or less than the number of columns in this rowset 3661 * @param a the new column {@code Array} value 3662 * @throws SQLException if (1) the given column index is out of bounds, 3663 * (2) the cursor is not on one of this rowset's rows or its 3664 * insert row, or (3) this rowset is 3665 * {@code ResultSet.CONCUR_READ_ONLY} 3666 */ 3667 public void updateArray(int columnIndex, Array a) throws SQLException { 3668 checkState(); 3669 rs.updateArray(columnIndex, a); 3670 } 3671 3672 /** 3673 * Sets the designated column in either the current row or the insert 3674 * row of this {@code JdbcRowSetImpl} object with the given 3675 * {@code java.sql.Array} value. 3676 * 3677 * This method updates a column value in either the current row or 3678 * the insert row of this rowset, but it does not update the 3679 * database. If the cursor is on a row in the rowset, the 3680 * method {@link #updateRow} must be called to update the database. 3681 * If the cursor is on the insert row, the method {@link #insertRow} 3682 * must be called, which will insert the new row into both this rowset 3683 * and the database. Both of these methods must be called before the 3684 * cursor moves to another row. 3685 * 3686 * @param columnName a {@code String} object that must match the 3687 * SQL name of a column in this rowset, ignoring case 3688 * @param a the new column {@code Array} value 3689 * @throws SQLException if (1) the given column name does not match the 3690 * name of a column in this rowset, (2) the cursor is not on 3691 * one of this rowset's rows or its insert row, or (3) this 3692 * rowset is {@code ResultSet.CONCUR_READ_ONLY} 3693 */ 3694 public void updateArray(String columnName, Array a) throws SQLException { 3695 updateArray(findColumn(columnName), a); 3696 } 3697 3698 /** 3699 * Provide interface coverage for getURL(int) in {@code ResultSet->RowSet} 3700 */ 3701 public java.net.URL getURL(int columnIndex) throws SQLException { 3702 checkState(); 3703 return rs.getURL(columnIndex); 3704 } 3705 3706 /** 3707 * Provide interface coverage for getURL(String) in {@code ResultSet->RowSet} 3708 */ 3709 public java.net.URL getURL(String columnName) throws SQLException { 3710 return getURL(findColumn(columnName)); 3711 } 3712 3713 /** 3714 * Return the RowSetWarning object for the current row of a 3715 * {@code JdbcRowSetImpl} 3716 */ 3717 public RowSetWarning getRowSetWarnings() throws SQLException { 3718 return null; 3719 } 3720 /** 3721 * Unsets the designated parameter to the given int array. 3722 * This was set using {@code setMatchColumn} 3723 * as the column which will form the basis of the join. 3724 * <P> 3725 * The parameter value unset by this method should be same 3726 * as was set. 3727 * 3728 * @param columnIdxes the index into this rowset 3729 * object's internal representation of parameter values 3730 * @throws SQLException if an error occurs or the 3731 * parameter index is out of bounds or if the columnIdx is 3732 * not the same as set using {@code setMatchColumn(int [])} 3733 */ 3734 public void unsetMatchColumn(int[] columnIdxes) throws SQLException { 3735 3736 int i_val; 3737 for( int j= 0 ;j < columnIdxes.length; j++) { 3738 i_val = (Integer.parseInt(iMatchColumns.get(j).toString())); 3739 if(columnIdxes[j] != i_val) { 3740 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols").toString()); 3741 } 3742 } 3743 3744 for( int i = 0;i < columnIdxes.length ;i++) { 3745 iMatchColumns.set(i,Integer.valueOf(-1)); 3746 } 3747 } 3748 3749 /** 3750 * Unsets the designated parameter to the given String array. 3751 * This was set using {@code setMatchColumn} 3752 * as the column which will form the basis of the join. 3753 * <P> 3754 * The parameter value unset by this method should be same 3755 * as was set. 3756 * 3757 * @param columnIdxes the index into this rowset 3758 * object's internal representation of parameter values 3759 * @throws SQLException if an error occurs or the 3760 * parameter index is out of bounds or if the columnName is 3761 * not the same as set using {@code setMatchColumn(String [])} 3762 */ 3763 public void unsetMatchColumn(String[] columnIdxes) throws SQLException { 3764 3765 for(int j = 0 ;j < columnIdxes.length; j++) { 3766 if( !columnIdxes[j].equals(strMatchColumns.get(j)) ){ 3767 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols").toString()); 3768 } 3769 } 3770 3771 for(int i = 0 ; i < columnIdxes.length; i++) { 3772 strMatchColumns.set(i,null); 3773 } 3774 } 3775 3776 /** 3777 * Retrieves the column name as {@code String} array 3778 * that was set using {@code setMatchColumn(String [])} 3779 * for this rowset. 3780 * 3781 * @return a {@code String} array object that contains the column names 3782 * for the rowset which has this the match columns 3783 * 3784 * @throws SQLException if an error occurs or column name is not set 3785 */ 3786 public String[] getMatchColumnNames() throws SQLException { 3787 3788 String []str_temp = new String[strMatchColumns.size()]; 3789 3790 if( strMatchColumns.get(0) == null) { 3791 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.setmatchcols").toString()); 3792 } 3793 3794 strMatchColumns.copyInto(str_temp); 3795 return str_temp; 3796 } 3797 3798 /** 3799 * Retrieves the column id as {@code int} array that was set using 3800 * {@code setMatchColumn(int [])} for this rowset. 3801 * 3802 * @return a {@code int} array object that contains the column ids 3803 * for the rowset which has this as the match columns. 3804 * 3805 * @throws SQLException if an error occurs or column index is not set 3806 */ 3807 public int[] getMatchColumnIndexes() throws SQLException { 3808 3809 Integer []int_temp = new Integer[iMatchColumns.size()]; 3810 int [] i_temp = new int[iMatchColumns.size()]; 3811 int i_val; 3812 3813 i_val = iMatchColumns.get(0); 3814 3815 if( i_val == -1 ) { 3816 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.setmatchcols").toString()); 3817 } 3818 3819 3820 iMatchColumns.copyInto(int_temp); 3821 3822 for(int i = 0; i < int_temp.length; i++) { 3823 i_temp[i] = (int_temp[i]).intValue(); 3824 } 3825 3826 return i_temp; 3827 } 3828 3829 /** 3830 * Sets the designated parameter to the given int array. 3831 * This forms the basis of the join for the 3832 * {@code JoinRowSet} as the column which will form the basis of the 3833 * join. 3834 * <P> 3835 * The parameter value set by this method is stored internally and 3836 * will be supplied as the appropriate parameter in this rowset's 3837 * command when the method {@code getMatchColumnIndexes} is called. 3838 * 3839 * @param columnIdxes the indexes into this rowset 3840 * object's internal representation of parameter values; the 3841 * first parameter is 0, the second is 1, and so on; must be 3842 * {@code 0} or greater 3843 * @throws SQLException if an error occurs or the 3844 * parameter index is out of bounds 3845 */ 3846 public void setMatchColumn(int[] columnIdxes) throws SQLException { 3847 3848 for(int j = 0 ; j < columnIdxes.length; j++) { 3849 if( columnIdxes[j] < 0 ) { 3850 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols1").toString()); 3851 } 3852 } 3853 for(int i = 0 ;i < columnIdxes.length; i++) { 3854 iMatchColumns.add(i,Integer.valueOf(columnIdxes[i])); 3855 } 3856 } 3857 3858 /** 3859 * Sets the designated parameter to the given String array. 3860 * This forms the basis of the join for the 3861 * {@code JoinRowSet} as the column which will form the basis of the 3862 * join. 3863 * <P> 3864 * The parameter value set by this method is stored internally and 3865 * will be supplied as the appropriate parameter in this rowset's 3866 * command when the method {@code getMatchColumn} is called. 3867 * 3868 * @param columnNames the name of the column into this rowset 3869 * object's internal representation of parameter values 3870 * @throws SQLException if an error occurs or the 3871 * parameter index is out of bounds 3872 */ 3873 public void setMatchColumn(String[] columnNames) throws SQLException { 3874 3875 for(int j = 0; j < columnNames.length; j++) { 3876 if( columnNames[j] == null || columnNames[j].equals("")) { 3877 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols2").toString()); 3878 } 3879 } 3880 for( int i = 0; i < columnNames.length; i++) { 3881 strMatchColumns.add(i,columnNames[i]); 3882 } 3883 } 3884 3885 3886 /** 3887 * Sets the designated parameter to the given {@code int} 3888 * object. This forms the basis of the join for the 3889 * {@code JoinRowSet} as the column which will form the basis of the 3890 * join. 3891 * <P> 3892 * The parameter value set by this method is stored internally and 3893 * will be supplied as the appropriate parameter in this rowset's 3894 * command when the method {@code getMatchColumn} is called. 3895 * 3896 * @param columnIdx the index into this rowset 3897 * object's internal representation of parameter values; the 3898 * first parameter is 0, the second is 1, and so on; must be 3899 * {@code 0} or greater 3900 * @throws SQLException if an error occurs or the 3901 * parameter index is out of bounds 3902 */ 3903 public void setMatchColumn(int columnIdx) throws SQLException { 3904 // validate, if col is ok to be set 3905 if(columnIdx < 0) { 3906 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols1").toString()); 3907 } else { 3908 // set iMatchColumn 3909 iMatchColumns.set(0, Integer.valueOf(columnIdx)); 3910 //strMatchColumn = null; 3911 } 3912 } 3913 3914 /** 3915 * Sets the designated parameter to the given {@code String} 3916 * object. This forms the basis of the join for the 3917 * {@code JoinRowSet} as the column which will form the basis of the 3918 * join. 3919 * <P> 3920 * The parameter value set by this method is stored internally and 3921 * will be supplied as the appropriate parameter in this rowset's 3922 * command when the method {@code getMatchColumn} is called. 3923 * 3924 * @param columnName the name of the column into this rowset 3925 * object's internal representation of parameter values 3926 * @throws SQLException if an error occurs or the 3927 * parameter index is out of bounds 3928 */ 3929 public void setMatchColumn(String columnName) throws SQLException { 3930 // validate, if col is ok to be set 3931 if(columnName == null || (columnName= columnName.trim()).equals("")) { 3932 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols2").toString()); 3933 } else { 3934 // set strMatchColumn 3935 strMatchColumns.set(0, columnName); 3936 //iMatchColumn = -1; 3937 } 3938 } 3939 3940 /** 3941 * Unsets the designated parameter to the given {@code int} 3942 * object. This was set using {@code setMatchColumn} 3943 * as the column which will form the basis of the join. 3944 * <P> 3945 * The parameter value unset by this method should be same 3946 * as was set. 3947 * 3948 * @param columnIdx the index into this rowset 3949 * object's internal representation of parameter values 3950 * @throws SQLException if an error occurs or the 3951 * parameter index is out of bounds or if the columnIdx is 3952 * not the same as set using {@code setMatchColumn(int)} 3953 */ 3954 public void unsetMatchColumn(int columnIdx) throws SQLException { 3955 // check if we are unsetting the SAME column 3956 if(! iMatchColumns.get(0).equals(Integer.valueOf(columnIdx) ) ) { 3957 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.unsetmatch").toString()); 3958 } else if(strMatchColumns.get(0) != null) { 3959 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.usecolname").toString()); 3960 } else { 3961 // that is, we are unsetting it. 3962 iMatchColumns.set(0, Integer.valueOf(-1)); 3963 } 3964 } 3965 3966 /** 3967 * Unsets the designated parameter to the given {@code String} 3968 * object. This was set using {@code setMatchColumn} 3969 * as the column which will form the basis of the join. 3970 * <P> 3971 * The parameter value unset by this method should be same 3972 * as was set. 3973 * 3974 * @param columnName the index into this rowset 3975 * object's internal representation of parameter values 3976 * @throws SQLException if an error occurs or the 3977 * parameter index is out of bounds or if the columnName is 3978 * not the same as set using {@code setMatchColumn(String)} 3979 * 3980 */ 3981 public void unsetMatchColumn(String columnName) throws SQLException { 3982 // check if we are unsetting the same column 3983 columnName = columnName.trim(); 3984 3985 if(!((strMatchColumns.get(0)).equals(columnName))) { 3986 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.unsetmatch").toString()); 3987 } else if(iMatchColumns.get(0) > 0) { 3988 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.usecolid").toString()); 3989 } else { 3990 strMatchColumns.set(0, null); // that is, we are unsetting it. 3991 } 3992 } 3993 3994 /** 3995 * Retrieves the {@code DatabaseMetaData} associated with 3996 * the connection handle associated with this 3997 * {@code JdbcRowSet} object. 3998 * 3999 * @return the {@code DatabaseMetadata} associated 4000 * with the rowset's connection. 4001 * @throws SQLException if a database access error occurs 4002 */ 4003 public DatabaseMetaData getDatabaseMetaData() throws SQLException { 4004 Connection con = connect(); 4005 return con.getMetaData(); 4006 } 4007 4008 /** 4009 * Retrieves the {@code ParameterMetaData} associated with 4010 * the connection handle associated with this 4011 * {@code JdbcRowSet} object. 4012 * 4013 * @return the {@code ParameterMetadata} associated 4014 * with the rowset's connection. 4015 * @throws SQLException if a database access error occurs 4016 */ 4017 public ParameterMetaData getParameterMetaData() throws SQLException { 4018 prepare(); 4019 return (ps.getParameterMetaData()); 4020 } 4021 4022 /** 4023 * Commits all updates in this {@code JdbcRowSet} object by 4024 * wrapping the internal {@code Connection} object and calling 4025 * its {@code commit} method. 4026 * This method sets this {@code JdbcRowSet} object's private field 4027 * {@code rs} to {@code null} after saving its value to another 4028 * object, but only if the {@code ResultSet} 4029 * constant {@code HOLD_CURSORS_OVER_COMMIT} has not been set. 4030 * (The field {@code rs} is this {@code JdbcRowSet} object's 4031 * {@code ResultSet} object.) 4032 * 4033 * @throws SQLException if autoCommit is set to true or if a database 4034 * access error occurs 4035 */ 4036 public void commit() throws SQLException { 4037 conn.commit(); 4038 4039 // Checking the holadbility value and making the result set handle null 4040 // Added as per Rave requirements 4041 4042 if( conn.getHoldability() != HOLD_CURSORS_OVER_COMMIT) { 4043 rs = null; 4044 } 4045 } 4046 4047 /** 4048 * Sets auto-commit on the internal {@code Connection} object with this 4049 * {@code JdbcRowSet} 4050 * 4051 * @throws SQLException if a database access error occurs 4052 */ 4053 public void setAutoCommit(boolean autoCommit) throws SQLException { 4054 // The connection object should be there 4055 // in order to commit the connection handle on or off. 4056 4057 if(conn != null) { 4058 conn.setAutoCommit(autoCommit); 4059 } else { 4060 // Coming here means the connection object is null. 4061 // So generate a connection handle internally, since 4062 // a JdbcRowSet is always connected to a db, it is fine 4063 // to get a handle to the connection. 4064 4065 // Get hold of a connection handle 4066 // and change the autcommit as passesd. 4067 conn = connect(); 4068 4069 // After setting the below the conn.getAutoCommit() 4070 // should return the same value. 4071 conn.setAutoCommit(autoCommit); 4072 4073 } 4074 } 4075 4076 /** 4077 * Returns the auto-commit status with this {@code JdbcRowSet}. 4078 * 4079 * @return true if auto commit is true; false otherwise 4080 * @throws SQLException if a database access error occurs 4081 */ 4082 public boolean getAutoCommit() throws SQLException { 4083 return conn.getAutoCommit(); 4084 } 4085 4086 /** 4087 * Rolls back all the updates in this {@code JdbcRowSet} object by 4088 * wrapping the internal {@code Connection} object and calling its 4089 * {@code rollback} method. 4090 * This method sets this {@code JdbcRowSet} object's private field 4091 * {@code rs} to {@code null} after saving its value to another object. 4092 * (The field {@code rs} is this {@code JdbcRowSet} object's 4093 * internal {@code ResultSet} object.) 4094 * 4095 * @throws SQLException if autoCommit is set to true or a database 4096 * access error occurs 4097 */ 4098 public void rollback() throws SQLException { 4099 conn.rollback(); 4100 4101 // Makes the result ste handle null after rollback 4102 // Added as per Rave requirements 4103 4104 rs = null; 4105 } 4106 4107 4108 /** 4109 * Rollbacks all the updates in the {@code JdbcRowSet} back to the 4110 * last {@code Savepoint} transaction marker. Wraps the internal 4111 * {@code Connection} object and call it's rollback method 4112 * 4113 * @param s the {@code Savepoint} transaction marker to roll the 4114 * transaction to. 4115 * @throws SQLException if autoCommit is set to true; or ia a database 4116 * access error occurs 4117 */ 4118 public void rollback(Savepoint s) throws SQLException { 4119 conn.rollback(s); 4120 } 4121 4122 // Setting the ResultSet Type and Concurrency 4123 protected void setParams() throws SQLException { 4124 if(rs == null) { 4125 setType(ResultSet.TYPE_SCROLL_INSENSITIVE); 4126 setConcurrency(ResultSet.CONCUR_UPDATABLE); 4127 } 4128 else { 4129 setType(rs.getType()); 4130 setConcurrency(rs.getConcurrency()); 4131 } 4132 } 4133 4134 4135 // Checking ResultSet Type and Concurrency 4136 private void checkTypeConcurrency() throws SQLException { 4137 if(rs.getType() == TYPE_FORWARD_ONLY || 4138 rs.getConcurrency() == CONCUR_READ_ONLY) { 4139 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.resnotupd").toString()); 4140 } 4141 } 4142 4143 // Returns a Connection Handle 4144 // Added as per Rave requirements 4145 4146 /** 4147 * Gets this {@code JdbcRowSet} object's Connection property 4148 * 4149 * 4150 * @return the {@code Connection} object associated with this rowset; 4151 */ 4152 4153 protected Connection getConnection() { 4154 return conn; 4155 } 4156 4157 // Sets the connection handle with the parameter 4158 // Added as per rave requirements 4159 4160 /** 4161 * Sets this {@code JdbcRowSet} object's connection property 4162 * to the given {@code Connection} object. 4163 * 4164 * @param connection the {@code Connection} object. 4165 */ 4166 4167 protected void setConnection(Connection connection) { 4168 conn = connection; 4169 } 4170 4171 // Returns a PreparedStatement Handle 4172 // Added as per Rave requirements 4173 4174 /** 4175 * Gets this {@code JdbcRowSet} object's PreparedStatement property 4176 * 4177 * 4178 * @return the {@code PreparedStatement} object associated with this rowset; 4179 */ 4180 4181 protected PreparedStatement getPreparedStatement() { 4182 return ps; 4183 } 4184 4185 //Sets the prepared statement handle to the parameter 4186 // Added as per Rave requirements 4187 4188 /** 4189 * Sets this {@code JdbcRowSet} object's preparedtsatement property 4190 * to the given {@code PreparedStatemennt} object. 4191 * 4192 * @param preparedStatement the {@code PreparedStatement} object 4193 * 4194 */ 4195 protected void setPreparedStatement(PreparedStatement preparedStatement) { 4196 ps = preparedStatement; 4197 } 4198 4199 // Returns a ResultSet handle 4200 // Added as per Rave requirements 4201 4202 /** 4203 * Gets this {@code JdbcRowSet} object's ResultSet property 4204 * 4205 * 4206 * @return the {@code ResultSet} object associated with this rowset; 4207 */ 4208 4209 protected ResultSet getResultSet() throws SQLException { 4210 4211 checkState(); 4212 4213 return rs; 4214 } 4215 4216 // Sets the result set handle to the parameter 4217 // Added as per Rave requirements 4218 4219 /** 4220 * Sets this {@code JdbcRowSet} object's resultset property 4221 * to the given {@code ResultSet} object. 4222 * 4223 * @param resultSet the {@code ResultSet} object 4224 * 4225 */ 4226 protected void setResultSet(ResultSet resultSet) { 4227 rs = resultSet; 4228 } 4229 4230 /** 4231 * Sets this {@code JdbcRowSet} object's {@code command} property to 4232 * the given {@code String} object and clears the parameters, if any, 4233 * that were set for the previous command. In addition, 4234 * if the {@code command} property has previously been set to a 4235 * non-null value and it is 4236 * different from the {@code String} object supplied, 4237 * this method sets this {@code JdbcRowSet} object's private fields 4238 * {@code ps} and {@code rs} to {@code null}. 4239 * (The field {@code ps} is its {@code PreparedStatement} object, and 4240 * the field {@code rs} is its {@code ResultSet} object.) 4241 * <P> 4242 * The {@code command} property may not be needed if the {@code RowSet} 4243 * object gets its data from a source that does not support commands, 4244 * such as a spreadsheet or other tabular file. 4245 * Thus, this property is optional and may be {@code null}. 4246 * 4247 * @param command a {@code String} object containing an SQL query 4248 * that will be set as this {@code RowSet} object's command 4249 * property; may be {@code null} but may not be an empty string 4250 * @throws SQLException if an empty string is provided as the command value 4251 * @see #getCommand 4252 */ 4253 public void setCommand(String command) throws SQLException { 4254 4255 if (getCommand() != null) { 4256 if(!getCommand().equals(command)) { 4257 super.setCommand(command); 4258 ps = null; 4259 rs = null; 4260 } 4261 } 4262 else { 4263 super.setCommand(command); 4264 } 4265 } 4266 4267 /** 4268 * Sets the {@code dataSourceName} property for this {@code JdbcRowSet} 4269 * object to the given logical name and sets this {@code JdbcRowSet} object's 4270 * Url property to {@code null}. In addition, if the {@code dataSourceName} 4271 * property has previously been set and is different from the one supplied, 4272 * this method sets this {@code JdbcRowSet} object's private fields 4273 * {@code ps}, {@code rs}, and {@code conn} to {@code null}. 4274 * (The field {@code ps} is its {@code PreparedStatement} object, 4275 * the field {@code rs} is its {@code ResultSet} object, and 4276 * the field {@code conn} is its {@code Connection} object.) 4277 * <P> 4278 * The name supplied to this method must have been bound to a 4279 * {@code DataSource} object in a JNDI naming service so that an 4280 * application can do a lookup using that name to retrieve the 4281 * {@code DataSource} object bound to it. The {@code DataSource} 4282 * object can then be used to establish a connection to the data source it 4283 * represents. 4284 * <P> 4285 * Users should set either the Url property or the dataSourceName property. 4286 * If both properties are set, the driver will use the property set most recently. 4287 * 4288 * @param dsName a {@code String} object with the name that can be supplied 4289 * to a naming service based on JNDI technology to retrieve the 4290 * {@code DataSource} object that can be used to get a connection; 4291 * may be {@code null} 4292 * @throws SQLException if there is a problem setting the 4293 * {@code dataSourceName} property 4294 * @see #getDataSourceName 4295 */ 4296 public void setDataSourceName(String dsName) throws SQLException{ 4297 4298 if(getDataSourceName() != null) { 4299 if(!getDataSourceName().equals(dsName)) { 4300 super.setDataSourceName(dsName); 4301 conn = null; 4302 ps = null; 4303 rs = null; 4304 } 4305 } 4306 else { 4307 super.setDataSourceName(dsName); 4308 } 4309 } 4310 4311 4312 /** 4313 * Sets the Url property for this {@code JdbcRowSet} object 4314 * to the given {@code String} object and sets the dataSource name 4315 * property to {@code null}. In addition, if the Url property has 4316 * previously been set to a non {@code null} value and its value 4317 * is different from the value to be set, 4318 * this method sets this {@code JdbcRowSet} object's private fields 4319 * {@code ps}, {@code rs}, and {@code conn} to {@code null}. 4320 * (The field {@code ps} is its {@code PreparedStatement} object, 4321 * the field {@code rs} is its {@code ResultSet} object, and 4322 * the field {@code conn} is its {@code Connection} object.) 4323 * <P> 4324 * The Url property is a JDBC URL that is used when 4325 * the connection is created using a JDBC technology-enabled driver 4326 * ("JDBC driver") and the {@code DriverManager}. 4327 * The correct JDBC URL for the specific driver to be used can be found 4328 * in the driver documentation. Although there are guidelines for how 4329 * a JDBC URL is formed, 4330 * a driver vendor can specify any {@code String} object except 4331 * one with a length of {@code 0} (an empty string). 4332 * <P> 4333 * Setting the Url property is optional if connections are established using 4334 * a {@code DataSource} object instead of the {@code DriverManager}. 4335 * The driver will use either the URL property or the 4336 * dataSourceName property to create a connection, whichever was 4337 * specified most recently. If an application uses a JDBC URL, it 4338 * must load a JDBC driver that accepts the JDBC URL before it uses the 4339 * {@code RowSet} object to connect to a database. The {@code RowSet} 4340 * object will use the URL internally to create a database connection in order 4341 * to read or write data. 4342 * 4343 * @param url a {@code String} object that contains the JDBC URL 4344 * that will be used to establish the connection to a database for this 4345 * {@code RowSet} object; may be {@code null} but must not 4346 * be an empty string 4347 * @throws SQLException if an error occurs setting the Url property or the 4348 * parameter supplied is a string with a length of {@code 0} (an 4349 * empty string) 4350 * @see #getUrl 4351 */ 4352 4353 public void setUrl(String url) throws SQLException { 4354 4355 if(getUrl() != null) { 4356 if(!getUrl().equals(url)) { 4357 super.setUrl(url); 4358 conn = null; 4359 ps = null; 4360 rs = null; 4361 } 4362 } 4363 else { 4364 super.setUrl(url); 4365 } 4366 } 4367 4368 /** 4369 * Sets the username property for this {@code JdbcRowSet} object 4370 * to the given user name. Because it 4371 * is not serialized, the username property is set at run time before 4372 * calling the method {@code execute}. In addition, 4373 * if the {@code username} property is already set with a 4374 * non-null value and that value is different from the {@code String} 4375 * object to be set, 4376 * this method sets this {@code JdbcRowSet} object's private fields 4377 * {@code ps}, {@code rs}, and {@code conn} to {@code null}. 4378 * (The field {@code ps} is its {@code PreparedStatement} object, 4379 * {@code rs} is its {@code ResultSet} object, and 4380 * {@code conn} is its {@code Connection} object.) 4381 * Setting these fields to {@code null} ensures that only current 4382 * values will be used. 4383 * 4384 * @param uname the {@code String} object containing the user name that 4385 * is supplied to the data source to create a connection. It may be null. 4386 * @see #getUsername 4387 */ 4388 public void setUsername(String uname) { 4389 4390 if( getUsername() != null) { 4391 if(!getUsername().equals(uname)) { 4392 super.setUsername(uname); 4393 conn = null; 4394 ps = null; 4395 rs = null; 4396 } 4397 } 4398 else{ 4399 super.setUsername(uname); 4400 } 4401 } 4402 4403 /** 4404 * Sets the password property for this {@code JdbcRowSet} object 4405 * to the given {@code String} object. Because it 4406 * is not serialized, the password property is set at run time before 4407 * calling the method {@code execute}. Its default valus is 4408 * {@code null}. In addition, 4409 * if the {@code password} property is already set with a 4410 * non-null value and that value is different from the one being set, 4411 * this method sets this {@code JdbcRowSet} object's private fields 4412 * {@code ps}, {@code rs}, and {@code conn} to {@code null}. 4413 * (The field {@code ps} is its {@code PreparedStatement} object, 4414 * {@code rs} is its {@code ResultSet} object, and 4415 * {@code conn} is its {@code Connection} object.) 4416 * Setting these fields to {@code null} ensures that only current 4417 * values will be used. 4418 * 4419 * @param password the {@code String} object that represents the password 4420 * that must be supplied to the database to create a connection 4421 */ 4422 public void setPassword(String password) { 4423 4424 if ( getPassword() != null) { 4425 if(!getPassword().equals(password)) { 4426 super.setPassword(password); 4427 conn = null; 4428 ps = null; 4429 rs = null; 4430 } 4431 } 4432 else{ 4433 super.setPassword(password); 4434 } 4435 } 4436 4437 /** 4438 * Sets the type for this {@code RowSet} object to the specified type. 4439 * The default type is {@code ResultSet.TYPE_SCROLL_INSENSITIVE}. 4440 * 4441 * @param type one of the following constants: 4442 * {@code ResultSet.TYPE_FORWARD_ONLY}, 4443 * {@code ResultSet.TYPE_SCROLL_INSENSITIVE}, or 4444 * {@code ResultSet.TYPE_SCROLL_SENSITIVE} 4445 * @throws SQLException if the parameter supplied is not one of the 4446 * following constants: 4447 * {@code ResultSet.TYPE_FORWARD_ONLY} or 4448 * {@code ResultSet.TYPE_SCROLL_INSENSITIVE} 4449 * {@code ResultSet.TYPE_SCROLL_SENSITIVE} 4450 * @see #getConcurrency 4451 * @see #getType 4452 */ 4453 4454 public void setType(int type) throws SQLException { 4455 4456 int oldVal; 4457 4458 try { 4459 oldVal = getType(); 4460 }catch(SQLException ex) { 4461 oldVal = 0; 4462 } 4463 4464 if(oldVal != type) { 4465 super.setType(type); 4466 } 4467 4468 } 4469 4470 /** 4471 * Sets the concurrency for this {@code RowSet} object to 4472 * the specified concurrency. The default concurrency for any {@code RowSet} 4473 * object (connected or disconnected) is {@code ResultSet.CONCUR_UPDATABLE}, 4474 * but this method may be called at any time to change the concurrency. 4475 * 4476 * @param concur one of the following constants: 4477 * {@code ResultSet.CONCUR_READ_ONLY} or 4478 * {@code ResultSet.CONCUR_UPDATABLE} 4479 * @throws SQLException if the parameter supplied is not one of the 4480 * following constants: 4481 * {@code ResultSet.CONCUR_UPDATABLE} or 4482 * {@code ResultSet.CONCUR_READ_ONLY} 4483 * @see #getConcurrency 4484 * @see #isReadOnly 4485 */ 4486 public void setConcurrency(int concur) throws SQLException { 4487 4488 int oldVal; 4489 4490 try { 4491 oldVal = getConcurrency(); 4492 }catch(NullPointerException ex) { 4493 oldVal = 0; 4494 } 4495 4496 if(oldVal != concur) { 4497 super.setConcurrency(concur); 4498 } 4499 4500 } 4501 4502 /** 4503 * Retrieves the value of the designated {@code SQL XML} parameter as a 4504 * {@code SQLXML} object in the Java programming language. 4505 * @param columnIndex the first column is 1, the second is 2, ... 4506 * @return a SQLXML object that maps an SQL XML value 4507 * @throws SQLException if a database access error occurs 4508 * @since 1.6 4509 */ 4510 public SQLXML getSQLXML(int columnIndex) throws SQLException { 4511 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4512 } 4513 4514 /** 4515 * Retrieves the value of the designated {@code SQL XML} parameter as a 4516 * {@code SQLXML} object in the Java programming language. 4517 * @param colName the name of the column from which to retrieve the value 4518 * @return a SQLXML object that maps an SQL XML value 4519 * @throws SQLException if a database access error occurs 4520 */ 4521 public SQLXML getSQLXML(String colName) throws SQLException { 4522 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4523 } 4524 4525 /** 4526 * Retrieves the value of the designated column in the current row of this 4527 * {@code ResultSet} object as a java.sql.RowId object in the Java 4528 * programming language. 4529 * 4530 * @param columnIndex the first column is 1, the second 2, ... 4531 * @return the column value if the value is a SQL {@code NULL} the 4532 * value returned is {@code null} 4533 * @throws SQLException if a database access error occurs 4534 * @since 1.6 4535 */ 4536 public RowId getRowId(int columnIndex) throws SQLException { 4537 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4538 } 4539 4540 /** 4541 * Retrieves the value of the designated column in the current row of this 4542 * {@code ResultSet} object as a java.sql.RowId object in the Java 4543 * programming language. 4544 * 4545 * @param columnName the name of the column 4546 * @return the column value if the value is a SQL {@code NULL} the 4547 * value returned is {@code null} 4548 * @throws SQLException if a database access error occurs 4549 * @since 1.6 4550 */ 4551 public RowId getRowId(String columnName) throws SQLException { 4552 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4553 } 4554 4555 /** 4556 * Updates the designated column with a {@code RowId} value. The updater 4557 * methods are used to update column values in the current row or the insert 4558 * row. The updater methods do not update the underlying database; instead 4559 * the {@code updateRow} or {@code insertRow} methods are called 4560 * to update the database. 4561 * 4562 * @param columnIndex the first column is 1, the second 2, ... 4563 * @param x the column value 4564 * @throws SQLException if a database access occurs 4565 * @since 1.6 4566 */ 4567 public void updateRowId(int columnIndex, RowId x) throws SQLException { 4568 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4569 } 4570 4571 /** 4572 * Updates the designated column with a {@code RowId} value. The updater 4573 * methods are used to update column values in the current row or the insert 4574 * row. The updater methods do not update the underlying database; instead 4575 * the {@code updateRow} or {@code insertRow} methods are called 4576 * to update the database. 4577 * 4578 * @param columnName the name of the column 4579 * @param x the column value 4580 * @throws SQLException if a database access occurs 4581 * @since 1.6 4582 */ 4583 public void updateRowId(String columnName, RowId x) throws SQLException { 4584 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4585 } 4586 4587 /** 4588 * Retrieves the holdability of this ResultSet object 4589 * @return either ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT 4590 * @throws SQLException if a database error occurs 4591 * @since 1.6 4592 */ 4593 public int getHoldability() throws SQLException { 4594 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4595 } 4614 * @since 1.6 4615 */ 4616 public void updateNString(int columnIndex, String nString) throws SQLException { 4617 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4618 } 4619 4620 /** 4621 * This method is used for updating columns that support National Character sets. 4622 * It can be used for updating NCHAR,NVARCHAR and LONGNVARCHAR columns. 4623 * @param columnName name of the Column 4624 * @param nString the value for the column to be updated 4625 * @throws SQLException if a database access error occurs 4626 * @since 1.6 4627 */ 4628 public void updateNString(String columnName, String nString) throws SQLException { 4629 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4630 } 4631 4632 4633 /*o 4634 * This method is used for updating SQL {@code NCLOB} type that maps 4635 * to {@code java.sql.Types.NCLOB} 4636 * @param columnIndex the first column is 1, the second 2, ... 4637 * @param nClob the value for the column to be updated 4638 * @throws SQLException if a database access error occurs 4639 * @since 1.6 4640 */ 4641 public void updateNClob(int columnIndex, NClob nClob) throws SQLException { 4642 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4643 } 4644 4645 /** 4646 * This method is used for updating SQL {@code NCLOB} type that maps 4647 * to {@code java.sql.Types.NCLOB} 4648 * @param columnName name of the column 4649 * @param nClob the value for the column to be updated 4650 * @throws SQLException if a database access error occurs 4651 * @since 1.6 4652 */ 4653 public void updateNClob(String columnName, NClob nClob) throws SQLException { 4654 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4655 } 4656 4657 /** 4658 * Retrieves the value of the designated column in the current row 4659 * of this {@code ResultSet} object as a {@code NClob} object 4660 * in the Java programming language. 4661 * 4662 * @param i the first column is 1, the second is 2, ... 4663 * @return a {@code NClob} object representing the SQL 4664 * {@code NCLOB} value in the specified column 4665 * @exception SQLException if a database access error occurs 4666 * @since 1.6 4667 */ 4668 public NClob getNClob(int i) throws SQLException { 4669 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4670 } 4671 4672 4673 /** 4674 * Retrieves the value of the designated column in the current row 4675 * of this {@code ResultSet} object as a {@code NClob} object 4676 * in the Java programming language. 4677 * 4678 * @param colName the name of the column from which to retrieve the value 4679 * @return a {@code NClob} object representing the SQL {@code NCLOB} 4680 * value in the specified column 4681 * @exception SQLException if a database access error occurs 4682 * @since 1.6 4683 */ 4684 public NClob getNClob(String colName) throws SQLException { 4685 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4686 } 4687 4688 public <T> T unwrap(java.lang.Class<T> iface) throws java.sql.SQLException{ 4689 return null; 4690 } 4691 4692 public boolean isWrapperFor(Class<?> interfaces) throws SQLException { 4693 return false; 4694 } 4695 4696 /** 4697 * Sets the designated parameter to the given {@code java.sql.SQLXML} object. The driver converts this to an 4698 * SQL {@code XML} value when it sends it to the database. 4699 * @param parameterIndex index of the first parameter is 1, the second is 2, ... 4700 * @param xmlObject a {@code SQLXML} object that maps an SQL {@code XML} value 4701 * @throws SQLException if a database access error occurs 4702 * @since 1.6 4703 */ 4704 public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException { 4705 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4706 } 4707 4708 /** 4709 * Sets the designated parameter to the given {@code java.sql.SQLXML} object. The driver converts this to an 4710 * {@code SQL XML} value when it sends it to the database. 4711 * @param parameterName the name of the parameter 4712 * @param xmlObject a {@code SQLXML} object that maps an {@code SQL XML} value 4713 * @throws SQLException if a database access error occurs 4714 * @since 1.6 4715 */ 4716 public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException { 4717 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4718 } 4719 4720 /** 4721 * Sets the designated parameter to the given {@code java.sql.RowId} object. The 4722 * driver converts this to a SQL {@code ROWID} value when it sends it 4723 * to the database 4724 * 4725 * @param parameterIndex the first parameter is 1, the second is 2, ... 4726 * @param x the parameter value 4727 * @throws SQLException if a database access error occurs 4728 * 4729 * @since 1.6 4730 */ 4731 public void setRowId(int parameterIndex, RowId x) throws SQLException { 4732 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4733 } 4734 4735 /** 4736 * Sets the designated parameter to the given {@code java.sql.RowId} object. The 4737 * driver converts this to a SQL {@code ROWID} when it sends it to the 4738 * database. 4739 * 4740 * @param parameterName the name of the parameter 4741 * @param x the parameter value 4742 * @throws SQLException if a database access error occurs 4743 * @since 1.6 4744 */ 4745 public void setRowId(String parameterName, RowId x) throws SQLException { 4746 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4747 } 4748 4749 4750 /** 4751 * Sets the designated parameter to the given {@code String} object. 4752 * The driver converts this to a SQL {@code NCHAR} or 4753 * {@code NVARCHAR} or {@code LONGNVARCHAR} value 4754 * (depending on the argument's 4755 * size relative to the driver's limits on {@code NVARCHAR} values) 4756 * when it sends it to the database. 4757 * 4758 * @param parameterIndex of the first parameter is 1, the second is 2, ... 4759 * @param value the parameter value 4760 * @throws SQLException if the driver does not support national 4761 * character sets; if the driver can detect that a data conversion 4762 * error could occur ; or if a database access error occurs 4763 * @since 1.6 4764 */ 4765 public void setNString(int parameterIndex, String value) throws SQLException { 4766 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4767 } 4768 4769 4770 /** 4771 * Sets the designated parameter in this {@code RowSet} object's command 4772 * to a {@code Reader} object. The 4773 * {@code Reader} reads the data till end-of-file is reached. The 4774 * driver does the necessary conversion from Java character format to 4775 * the national character set in the database. 4776 4777 * <P><B>Note:</B> This stream object can either be a standard 4778 * Java stream object or your own subclass that implements the 4779 * standard interface. 4780 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 4781 * it might be more efficient to use a version of 4782 * {@code setNCharacterStream} which takes a length parameter. 4783 * 4784 * @param parameterIndex of the first parameter is 1, the second is 2, ... 4785 * @param value the parameter value 4786 * @throws SQLException if the driver does not support national 4787 * character sets; if the driver can detect that a data conversion 4788 * error could occur ; if a database access error occurs; or 4789 * this method is called on a closed {@code PreparedStatement} 4790 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 4791 * @since 1.6 4792 */ 4793 public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException { 4794 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4795 } 4796 4797 /** 4798 * Sets the designated parameter to a {@code java.sql.NClob} object. The object 4799 * implements the {@code java.sql.NClob} interface. This {@code NClob} 4800 * object maps to a SQL {@code NCLOB}. 4801 * @param parameterName the name of the column to be set 4802 * @param value the parameter value 4803 * @throws SQLException if the driver does not support national 4804 * character sets; if the driver can detect that a data conversion 4805 * error could occur; or if a database access error occurs 4806 * @since 1.6 4807 */ 4808 public void setNClob(String parameterName, NClob value) throws SQLException { 4809 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4810 } 4811 4812 4813 /** 4814 * Retrieves the value of the designated column in the current row 4815 * of this {@code ResultSet} object as a 4816 * {@code java.io.Reader} object. 4817 * It is intended for use when 4818 * accessing {@code NCHAR},{@code NVARCHAR} 4819 * and {@code LONGNVARCHAR} columns. 4820 * 4821 * @return a {@code java.io.Reader} object that contains the column 4822 * value; if the value is SQL {@code NULL}, the value returned is 4823 * {@code null} in the Java programming language. 4824 * @param columnIndex the first column is 1, the second is 2, ... 4825 * @exception SQLException if a database access error occurs 4826 * @since 1.6 4827 */ 4828 public java.io.Reader getNCharacterStream(int columnIndex) throws SQLException { 4829 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4830 } 4831 4832 4833 /** 4834 * Retrieves the value of the designated column in the current row 4835 * of this {@code ResultSet} object as a 4836 * {@code java.io.Reader} object. 4837 * It is intended for use when 4838 * accessing {@code NCHAR},{@code NVARCHAR} 4839 * and {@code LONGNVARCHAR} columns. 4840 * 4841 * @param columnName the name of the column 4842 * @return a {@code java.io.Reader} object that contains the column 4843 * value; if the value is SQL {@code NULL}, the value returned is 4844 * {@code null} in the Java programming language 4845 * @exception SQLException if a database access error occurs 4846 * @since 1.6 4847 */ 4848 public java.io.Reader getNCharacterStream(String columnName) throws SQLException { 4849 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4850 } 4851 4852 /** 4853 * Updates the designated column with a {@code java.sql.SQLXML} value. 4854 * The updater 4855 * methods are used to update column values in the current row or the insert 4856 * row. The updater methods do not update the underlying database; instead 4857 * the {@code updateRow} or {@code insertRow} methods are called 4858 * to update the database. 4859 * @param columnIndex the first column is 1, the second 2, ... 4860 * @param xmlObject the value for the column to be updated 4861 * @throws SQLException if a database access error occurs 4862 * @since 1.6 4863 */ 4864 public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException { 4865 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4866 } 4867 4868 /** 4869 * Updates the designated column with a {@code java.sql.SQLXML} value. 4870 * The updater 4871 * methods are used to update column values in the current row or the insert 4872 * row. The updater methods do not update the underlying database; instead 4873 * the {@code updateRow} or {@code insertRow} methods are called 4874 * to update the database. 4875 * 4876 * @param columnName the name of the column 4877 * @param xmlObject the column value 4878 * @throws SQLException if a database access occurs 4879 * @since 1.6 4880 */ 4881 public void updateSQLXML(String columnName, SQLXML xmlObject) throws SQLException { 4882 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4883 } 4884 4885 /** 4886 * Retrieves the value of the designated column in the current row 4887 * of this {@code ResultSet} object as 4888 * a {@code String} in the Java programming language. 4889 * It is intended for use when 4890 * accessing {@code NCHAR},{@code NVARCHAR} 4891 * and {@code LONGNVARCHAR} columns. 4892 * 4893 * @param columnIndex the first column is 1, the second is 2, ... 4894 * @return the column value; if the value is SQL {@code NULL}, the 4895 * value returned is {@code null} 4896 * @exception SQLException if a database access error occurs 4897 * @since 1.6 4898 */ 4899 public String getNString(int columnIndex) throws SQLException { 4900 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4901 } 4902 4903 /** 4904 * Retrieves the value of the designated column in the current row 4905 * of this {@code ResultSet} object as 4906 * a {@code String} in the Java programming language. 4907 * It is intended for use when 4908 * accessing {@code NCHAR},{@code NVARCHAR} 4909 * and {@code LONGNVARCHAR} columns. 4910 * 4911 * @param columnName the SQL name of the column 4912 * @return the column value; if the value is SQL {@code NULL}, the 4913 * value returned is {@code null} 4914 * @exception SQLException if a database access error occurs 4915 * @since 1.6 4916 */ 4917 public String getNString(String columnName) throws SQLException { 4918 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4919 } 4920 4921 /** 4922 * Updates the designated column with a character stream value, which will 4923 * have the specified number of bytes. The driver does the necessary conversion 4924 * from Java character format to the national character set in the database. 4925 * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns. 4926 * The updater methods are used to update column values in the current row or 4927 * the insert row. The updater methods do not update the underlying database; 4928 * instead the updateRow or insertRow methods are called to update the database. 4929 * 4930 * @param columnIndex the first column is 1, the second is 2, ... 4931 * @param x the new column value 4932 * @param length the length of the stream 4933 * @exception SQLException if a database access error occurs 4934 * @since 1.6 4935 */ 4936 public void updateNCharacterStream(int columnIndex, 4937 java.io.Reader x, 4938 long length) 4939 throws SQLException { 4940 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4941 } 4942 4943 /** 4944 * Updates the designated column with a character stream value, which will 4945 * have the specified number of bytes. The driver does the necessary conversion 4946 * from Java character format to the national character set in the database. 4947 * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns. 4948 * The updater methods are used to update column values in the current row or 4949 * the insert row. The updater methods do not update the underlying database; 4950 * instead the updateRow or insertRow methods are called to update the database. 4951 * 4952 * @param columnName name of the Column 4953 * @param x the new column value 4954 * @param length the length of the stream 4955 * @exception SQLException if a database access error occurs 4956 * @since 1.6 4957 */ 4958 public void updateNCharacterStream(String columnName, 4959 java.io.Reader x, 4960 long length) 4961 throws SQLException { 4962 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4963 } 4964 4965 /** 4966 * Updates the designated column with a character stream value. The 4967 * driver does the necessary conversion from Java character format to 4968 * the national character set in the database. 4969 * It is intended for use when 4970 * updating {@code NCHAR},{@code NVARCHAR} 4971 * and {@code LONGNVARCHAR} columns. 4972 * 4973 * The updater methods are used to update column values in the 4974 * current row or the insert row. The updater methods do not 4975 * update the underlying database; instead the {@code updateRow} or 4976 * {@code insertRow} methods are called to update the database. 4977 * 4978 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 4979 * it might be more efficient to use a version of 4980 * {@code updateNCharacterStream} which takes a length parameter. 4981 * 4982 * @param columnIndex the first column is 1, the second is 2, ... 4983 * @param x the new column value 4984 * @exception SQLException if a database access error occurs, 4985 * the result set concurrency is {@code CONCUR_READ_ONLY} or this 4986 * method is called on a closed result set 4987 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 4988 * this method 4989 * @since 1.6 4990 */ 4991 public void updateNCharacterStream(int columnIndex, 4992 java.io.Reader x) throws SQLException { 4993 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 4994 } 4995 4996 /** 4997 * Updates the designated column with a character stream value. The 4998 * driver does the necessary conversion from Java character format to 4999 * the national character set in the database. 5000 * It is intended for use when 5001 * updating {@code NCHAR},{@code NVARCHAR} 5002 * and {@code LONGNVARCHAR} columns. 5003 * 5004 * The updater methods are used to update column values in the 5005 * current row or the insert row. The updater methods do not 5006 * update the underlying database; instead the {@code updateRow} or 5007 * {@code insertRow} methods are called to update the database. 5008 * 5009 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5010 * it might be more efficient to use a version of 5011 * {@code updateNCharacterStream} which takes a length parameter. 5012 * 5013 * @param columnLabel the label for the column specified with the SQL AS clause. 5014 * If the SQL AS clause was not specified, then the label is the name of the column 5015 * @param reader the {@code java.io.Reader} object containing 5016 * the new column value 5017 * @exception SQLException if a database access error occurs, 5018 * the result set concurrency is {@code CONCUR_READ_ONLY} or 5019 * this method is called on a closed result set 5020 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5021 * this method 5022 * @since 1.6 5023 */ 5024 public void updateNCharacterStream(String columnLabel, 5025 java.io.Reader reader) throws SQLException { 5026 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5027 } 5028 5029 /** 5030 * Updates the designated column using the given input stream, which 5031 * will have the specified number of bytes. 5032 * When a very large ASCII value is input to a {@code LONGVARCHAR} 5033 * parameter, it may be more practical to send it via a 5034 * {@code java.io.InputStream}. Data will be read from the stream 5035 * as needed until end-of-file is reached. The JDBC driver will 5036 * do any necessary conversion from ASCII to the database char format. 5037 * 5038 * <P><B>Note:</B> This stream object can either be a standard 5039 * Java stream object or your own subclass that implements the 5040 * standard interface. 5041 * <p> 5042 * The updater methods are used to update column values in the 5043 * current row or the insert row. The updater methods do not 5044 * update the underlying database; instead the {@code updateRow} or 5045 * {@code insertRow} methods are called to update the database. 5046 * 5047 * @param columnIndex the first column is 1, the second is 2, ... 5048 * @param inputStream An object that contains the data to set the parameter 5049 * value to. 5050 * @param length the number of bytes in the parameter data. 5051 * @exception SQLException if a database access error occurs, 5052 * the result set concurrency is {@code CONCUR_READ_ONLY} 5053 * or this method is called on a closed result set 5054 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5055 * this method 5056 * @since 1.6 5057 */ 5058 public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException{ 5059 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5060 } 5061 5062 /** 5063 * Updates the designated column using the given input stream, which 5064 * will have the specified number of bytes. 5065 * When a very large ASCII value is input to a {@code LONGVARCHAR} 5066 * parameter, it may be more practical to send it via a 5067 * {@code java.io.InputStream}. Data will be read from the stream 5068 * as needed until end-of-file is reached. The JDBC driver will 5069 * do any necessary conversion from ASCII to the database char format. 5070 * 5071 * <P><B>Note:</B> This stream object can either be a standard 5072 * Java stream object or your own subclass that implements the 5073 * standard interface. 5074 * <p> 5075 * The updater methods are used to update column values in the 5076 * current row or the insert row. The updater methods do not 5077 * update the underlying database; instead the {@code updateRow} or 5078 * {@code insertRow} methods are called to update the database. 5079 * 5080 * @param columnLabel the label for the column specified with the SQL AS clause. 5081 * If the SQL AS clause was not specified, 5082 * then the label is the name of the column. 5083 * @param inputStream An object that contains the data to set the parameter 5084 * value to. 5085 * @param length the number of bytes in the parameter data. 5086 * @exception SQLException if a database access error occurs, 5087 * the result set concurrency is {@code CONCUR_READ_ONLY} 5088 * or this method is called on a closed result set 5089 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5090 * this method 5091 * @since 1.6 5092 */ 5093 public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException { 5094 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5095 } 5096 5097 /** 5098 * Updates the designated column using the given input stream. 5099 * When a very large ASCII value is input to a {@code LONGVARCHAR} 5100 * parameter, it may be more practical to send it via a 5101 * {@code java.io.InputStream}. Data will be read from the stream 5102 * as needed until end-of-file is reached. The JDBC driver will 5103 * do any necessary conversion from ASCII to the database char format. 5104 * 5105 * <P><B>Note:</B> This stream object can either be a standard 5106 * Java stream object or your own subclass that implements the 5107 * standard interface. 5108 * 5109 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5110 * it might be more efficient to use a version of 5111 * {@code updateBlob} which takes a length parameter. 5112 * <p> 5113 * The updater methods are used to update column values in the 5114 * current row or the insert row. The updater methods do not 5115 * update the underlying database; instead the {@code updateRow} or 5116 * {@code insertRow} methods are called to update the database. 5117 * 5118 * @param columnIndex the first column is 1, the second is 2, ... 5119 * @param inputStream An object that contains the data to set the parameter 5120 * value to. 5121 * @exception SQLException if a database access error occurs, 5122 * the result set concurrency is {@code CONCUR_READ_ONLY} 5123 * or this method is called on a closed result set 5124 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5125 * this method 5126 * @since 1.6 5127 */ 5128 public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException { 5129 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5130 } 5131 5132 /** 5133 * Updates the designated column using the given input stream. 5134 * When a very large ASCII value is input to a {@code LONGVARCHAR} 5135 * parameter, it may be more practical to send it via a 5136 * {@code java.io.InputStream}. Data will be read from the stream 5137 * as needed until end-of-file is reached. The JDBC driver will 5138 * do any necessary conversion from ASCII to the database char format. 5139 * 5140 * <P><B>Note:</B> This stream object can either be a standard 5141 * Java stream object or your own subclass that implements the 5142 * standard interface. 5143 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5144 * it might be more efficient to use a version of 5145 * {@code updateBlob} which takes a length parameter. 5146 * <p> 5147 * The updater methods are used to update column values in the 5148 * current row or the insert row. The updater methods do not 5149 * update the underlying database; instead the {@code updateRow} or 5150 * {@code insertRow} methods are called to update the database. 5151 * 5152 * @param columnLabel the label for the column specified with the SQL AS clause. 5153 * If the SQL AS clause was not specified, then the label 5154 * is the name of the column 5155 * @param inputStream An object that contains the data to set the parameter 5156 * value to. 5157 * @exception SQLException if a database access error occurs, 5158 * the result set concurrency is {@code CONCUR_READ_ONLY} 5159 * or this method is called on a closed result set 5160 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5161 * this method 5162 * @since 1.6 5163 */ 5164 public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException { 5165 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5166 } 5167 5168 /** 5169 * Updates the designated column using the given {@code Reader} 5170 * object, which is the given number of characters long. 5171 * When a very large UNICODE value is input to a {@code LONGVARCHAR} 5172 * parameter, it may be more practical to send it via a 5173 * {@code java.io.Reader} object. The data will be read from the stream 5174 * as needed until end-of-file is reached. The JDBC driver will 5175 * do any necessary conversion from UNICODE to the database char format. 5176 * 5177 * <P><B>Note:</B> This stream object can either be a standard 5178 * Java stream object or your own subclass that implements the 5179 * standard interface. 5180 * <p> 5181 * The updater methods are used to update column values in the 5182 * current row or the insert row. The updater methods do not 5183 * update the underlying database; instead the {@code updateRow} or 5184 * {@code insertRow} methods are called to update the database. 5185 * 5186 * @param columnIndex the first column is 1, the second is 2, ... 5187 * @param reader An object that contains the data to set the parameter value to. 5188 * @param length the number of characters in the parameter data. 5189 * @exception SQLException if a database access error occurs, 5190 * the result set concurrency is {@code CONCUR_READ_ONLY} 5191 * or this method is called on a closed result set 5192 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5193 * this method 5194 * @since 1.6 5195 */ 5196 public void updateClob(int columnIndex, Reader reader, long length) throws SQLException { 5197 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5198 } 5199 5200 /** 5201 * Updates the designated column using the given {@code Reader} 5202 * object, which is the given number of characters long. 5203 * When a very large UNICODE value is input to a {@code LONGVARCHAR} 5204 * parameter, it may be more practical to send it via a 5205 * {@code java.io.Reader} object. The data will be read from the stream 5206 * as needed until end-of-file is reached. The JDBC driver will 5207 * do any necessary conversion from UNICODE to the database char format. 5208 * 5209 * <P><B>Note:</B> This stream object can either be a standard 5210 * Java stream object or your own subclass that implements the 5211 * standard interface. 5212 * <p> 5213 * The updater methods are used to update column values in the 5214 * current row or the insert row. The updater methods do not 5215 * update the underlying database; instead the {@code updateRow} or 5216 * {@code insertRow} methods are called to update the database. 5217 * 5218 * @param columnLabel the label for the column specified with the SQL AS clause. 5219 * If the SQL AS clause was not specified, then the label is the name of the column 5220 * @param reader An object that contains the data to set the parameter value to. 5221 * @param length the number of characters in the parameter data. 5222 * @exception SQLException if a database access error occurs, 5223 * the result set concurrency is {@code CONCUR_READ_ONLY} 5224 * or this method is called on a closed result set 5225 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5226 * this method 5227 * @since 1.6 5228 */ 5229 public void updateClob(String columnLabel, Reader reader, long length) throws SQLException { 5230 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5231 } 5232 5233 /** 5234 * Updates the designated column using the given {@code Reader} 5235 * object. 5236 * When a very large UNICODE value is input to a {@code LONGVARCHAR} 5237 * parameter, it may be more practical to send it via a 5238 * {@code java.io.Reader} object. The data will be read from the stream 5239 * as needed until end-of-file is reached. The JDBC driver will 5240 * do any necessary conversion from UNICODE to the database char format. 5241 * 5242 * <P><B>Note:</B> This stream object can either be a standard 5243 * Java stream object or your own subclass that implements the 5244 * standard interface. 5245 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5246 * it might be more efficient to use a version of 5247 * {@code updateClob} which takes a length parameter. 5248 * <p> 5249 * The updater methods are used to update column values in the 5250 * current row or the insert row. The updater methods do not 5251 * update the underlying database; instead the {@code updateRow} or 5252 * {@code insertRow} methods are called to update the database. 5253 * 5254 * @param columnIndex the first column is 1, the second is 2, ... 5255 * @param reader An object that contains the data to set the parameter value to. 5256 * @exception SQLException if a database access error occurs, 5257 * the result set concurrency is {@code CONCUR_READ_ONLY} 5258 * or this method is called on a closed result set 5259 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5260 * this method 5261 * @since 1.6 5262 */ 5263 public void updateClob(int columnIndex, Reader reader) throws SQLException { 5264 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5265 } 5266 5267 /** 5268 * Updates the designated column using the given {@code Reader} 5269 * object. 5270 * When a very large UNICODE value is input to a {@code LONGVARCHAR} 5271 * parameter, it may be more practical to send it via a 5272 * {@code java.io.Reader} object. The data will be read from the stream 5273 * as needed until end-of-file is reached. The JDBC driver will 5274 * do any necessary conversion from UNICODE to the database char format. 5275 * 5276 * <P><B>Note:</B> This stream object can either be a standard 5277 * Java stream object or your own subclass that implements the 5278 * standard interface. 5279 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5280 * it might be more efficient to use a version of 5281 * {@code updateClob} which takes a length parameter. 5282 * <p> 5283 * The updater methods are used to update column values in the 5284 * current row or the insert row. The updater methods do not 5285 * update the underlying database; instead the {@code updateRow} or 5286 * {@code insertRow} methods are called to update the database. 5287 * 5288 * @param columnLabel the label for the column specified with the SQL AS clause. 5289 * If the SQL AS clause was not specified, then the label 5290 * is the name of the column 5291 * @param reader An object that contains the data to set the parameter value to. 5292 * @exception SQLException if a database access error occurs, 5293 * the result set concurrency is {@code CONCUR_READ_ONLY} 5294 * or this method is called on a closed result set 5295 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5296 * this method 5297 * @since 1.6 5298 */ 5299 public void updateClob(String columnLabel, Reader reader) throws SQLException { 5300 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5301 } 5302 5303 /** 5304 * Updates the designated column using the given {@code Reader} 5305 * object, which is the given number of characters long. 5306 * When a very large UNICODE value is input to a {@code LONGVARCHAR} 5307 * parameter, it may be more practical to send it via a 5308 * {@code java.io.Reader} object. The data will be read from the stream 5309 * as needed until end-of-file is reached. The JDBC driver will 5310 * do any necessary conversion from UNICODE to the database char format. 5311 * 5312 * <P><B>Note:</B> This stream object can either be a standard 5313 * Java stream object or your own subclass that implements the 5314 * standard interface. 5315 * <p> 5316 * The updater methods are used to update column values in the 5317 * current row or the insert row. The updater methods do not 5318 * update the underlying database; instead the {@code updateRow} or 5319 * {@code insertRow} methods are called to update the database. 5320 * 5321 * @param columnIndex the first column is 1, the second 2, ... 5322 * @param reader An object that contains the data to set the parameter value to. 5323 * @param length the number of characters in the parameter data. 5324 * @throws SQLException if the driver does not support national 5325 * character sets; if the driver can detect that a data conversion 5326 * error could occur; this method is called on a closed result set, 5327 * if a database access error occurs or 5328 * the result set concurrency is {@code CONCUR_READ_ONLY} 5329 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5330 * this method 5331 * @since 1.6 5332 */ 5333 public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException { 5334 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5335 } 5336 5337 /** 5338 * Updates the designated column using the given {@code Reader} 5339 * object, which is the given number of characters long. 5340 * When a very large UNICODE value is input to a {@code LONGVARCHAR} 5341 * parameter, it may be more practical to send it via a 5342 * {@code java.io.Reader} object. The data will be read from the stream 5343 * as needed until end-of-file is reached. The JDBC driver will 5344 * do any necessary conversion from UNICODE to the database char format. 5345 * 5346 * <P><B>Note:</B> This stream object can either be a standard 5347 * Java stream object or your own subclass that implements the 5348 * standard interface. 5349 * <p> 5350 * The updater methods are used to update column values in the 5351 * current row or the insert row. The updater methods do not 5352 * update the underlying database; instead the {@code updateRow} or 5353 * {@code insertRow} methods are called to update the database. 5354 * 5355 * @param columnLabel the label for the column specified with the SQL AS clause. 5356 * If the SQL AS clause was not specified, then the label is the name of the column 5357 * @param reader An object that contains the data to set the parameter value to. 5358 * @param length the number of characters in the parameter data. 5359 * @throws SQLException if the driver does not support national 5360 * character sets; if the driver can detect that a data conversion 5361 * error could occur; this method is called on a closed result set; 5362 * if a database access error occurs or 5363 * the result set concurrency is {@code CONCUR_READ_ONLY} 5364 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5365 * this method 5366 * @since 1.6 5367 */ 5368 public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException { 5369 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5370 } 5371 5372 /** 5373 * Updates the designated column using the given {@code Reader} 5374 * object. 5375 * When a very large UNICODE value is input to a {@code LONGVARCHAR} 5376 * parameter, it may be more practical to send it via a 5377 * {@code java.io.Reader} object. The data will be read from the stream 5378 * as needed until end-of-file is reached. The JDBC driver will 5379 * do any necessary conversion from UNICODE to the database char format. 5380 * 5381 * <P><B>Note:</B> This stream object can either be a standard 5382 * Java stream object or your own subclass that implements the 5383 * standard interface. 5384 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5385 * it might be more efficient to use a version of 5386 * {@code updateNClob} which takes a length parameter. 5387 * <p> 5388 * The updater methods are used to update column values in the 5389 * current row or the insert row. The updater methods do not 5390 * update the underlying database; instead the {@code updateRow} or 5391 * {@code insertRow} methods are called to update the database. 5392 * 5393 * @param columnIndex the first column is 1, the second 2, ... 5394 * @param reader An object that contains the data to set the parameter value to. 5395 * @throws SQLException if the driver does not support national 5396 * character sets; if the driver can detect that a data conversion 5397 * error could occur; this method is called on a closed result set, 5398 * if a database access error occurs or 5399 * the result set concurrency is {@code CONCUR_READ_ONLY} 5400 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5401 * this method 5402 * @since 1.6 5403 */ 5404 public void updateNClob(int columnIndex, Reader reader) throws SQLException { 5405 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5406 } 5407 5408 /** 5409 * Updates the designated column using the given {@code Reader} 5410 * object. 5411 * When a very large UNICODE value is input to a {@code LONGVARCHAR} 5412 * parameter, it may be more practical to send it via a 5413 * {@code java.io.Reader} object. The data will be read from the stream 5414 * as needed until end-of-file is reached. The JDBC driver will 5415 * do any necessary conversion from UNICODE to the database char format. 5416 * 5417 * <P><B>Note:</B> This stream object can either be a standard 5418 * Java stream object or your own subclass that implements the 5419 * standard interface. 5420 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5421 * it might be more efficient to use a version of 5422 * {@code updateNClob} which takes a length parameter. 5423 * <p> 5424 * The updater methods are used to update column values in the 5425 * current row or the insert row. The updater methods do not 5426 * update the underlying database; instead the {@code updateRow} or 5427 * {@code insertRow} methods are called to update the database. 5428 * 5429 * @param columnLabel the label for the column specified with the SQL AS clause. 5430 * If the SQL AS clause was not specified, then 5431 * the label is the name of the column 5432 * @param reader An object that contains the data to set the parameter value to. 5433 * @throws SQLException if the driver does not support national 5434 * character sets; if the driver can detect that a data conversion 5435 * error could occur; this method is called on a closed result set; 5436 * if a database access error occurs or 5437 * the result set concurrency is {@code CONCUR_READ_ONLY} 5438 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5439 * this method 5440 * @since 1.6 5441 */ 5442 public void updateNClob(String columnLabel, Reader reader) throws SQLException { 5443 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5444 } 5445 5446 5447 /** 5448 * Updates the designated column with an ascii stream value, which will have 5449 * the specified number of bytes. 5450 * The updater methods are used to update column values in the 5451 * current row or the insert row. The updater methods do not 5452 * update the underlying database; instead the {@code updateRow} or 5453 * {@code insertRow} methods are called to update the database. 5454 * 5455 * @param columnIndex the first column is 1, the second is 2, ... 5456 * @param x the new column value 5457 * @param length the length of the stream 5458 * @exception SQLException if a database access error occurs, 5459 * the result set concurrency is {@code CONCUR_READ_ONLY} 5460 * or this method is called on a closed result set 5461 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5462 * this method 5463 * @since 1.6 5464 */ 5465 public void updateAsciiStream(int columnIndex, 5466 java.io.InputStream x, 5467 long length) throws SQLException { 5468 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5469 } 5470 5471 /** 5472 * Updates the designated column with a binary stream value, which will have 5473 * the specified number of bytes. 5474 * The updater methods are used to update column values in the 5475 * current row or the insert row. The updater methods do not 5476 * update the underlying database; instead the {@code updateRow} or 5477 * {@code insertRow} methods are called to update the database. 5478 * 5479 * @param columnIndex the first column is 1, the second is 2, ... 5480 * @param x the new column value 5481 * @param length the length of the stream 5482 * @exception SQLException if a database access error occurs, 5483 * the result set concurrency is {@code CONCUR_READ_ONLY} 5484 * or this method is called on a closed result set 5485 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5486 * this method 5487 * @since 1.6 5488 */ 5489 public void updateBinaryStream(int columnIndex, 5490 java.io.InputStream x, 5491 long length) throws SQLException { 5492 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5493 } 5494 5495 /** 5496 * Updates the designated column with a character stream value, which will have 5497 * the specified number of bytes. 5498 * The updater methods are used to update column values in the 5499 * current row or the insert row. The updater methods do not 5500 * update the underlying database; instead the {@code updateRow} or 5501 * {@code insertRow} methods are called to update the database. 5502 * 5503 * @param columnIndex the first column is 1, the second is 2, ... 5504 * @param x the new column value 5505 * @param length the length of the stream 5506 * @exception SQLException if a database access error occurs, 5507 * the result set concurrency is {@code CONCUR_READ_ONLY} 5508 * or this method is called on a closed result set 5509 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5510 * this method 5511 * @since 1.6 5512 */ 5513 public void updateCharacterStream(int columnIndex, 5514 java.io.Reader x, 5515 long length) throws SQLException { 5516 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5517 } 5518 5519 /** 5520 * Updates the designated column with an ascii stream value, which will have 5521 * the specified number of bytes.. 5522 * The updater methods are used to update column values in the 5523 * current row or the insert row. The updater methods do not 5524 * update the underlying database; instead the {@code updateRow} or 5525 * {@code insertRow} methods are called to update the database. 5526 * 5527 * @param columnLabel the label for the column specified with the SQL AS clause. 5528 * If the SQL AS clause was not specified, then 5529 * the label is the name of the column 5530 * @param x the new column value 5531 * @param length the length of the stream 5532 * @exception SQLException if a database access error occurs, 5533 * the result set concurrency is {@code CONCUR_READ_ONLY} 5534 * or this method is called on a closed result set 5535 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5536 * this method 5537 * @since 1.6 5538 */ 5539 public void updateAsciiStream(String columnLabel, 5540 java.io.InputStream x, 5541 long length) throws SQLException { 5542 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5543 } 5544 5545 /** 5546 * Updates the designated column with an ascii stream value. 5547 * The updater methods are used to update column values in the 5548 * current row or the insert row. The updater methods do not 5549 * update the underlying database; instead the {@code updateRow} or 5550 * {@code insertRow} methods are called to update the database. 5551 * 5552 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5553 * it might be more efficient to use a version of 5554 * {@code updateAsciiStream} which takes a length parameter. 5555 * 5556 * @param columnIndex the first column is 1, the second is 2, ... 5557 * @param x the new column value 5558 * @exception SQLException if a database access error occurs, 5559 * the result set concurrency is {@code CONCUR_READ_ONLY} 5560 * or this method is called on a closed result set 5561 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5562 * this method 5563 * @since 1.6 5564 */ 5565 public void updateAsciiStream(int columnIndex, 5566 java.io.InputStream x) throws SQLException { 5567 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5568 } 5569 5570 /** 5571 * Updates the designated column with an ascii stream value. 5572 * The updater methods are used to update column values in the 5573 * current row or the insert row. The updater methods do not 5574 * update the underlying database; instead the {@code updateRow} or 5575 * {@code insertRow} methods are called to update the database. 5576 * 5577 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5578 * it might be more efficient to use a version of 5579 * {@code updateAsciiStream} which takes a length parameter. 5580 * 5581 * @param columnLabel the label for the column specified with the SQL AS clause. 5582 * If the SQL AS clause was not specified, then the label 5583 * is the name of the column 5584 * @param x the new column value 5585 * @exception SQLException if a database access error occurs, 5586 * the result set concurrency is {@code CONCUR_READ_ONLY} 5587 * or this method is called on a closed result set 5588 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5589 * this method 5590 * @since 1.6 5591 */ 5592 public void updateAsciiStream(String columnLabel, 5593 java.io.InputStream x) throws SQLException { 5594 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5595 } 5596 5597 5598 /** 5599 * Updates the designated column with a binary stream value, which will have 5600 * the specified number of bytes. 5601 * The updater methods are used to update column values in the 5602 * current row or the insert row. The updater methods do not 5603 * update the underlying database; instead the {@code updateRow} or 5604 * {@code insertRow} methods are called to update the database. 5605 * 5606 * @param columnLabel the label for the column specified with the SQL AS clause. 5607 * If the SQL AS clause was not specified, then 5608 * the label is the name of the column 5609 * @param x the new column value 5610 * @param length the length of the stream 5611 * @exception SQLException if a database access error occurs, 5612 * the result set concurrency is {@code CONCUR_READ_ONLY} 5613 * or this method is called on a closed result set 5614 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5615 * this method 5616 * @since 1.6 5617 */ 5618 public void updateBinaryStream(String columnLabel, 5619 java.io.InputStream x, 5620 long length) throws SQLException { 5621 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5622 } 5623 5624 /** 5625 * Updates the designated column with a binary stream value. 5626 * The updater methods are used to update column values in the 5627 * current row or the insert row. The updater methods do not 5628 * update the underlying database; instead the {@code updateRow} or 5629 * {@code insertRow} methods are called to update the database. 5630 * 5631 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5632 * it might be more efficient to use a version of 5633 * {@code updateBinaryStream} which takes a length parameter. 5634 * 5635 * @param columnIndex the first column is 1, the second is 2, ... 5636 * @param x the new column value 5637 * @exception SQLException if a database access error occurs, 5638 * the result set concurrency is {@code CONCUR_READ_ONLY} 5639 * or this method is called on a closed result set 5640 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5641 * this method 5642 * @since 1.6 5643 */ 5644 public void updateBinaryStream(int columnIndex, 5645 java.io.InputStream x) throws SQLException { 5646 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5647 } 5648 5649 5650 /** 5651 * Updates the designated column with a binary stream value. 5652 * The updater methods are used to update column values in the 5653 * current row or the insert row. The updater methods do not 5654 * update the underlying database; instead the {@code updateRow} or 5655 * {@code insertRow} methods are called to update the database. 5656 * 5657 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5658 * it might be more efficient to use a version of 5659 * {@code updateBinaryStream} which takes a length parameter. 5660 * 5661 * @param columnLabel the label for the column specified with the SQL AS clause. 5662 * If the SQL AS clause was not specified, then 5663 * the label is the name of the column 5664 * @param x the new column value 5665 * @exception SQLException if a database access error occurs, 5666 * the result set concurrency is {@code CONCUR_READ_ONLY} 5667 * or this method is called on a closed result set 5668 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5669 * this method 5670 * @since 1.6 5671 */ 5672 public void updateBinaryStream(String columnLabel, 5673 java.io.InputStream x) throws SQLException { 5674 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5675 } 5676 5677 5678 /** 5679 * Updates the designated column with a character stream value, which will have 5680 * the specified number of bytes. 5681 * The updater methods are used to update column values in the 5682 * current row or the insert row. The updater methods do not 5683 * update the underlying database; instead the {@code updateRow} or 5684 * {@code insertRow} methods are called to update the database. 5685 * 5686 * @param columnLabel the label for the column specified with the SQL AS clause. 5687 * If the SQL AS clause was not specified, then 5688 * the label is the name of the column 5689 * @param reader the {@code java.io.Reader} object containing 5690 * the new column value 5691 * @param length the length of the stream 5692 * @exception SQLException if a database access error occurs, 5693 * the result set concurrency is {@code CONCUR_READ_ONLY} 5694 * or this method is called on a closed result set 5695 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5696 * this method 5697 * @since 1.6 5698 */ 5699 public void updateCharacterStream(String columnLabel, 5700 java.io.Reader reader, 5701 long length) throws SQLException { 5702 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5703 } 5704 5705 /** 5706 * Updates the designated column with a character stream value. 5707 * The updater methods are used to update column values in the 5708 * current row or the insert row. The updater methods do not 5709 * update the underlying database; instead the {@code updateRow} or 5710 * {@code insertRow} methods are called to update the database. 5711 * 5712 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5713 * it might be more efficient to use a version of 5714 * {@code updateCharacterStream} which takes a length parameter. 5715 * 5716 * @param columnIndex the first column is 1, the second is 2, ... 5717 * @param x the new column value 5718 * @exception SQLException if a database access error occurs, 5719 * the result set concurrency is {@code CONCUR_READ_ONLY} 5720 * or this method is called on a closed result set 5721 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5722 * this method 5723 * @since 1.6 5724 */ 5725 public void updateCharacterStream(int columnIndex, 5726 java.io.Reader x) throws SQLException { 5727 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5728 } 5729 5730 /** 5731 * Updates the designated column with a character stream value. 5732 * The updater methods are used to update column values in the 5733 * current row or the insert row. The updater methods do not 5734 * update the underlying database; instead the {@code updateRow} or 5735 * {@code insertRow} methods are called to update the database. 5736 * 5737 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5738 * it might be more efficient to use a version of 5739 * {@code updateCharacterStream} which takes a length parameter. 5740 * 5741 * @param columnLabel the label for the column specified with the SQL AS clause. 5742 * If the SQL AS clause was not specified, then the label 5743 * is the name of the column 5744 * @param reader the {@code java.io.Reader} object containing 5745 * the new column value 5746 * @exception SQLException if a database access error occurs, 5747 * the result set concurrency is {@code CONCUR_READ_ONLY} 5748 * or this method is called on a closed result set 5749 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5750 * this method 5751 * @since 1.6 5752 */ 5753 public void updateCharacterStream(String columnLabel, 5754 java.io.Reader reader) throws SQLException { 5755 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5756 } 5757 5758 5759 /** 5760 * Sets the designated parameter to the given {@code java.net.URL} value. 5761 * The driver converts this to an SQL {@code DATALINK} value 5762 * when it sends it to the database. 5763 * 5764 * @param parameterIndex the first parameter is 1, the second is 2, ... 5765 * @param x the {@code java.net.URL} object to be set 5766 * @exception SQLException if a database access error occurs or 5767 * this method is called on a closed {@code PreparedStatement} 5768 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 5769 * @since 1.4 5770 */ 5771 public void setURL(int parameterIndex, java.net.URL x) throws SQLException{ 5772 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5773 } 5774 5775 5776 /** 5777 * Sets the designated parameter to a {@code Reader} object. 5778 * This method differs from the {@code setCharacterStream (int, Reader)} method 5779 * because it informs the driver that the parameter value should be sent to 5780 * the server as a {@code NCLOB}. When the {@code setCharacterStream} method is used, the 5781 * driver may have to do extra work to determine whether the parameter 5782 * data should be sent to the server as a {@code LONGNVARCHAR} or a {@code NCLOB} 5783 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5784 * it might be more efficient to use a version of 5785 * {@code setNClob} which takes a length parameter. 5786 * 5787 * @param parameterIndex index of the first parameter is 1, the second is 2, ... 5788 * @param reader An object that contains the data to set the parameter value to. 5789 * @throws SQLException if parameterIndex does not correspond to a parameter 5790 * marker in the SQL statement; 5791 * if the driver does not support national character sets; 5792 * if the driver can detect that a data conversion 5793 * error could occur; if a database access error occurs or 5794 * this method is called on a closed {@code PreparedStatement} 5795 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 5796 * 5797 * @since 1.6 5798 */ 5799 public void setNClob(int parameterIndex, Reader reader) 5800 throws SQLException{ 5801 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5802 } 5803 5804 /** 5805 * Sets the designated parameter to a {@code Reader} object. 5806 * The {@code reader} must contain the number 5807 * of characters specified by length otherwise a {@code SQLException} will be 5808 * generated when the {@code CallableStatement} is executed. 5809 * This method differs from the {@code setCharacterStream (int, Reader, int)} method 5810 * because it informs the driver that the parameter value should be sent to 5811 * the server as a {@code NCLOB}. When the {@code setCharacterStream} method is used, the 5812 * driver may have to do extra work to determine whether the parameter 5813 * data should be send to the server as a {@code LONGNVARCHAR} or a {@code NCLOB} 5814 * 5815 * @param parameterName the name of the parameter to be set 5816 * @param reader An object that contains the data to set the parameter value to. 5817 * @param length the number of characters in the parameter data. 5818 * @throws SQLException if parameterIndex does not correspond to a parameter 5819 * marker in the SQL statement; if the length specified is less than zero; 5820 * if the driver does not support national 5821 * character sets; if the driver can detect that a data conversion 5822 * error could occur; if a database access error occurs or 5823 * this method is called on a closed {@code CallableStatement} 5824 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 5825 * this method 5826 * @since 1.6 5827 */ 5828 public void setNClob(String parameterName, Reader reader, long length) 5829 throws SQLException{ 5830 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5831 } 5832 5833 5834 /** 5835 * Sets the designated parameter to a {@code Reader} object. 5836 * This method differs from the {@code setCharacterStream (int, Reader)} method 5837 * because it informs the driver that the parameter value should be sent to 5838 * the server as a {@code NCLOB}. When the {@code setCharacterStream} method is used, the 5839 * driver may have to do extra work to determine whether the parameter 5840 * data should be send to the server as a {@code LONGNVARCHAR} or a {@code NCLOB} 5841 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5842 * it might be more efficient to use a version of 5843 * {@code setNClob} which takes a length parameter. 5844 * 5845 * @param parameterName the name of the parameter 5846 * @param reader An object that contains the data to set the parameter value to. 5847 * @throws SQLException if the driver does not support national character sets; 5848 * if the driver can detect that a data conversion 5849 * error could occur; if a database access error occurs or 5850 * this method is called on a closed {@code CallableStatement} 5851 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 5852 * 5853 * @since 1.6 5854 */ 5855 public void setNClob(String parameterName, Reader reader) 5856 throws SQLException{ 5857 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5858 } 5859 5860 5861 /** 5862 * Sets the designated parameter to a {@code Reader} object. The reader must contain the number 5863 * of characters specified by length otherwise a {@code SQLException} will be 5864 * generated when the {@code PreparedStatement} is executed. 5865 * This method differs from the {@code setCharacterStream (int, Reader, int)} method 5866 * because it informs the driver that the parameter value should be sent to 5867 * the server as a {@code NCLOB}. When the {@code setCharacterStream} method is used, the 5868 * driver may have to do extra work to determine whether the parameter 5869 * data should be sent to the server as a {@code LONGNVARCHAR} or a {@code NCLOB} 5870 * 5871 * @param parameterIndex index of the first parameter is 1, the second is 2, ... 5872 * @param reader An object that contains the data to set the parameter value to. 5873 * @param length the number of characters in the parameter data. 5874 * @throws SQLException if parameterIndex does not correspond to a parameter 5875 * marker in the SQL statement; if the length specified is less than zero; 5876 * if the driver does not support national character sets; 5877 * if the driver can detect that a data conversion 5878 * error could occur; if a database access error occurs or 5879 * this method is called on a closed {@code PreparedStatement} 5880 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 5881 * 5882 * @since 1.6 5883 */ 5884 public void setNClob(int parameterIndex, Reader reader, long length) 5885 throws SQLException{ 5886 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5887 } 5888 5889 5890 /** 5891 * Sets the designated parameter to a {@code java.sql.NClob} object. 5892 * The driver converts this to an 5893 * SQL {@code NCLOB} value when it sends it to the database. 5894 * @param parameterIndex of the first parameter is 1, the second is 2, ... 5895 * @param value the parameter value 5896 * @throws SQLException if the driver does not support national 5897 * character sets; if the driver can detect that a data conversion 5898 * error could occur; or if a database access error occurs 5899 * @since 1.6 5900 */ 5901 public void setNClob(int parameterIndex, NClob value) throws SQLException{ 5902 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5903 } 5904 5905 5906 /** 5907 * Sets the designated parameter to the given {@code String} object. 5908 * The driver converts this to a SQL {@code NCHAR} or 5909 * {@code NVARCHAR} or {@code LONGNVARCHAR} 5910 * @param parameterName the name of the column to be set 5911 * @param value the parameter value 5912 * @throws SQLException if the driver does not support national 5913 * character sets; if the driver can detect that a data conversion 5914 * error could occur; or if a database access error occurs 5915 * @since 1.6 5916 */ 5917 public void setNString(String parameterName, String value) 5918 throws SQLException{ 5919 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5920 } 5921 5922 /** 5923 * Sets the designated parameter to a {@code Reader} object. The 5924 * {@code Reader} reads the data till end-of-file is reached. The 5925 * driver does the necessary conversion from Java character format to 5926 * the national character set in the database. 5927 * @param parameterIndex of the first parameter is 1, the second is 2, ... 5928 * @param value the parameter value 5929 * @param length the number of characters in the parameter data. 5930 * @throws SQLException if the driver does not support national 5931 * character sets; if the driver can detect that a data conversion 5932 * error could occur ; or if a database access error occurs 5933 * @since 1.6 5934 */ 5935 public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException{ 5936 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5937 } 5938 5939 5940 5941 /** 5942 * Sets the designated parameter to a {@code Reader} object. The 5943 * {@code Reader} reads the data till end-of-file is reached. The 5944 * driver does the necessary conversion from Java character format to 5945 * the national character set in the database. 5946 * @param parameterName the name of the column to be set 5947 * @param value the parameter value 5948 * @param length the number of characters in the parameter data. 5949 * @throws SQLException if the driver does not support national 5950 * character sets; if the driver can detect that a data conversion 5951 * error could occur; or if a database access error occurs 5952 * @since 1.6 5953 */ 5954 public void setNCharacterStream(String parameterName, Reader value, long length) 5955 throws SQLException{ 5956 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5957 } 5958 5959 /** 5960 * Sets the designated parameter to a {@code Reader} object. The 5961 * {@code Reader} reads the data till end-of-file is reached. The 5962 * driver does the necessary conversion from Java character format to 5963 * the national character set in the database. 5964 5965 * <P><B>Note:</B> This stream object can either be a standard 5966 * Java stream object or your own subclass that implements the 5967 * standard interface. 5968 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 5969 * it might be more efficient to use a version of 5970 * {@code setNCharacterStream} which takes a length parameter. 5971 * 5972 * @param parameterName the name of the parameter 5973 * @param value the parameter value 5974 * @throws SQLException if the driver does not support national 5975 * character sets; if the driver can detect that a data conversion 5976 * error could occur ; if a database access error occurs; or 5977 * this method is called on a closed {@code CallableStatement} 5978 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 5979 * @since 1.6 5980 */ 5981 public void setNCharacterStream(String parameterName, Reader value) throws SQLException{ 5982 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 5983 } 5984 5985 /** 5986 * Sets the designated parameter to the given {@code java.sql.Timestamp} value, 5987 * using the given {@code Calendar} object. The driver uses 5988 * the {@code Calendar} object to construct an SQL {@code TIMESTAMP} value, 5989 * which the driver then sends to the database. With a 5990 * a {@code Calendar} object, the driver can calculate the timestamp 5991 * taking into account a custom timezone. If no 5992 * {@code Calendar} object is specified, the driver uses the default 5993 * timezone, which is that of the virtual machine running the application. 5994 * 5995 * @param parameterName the name of the parameter 5996 * @param x the parameter value 5997 * @param cal the {@code Calendar} object the driver will use 5998 * to construct the timestamp 5999 * @exception SQLException if a database access error occurs or 6000 * this method is called on a closed {@code CallableStatement} 6001 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6002 * this method 6003 * @see #getTimestamp 6004 * @since 1.4 6005 */ 6006 public void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal) 6007 throws SQLException{ 6008 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6009 } 6010 6011 /** 6012 * Sets the designated parameter to a {@code Reader} object. The {@code reader} must contain the number 6013 * of characters specified by length otherwise a {@code SQLException} will be 6014 * generated when the {@code CallableStatement} is executed. 6015 * This method differs from the {@code setCharacterStream (int, Reader, int)} method 6016 * because it informs the driver that the parameter value should be sent to 6017 * the server as a {@code CLOB}. When the {@code setCharacterStream} method is used, the 6018 * driver may have to do extra work to determine whether the parameter 6019 * data should be send to the server as a {@code LONGVARCHAR} or a {@code CLOB} 6020 * 6021 * @param parameterName the name of the parameter to be set 6022 * @param reader An object that contains the data to set the parameter value to. 6023 * @param length the number of characters in the parameter data. 6024 * @throws SQLException if parameterIndex does not correspond to a parameter 6025 * marker in the SQL statement; if the length specified is less than zero; 6026 * a database access error occurs or 6027 * this method is called on a closed {@code CallableStatement} 6028 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6029 * this method 6030 * 6031 * @since 1.6 6032 */ 6033 public void setClob(String parameterName, Reader reader, long length) 6034 throws SQLException{ 6035 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6036 } 6037 6038 6039 6040 /** 6041 * Sets the designated parameter to the given {@code java.sql.Clob} object. 6042 * The driver converts this to an SQL {@code CLOB} value when it 6043 * sends it to the database. 6044 * 6045 * @param parameterName the name of the parameter 6046 * @param x a {@code Clob} object that maps an SQL {@code CLOB} value 6047 * @exception SQLException if a database access error occurs or 6048 * this method is called on a closed {@code CallableStatement} 6049 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6050 * this method 6051 * @since 1.6 6052 */ 6053 public void setClob (String parameterName, Clob x) throws SQLException{ 6054 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6055 } 6056 6057 /** 6058 * Sets the designated parameter to a {@code Reader} object. 6059 * This method differs from the {@code setCharacterStream (int, Reader)} method 6060 * because it informs the driver that the parameter value should be sent to 6061 * the server as a {@code CLOB}. When the {@code setCharacterStream} method is used, the 6062 * driver may have to do extra work to determine whether the parameter 6063 * data should be send to the server as a {@code LONGVARCHAR} or a {@code CLOB} 6064 * 6065 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 6066 * it might be more efficient to use a version of 6067 * {@code setClob} which takes a length parameter. 6068 * 6069 * @param parameterName the name of the parameter 6070 * @param reader An object that contains the data to set the parameter value to. 6071 * @throws SQLException if a database access error occurs or this method is called on 6072 * a closed {@code CallableStatement} 6073 * 6074 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6075 * @since 1.6 6076 */ 6077 public void setClob(String parameterName, Reader reader) 6078 throws SQLException{ 6079 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6080 } 6081 6082 6083 /** 6084 * Sets the designated parameter to the given {@code java.sql.Date} value 6085 * using the default time zone of the virtual machine that is running 6086 * the application. 6087 * The driver converts this 6088 * to an SQL {@code DATE} value when it sends it to the database. 6089 * 6090 * @param parameterName the name of the parameter 6091 * @param x the parameter value 6092 * @exception SQLException if a database access error occurs or 6093 * this method is called on a closed {@code CallableStatement} 6094 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6095 * this method 6096 * @see #getDate 6097 * @since 1.4 6098 */ 6099 public void setDate(String parameterName, java.sql.Date x) 6100 throws SQLException{ 6101 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6102 } 6103 6104 /** 6105 * Sets the designated parameter to the given {@code java.sql.Date} value, 6106 * using the given {@code Calendar} object. The driver uses 6107 * the {@code Calendar} object to construct an SQL {@code DATE} value, 6108 * which the driver then sends to the database. With a 6109 * a {@code Calendar} object, the driver can calculate the date 6110 * taking into account a custom timezone. If no 6111 * {@code Calendar} object is specified, the driver uses the default 6112 * timezone, which is that of the virtual machine running the application. 6113 * 6114 * @param parameterName the name of the parameter 6115 * @param x the parameter value 6116 * @param cal the {@code Calendar} object the driver will use 6117 * to construct the date 6118 * @exception SQLException if a database access error occurs or 6119 * this method is called on a closed {@code CallableStatement} 6120 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6121 * this method 6122 * @see #getDate 6123 * @since 1.4 6124 */ 6125 public void setDate(String parameterName, java.sql.Date x, Calendar cal) 6126 throws SQLException{ 6127 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6128 } 6129 6130 6131 /** 6132 * Sets the designated parameter to the given {@code java.sql.Time} value. 6133 * The driver converts this 6134 * to an SQL {@code TIME} value when it sends it to the database. 6135 * 6136 * @param parameterName the name of the parameter 6137 * @param x the parameter value 6138 * @exception SQLException if a database access error occurs or 6139 * this method is called on a closed {@code CallableStatement} 6140 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6141 * this method 6142 * @see #getTime 6143 * @since 1.4 6144 */ 6145 public void setTime(String parameterName, java.sql.Time x) 6146 throws SQLException{ 6147 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6148 } 6149 6150 /** 6151 * Sets the designated parameter to the given {@code java.sql.Time} value, 6152 * using the given {@code Calendar} object. The driver uses 6153 * the {@code Calendar} object to construct an SQL {@code TIME} value, 6154 * which the driver then sends to the database. With a 6155 * a {@code Calendar} object, the driver can calculate the time 6156 * taking into account a custom timezone. If no 6157 * {@code Calendar} object is specified, the driver uses the default 6158 * timezone, which is that of the virtual machine running the application. 6159 * 6160 * @param parameterName the name of the parameter 6161 * @param x the parameter value 6162 * @param cal the {@code Calendar} object the driver will use 6163 * to construct the time 6164 * @exception SQLException if a database access error occurs or 6165 * this method is called on a closed {@code CallableStatement} 6166 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6167 * this method 6168 * @see #getTime 6169 * @since 1.4 6170 */ 6171 public void setTime(String parameterName, java.sql.Time x, Calendar cal) 6172 throws SQLException{ 6173 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6174 } 6175 6176 /** 6177 * Sets the designated parameter to a {@code Reader} object. 6178 * This method differs from the {@code setCharacterStream (int, Reader)} method 6179 * because it informs the driver that the parameter value should be sent to 6180 * the server as a {@code CLOB}. When the {@code setCharacterStream} method is used, the 6181 * driver may have to do extra work to determine whether the parameter 6182 * data should be sent to the server as a {@code LONGVARCHAR} or a {@code CLOB} 6183 * 6184 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 6185 * it might be more efficient to use a version of 6186 * {@code setClob} which takes a length parameter. 6187 * 6188 * @param parameterIndex index of the first parameter is 1, the second is 2, ... 6189 * @param reader An object that contains the data to set the parameter value to. 6190 * @throws SQLException if a database access error occurs, this method is called on 6191 * a closed {@code PreparedStatement}or if parameterIndex does not correspond to a parameter 6192 * marker in the SQL statement 6193 * 6194 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6195 * @since 1.6 6196 */ 6197 public void setClob(int parameterIndex, Reader reader) 6198 throws SQLException{ 6199 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6200 } 6201 6202 6203 /** 6204 * Sets the designated parameter to a {@code Reader} object. The reader must contain the number 6205 * of characters specified by length otherwise a {@code SQLException} will be 6206 * generated when the {@code PreparedStatement} is executed. 6207 * This method differs from the {@code setCharacterStream (int, Reader, int)} method 6208 * because it informs the driver that the parameter value should be sent to 6209 * the server as a {@code CLOB}. When the {@code setCharacterStream} method is used, the 6210 * driver may have to do extra work to determine whether the parameter 6211 * data should be sent to the server as a {@code LONGVARCHAR} or a {@code CLOB} 6212 * @param parameterIndex index of the first parameter is 1, the second is 2, ... 6213 * @param reader An object that contains the data to set the parameter value to. 6214 * @param length the number of characters in the parameter data. 6215 * @throws SQLException if a database access error occurs, this method is called on 6216 * a closed {@code PreparedStatement}, if parameterIndex does not correspond to a parameter 6217 * marker in the SQL statement, or if the length specified is less than zero. 6218 * 6219 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6220 * @since 1.6 6221 */ 6222 public void setClob(int parameterIndex, Reader reader, long length) 6223 throws SQLException{ 6224 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6225 } 6226 6227 6228 /** 6229 * Sets the designated parameter to a {@code InputStream} object. The inputstream must contain the number 6230 * of characters specified by length otherwise a {@code SQLException} will be 6231 * generated when the {@code PreparedStatement} is executed. 6232 * This method differs from the {@code setBinaryStream (int, InputStream, int)} 6233 * method because it informs the driver that the parameter value should be 6234 * sent to the server as a {@code BLOB}. When the {@code setBinaryStream} method is used, 6235 * the driver may have to do extra work to determine whether the parameter 6236 * data should be sent to the server as a {@code LONGVARBINARY} or a {@code BLOB} 6237 * 6238 * @param parameterIndex index of the first parameter is 1, 6239 * the second is 2, ... 6240 * @param inputStream An object that contains the data to set the parameter 6241 * value to. 6242 * @param length the number of bytes in the parameter data. 6243 * @throws SQLException if a database access error occurs, 6244 * this method is called on a closed {@code PreparedStatement}, 6245 * if parameterIndex does not correspond 6246 * to a parameter marker in the SQL statement, if the length specified 6247 * is less than zero or if the number of bytes in the inputstream does not match 6248 * the specified length. 6249 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6250 * 6251 * @since 1.6 6252 */ 6253 public void setBlob(int parameterIndex, InputStream inputStream, long length) 6254 throws SQLException{ 6255 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6256 } 6257 6258 /** 6259 * Sets the designated parameter to a {@code InputStream} object. 6260 * This method differs from the {@code setBinaryStream (int, InputStream)} 6261 * This method differs from the {@code setBinaryStream (int, InputStream)} 6262 * method because it informs the driver that the parameter value should be 6263 * sent to the server as a {@code BLOB}. When the {@code setBinaryStream} method is used, 6264 * the driver may have to do extra work to determine whether the parameter 6265 * data should be sent to the server as a {@code LONGVARBINARY} or a {@code BLOB} 6266 * 6267 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 6268 * it might be more efficient to use a version of 6269 * {@code setBlob} which takes a length parameter. 6270 * 6271 * @param parameterIndex index of the first parameter is 1, 6272 * the second is 2, ... 6273 * 6274 * @param inputStream An object that contains the data to set the parameter 6275 * value to. 6276 * @throws SQLException if a database access error occurs, 6277 * this method is called on a closed {@code PreparedStatement} or 6278 * if parameterIndex does not correspond 6279 * to a parameter marker in the SQL statement, 6280 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6281 * 6282 * @since 1.6 6283 */ 6284 public void setBlob(int parameterIndex, InputStream inputStream) 6285 throws SQLException{ 6286 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6287 } 6288 6289 /** 6290 * Sets the designated parameter to a {@code InputStream} object. The {@code inputstream} must contain the number 6291 * of characters specified by length, otherwise a {@code SQLException} will be 6292 * generated when the {@code CallableStatement} is executed. 6293 * This method differs from the {@code setBinaryStream (int, InputStream, int)} 6294 * method because it informs the driver that the parameter value should be 6295 * sent to the server as a {@code BLOB}. When the {@code setBinaryStream} method is used, 6296 * the driver may have to do extra work to determine whether the parameter 6297 * data should be sent to the server as a {@code LONGVARBINARY} or a {@code BLOB} 6298 * 6299 * @param parameterName the name of the parameter to be set 6300 * the second is 2, ... 6301 * 6302 * @param inputStream An object that contains the data to set the parameter 6303 * value to. 6304 * @param length the number of bytes in the parameter data. 6305 * @throws SQLException if parameterIndex does not correspond 6306 * to a parameter marker in the SQL statement, or if the length specified 6307 * is less than zero; if the number of bytes in the inputstream does not match 6308 * the specified length; if a database access error occurs or 6309 * this method is called on a closed {@code CallableStatement} 6310 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6311 * this method 6312 * 6313 * @since 1.6 6314 */ 6315 public void setBlob(String parameterName, InputStream inputStream, long length) 6316 throws SQLException{ 6317 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6318 } 6319 6320 6321 /** 6322 * Sets the designated parameter to the given {@code java.sql.Blob} object. 6323 * The driver converts this to an SQL {@code BLOB} value when it 6324 * sends it to the database. 6325 * 6326 * @param parameterName the name of the parameter 6327 * @param x a {@code Blob} object that maps an SQL {@code BLOB} value 6328 * @exception SQLException if a database access error occurs or 6329 * this method is called on a closed {@code CallableStatement} 6330 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6331 * this method 6332 * @since 1.6 6333 */ 6334 public void setBlob (String parameterName, Blob x) throws SQLException{ 6335 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6336 } 6337 6338 /** 6339 * Sets the designated parameter to a {@code InputStream} object. 6340 * This method differs from the {@code setBinaryStream (int, InputStream)} 6341 * method because it informs the driver that the parameter value should be 6342 * sent to the server as a {@code BLOB}. When the {@code setBinaryStream} method is used, 6343 * the driver may have to do extra work to determine whether the parameter 6344 * data should be send to the server as a {@code LONGVARBINARY} or a {@code BLOB} 6345 * 6346 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 6347 * it might be more efficient to use a version of 6348 * {@code setBlob} which takes a length parameter. 6349 * 6350 * @param parameterName the name of the parameter 6351 * @param inputStream An object that contains the data to set the parameter 6352 * value to. 6353 * @throws SQLException if a database access error occurs or 6354 * this method is called on a closed {@code CallableStatement} 6355 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6356 * 6357 * @since 1.6 6358 */ 6359 public void setBlob(String parameterName, InputStream inputStream) 6360 throws SQLException{ 6361 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6362 } 6363 6364 /** 6365 * Sets the value of the designated parameter with the given object. The second 6366 * argument must be an object type; for integral values, the 6367 * {@code java.lang} equivalent objects should be used. 6368 * 6369 * <p>The given Java object will be converted to the given targetSqlType 6370 * before being sent to the database. 6371 * 6372 * If the object has a custom mapping (is of a class implementing the 6373 * interface {@code SQLData}), 6374 * the JDBC driver should call the method {@code SQLData.writeSQL} to write it 6375 * to the SQL data stream. 6376 * If, on the other hand, the object is of a class implementing 6377 * {@code Ref}, {@code Blob}, {@code Clob}, {@code NClob}, 6378 * {@code Struct}, {@code java.net.URL}, 6379 * or {@code Array}, the driver should pass it to the database as a 6380 * value of the corresponding SQL type. 6381 * <P> 6382 * Note that this method may be used to pass datatabase- 6383 * specific abstract data types. 6384 * 6385 * @param parameterName the name of the parameter 6386 * @param x the object containing the input parameter value 6387 * @param targetSqlType the SQL type (as defined in java.sql.Types) to be 6388 * sent to the database. The scale argument may further qualify this type. 6389 * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types, 6390 * this is the number of digits after the decimal point. For all other 6391 * types, this value will be ignored. 6392 * @exception SQLException if a database access error occurs or 6393 * this method is called on a closed {@code CallableStatement} 6394 * @exception SQLFeatureNotSupportedException if {@code targetSqlType} is 6395 * an {@code ARRAY, BLOB, CLOB, 6396 * DATALINK, JAVA_OBJECT, NCHAR, 6397 * NCLOB, NVARCHAR, LONGNVARCHAR, 6398 * REF, ROWID, SQLXML} 6399 * or {@code STRUCT} data type and the JDBC driver does not support 6400 * this data type 6401 * @see Types 6402 * @see #getObject 6403 * @since 1.4 6404 */ 6405 public void setObject(String parameterName, Object x, int targetSqlType, int scale) 6406 throws SQLException{ 6407 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6408 } 6409 6410 /** 6411 * Sets the value of the designated parameter with the given object. 6412 * This method is like the method {@code setObject} 6413 * above, except that it assumes a scale of zero. 6414 * 6415 * @param parameterName the name of the parameter 6416 * @param x the object containing the input parameter value 6417 * @param targetSqlType the SQL type (as defined in java.sql.Types) to be 6418 * sent to the database 6419 * @exception SQLException if a database access error occurs or 6420 * this method is called on a closed {@code CallableStatement} 6421 * @exception SQLFeatureNotSupportedException if {@code targetSqlType} is 6422 * an {@code ARRAY, BLOB, CLOB, 6423 * DATALINK, JAVA_OBJECT, NCHAR, 6424 * NCLOB, NVARCHAR, LONGNVARCHAR, 6425 * REF, ROWID, SQLXML} 6426 * or {@code STRUCT} data type and the JDBC driver does not support 6427 * this data type 6428 * @see #getObject 6429 * @since 1.4 6430 */ 6431 public void setObject(String parameterName, Object x, int targetSqlType) 6432 throws SQLException{ 6433 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6434 } 6435 6436 /** 6437 * Sets the value of the designated parameter with the given object. 6438 * The second parameter must be of type {@code Object}; therefore, the 6439 * {@code java.lang} equivalent objects should be used for built-in types. 6440 * 6441 * <p>The JDBC specification specifies a standard mapping from 6442 * Java {@code Object} types to SQL types. The given argument 6443 * will be converted to the corresponding SQL type before being 6444 * sent to the database. 6445 * 6446 * <p>Note that this method may be used to pass datatabase- 6447 * specific abstract data types, by using a driver-specific Java 6448 * type. 6449 * 6450 * If the object is of a class implementing the interface {@code SQLData}, 6451 * the JDBC driver should call the method {@code SQLData.writeSQL} 6452 * to write it to the SQL data stream. 6453 * If, on the other hand, the object is of a class implementing 6454 * {@code Ref}, {@code Blob}, {@code Clob}, {@code NClob}, 6455 * {@code Struct}, {@code java.net.URL}, 6456 * or {@code Array}, the driver should pass it to the database as a 6457 * value of the corresponding SQL type. 6458 * <P> 6459 * This method throws an exception if there is an ambiguity, for example, if the 6460 * object is of a class implementing more than one of the interfaces named above. 6461 * 6462 * @param parameterName the name of the parameter 6463 * @param x the object containing the input parameter value 6464 * @exception SQLException if a database access error occurs, 6465 * this method is called on a closed {@code CallableStatement} or if the given 6466 * {@code Object} parameter is ambiguous 6467 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6468 * this method 6469 * @see #getObject 6470 * @since 1.4 6471 */ 6472 public void setObject(String parameterName, Object x) throws SQLException{ 6473 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6474 } 6475 6476 /** 6477 * Sets the designated parameter to the given input stream, which will have 6478 * the specified number of bytes. 6479 * When a very large ASCII value is input to a {@code LONGVARCHAR} 6480 * parameter, it may be more practical to send it via a 6481 * {@code java.io.InputStream}. Data will be read from the stream 6482 * as needed until end-of-file is reached. The JDBC driver will 6483 * do any necessary conversion from ASCII to the database char format. 6484 * 6485 * <P><B>Note:</B> This stream object can either be a standard 6486 * Java stream object or your own subclass that implements the 6487 * standard interface. 6488 * 6489 * @param parameterName the name of the parameter 6490 * @param x the Java input stream that contains the ASCII parameter value 6491 * @param length the number of bytes in the stream 6492 * @exception SQLException if a database access error occurs or 6493 * this method is called on a closed {@code CallableStatement} 6494 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6495 * this method 6496 * @since 1.4 6497 */ 6498 public void setAsciiStream(String parameterName, java.io.InputStream x, int length) 6499 throws SQLException{ 6500 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6501 } 6502 6503 6504 /** 6505 * Sets the designated parameter to the given input stream, which will have 6506 * the specified number of bytes. 6507 * When a very large binary value is input to a {@code LONGVARBINARY} 6508 * parameter, it may be more practical to send it via a 6509 * {@code java.io.InputStream} object. The data will be read from the stream 6510 * as needed until end-of-file is reached. 6511 * 6512 * <P><B>Note:</B> This stream object can either be a standard 6513 * Java stream object or your own subclass that implements the 6514 * standard interface. 6515 * 6516 * @param parameterName the name of the parameter 6517 * @param x the java input stream which contains the binary parameter value 6518 * @param length the number of bytes in the stream 6519 * @exception SQLException if a database access error occurs or 6520 * this method is called on a closed {@code CallableStatement} 6521 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6522 * this method 6523 * @since 1.4 6524 */ 6525 public void setBinaryStream(String parameterName, java.io.InputStream x, 6526 int length) throws SQLException{ 6527 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6528 } 6529 6530 /** 6531 * Sets the designated parameter to the given {@code Reader} 6532 * object, which is the given number of characters long. 6533 * When a very large UNICODE value is input to a {@code LONGVARCHAR} 6534 * parameter, it may be more practical to send it via a 6535 * {@code java.io.Reader} object. The data will be read from the stream 6536 * as needed until end-of-file is reached. The JDBC driver will 6537 * do any necessary conversion from UNICODE to the database char format. 6538 * 6539 * <P><B>Note:</B> This stream object can either be a standard 6540 * Java stream object or your own subclass that implements the 6541 * standard interface. 6542 * 6543 * @param parameterName the name of the parameter 6544 * @param reader the {@code java.io.Reader} object that 6545 * contains the UNICODE data used as the designated parameter 6546 * @param length the number of characters in the stream 6547 * @exception SQLException if a database access error occurs or 6548 * this method is called on a closed {@code CallableStatement} 6549 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6550 * this method 6551 * @since 1.4 6552 */ 6553 public void setCharacterStream(String parameterName, 6554 java.io.Reader reader, 6555 int length) throws SQLException{ 6556 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6557 } 6558 6559 /** 6560 * Sets the designated parameter to the given input stream. 6561 * When a very large ASCII value is input to a {@code LONGVARCHAR} 6562 * parameter, it may be more practical to send it via a 6563 * {@code java.io.InputStream}. Data will be read from the stream 6564 * as needed until end-of-file is reached. The JDBC driver will 6565 * do any necessary conversion from ASCII to the database char format. 6566 * 6567 * <P><B>Note:</B> This stream object can either be a standard 6568 * Java stream object or your own subclass that implements the 6569 * standard interface. 6570 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 6571 * it might be more efficient to use a version of 6572 * {@code setAsciiStream} which takes a length parameter. 6573 * 6574 * @param parameterName the name of the parameter 6575 * @param x the Java input stream that contains the ASCII parameter value 6576 * @exception SQLException if a database access error occurs or 6577 * this method is called on a closed {@code CallableStatement} 6578 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6579 * @since 1.6 6580 */ 6581 public void setAsciiStream(String parameterName, java.io.InputStream x) 6582 throws SQLException{ 6583 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6584 } 6585 6586 6587 /** 6588 * Sets the designated parameter to the given input stream. 6589 * When a very large binary value is input to a {@code LONGVARBINARY} 6590 * parameter, it may be more practical to send it via a 6591 * {@code java.io.InputStream} object. The data will be read from the 6592 * stream as needed until end-of-file is reached. 6593 * 6594 * <P><B>Note:</B> This stream object can either be a standard 6595 * Java stream object or your own subclass that implements the 6596 * standard interface. 6597 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 6598 * it might be more efficient to use a version of 6599 * {@code setBinaryStream} which takes a length parameter. 6600 * 6601 * @param parameterName the name of the parameter 6602 * @param x the java input stream which contains the binary parameter value 6603 * @exception SQLException if a database access error occurs or 6604 * this method is called on a closed {@code CallableStatement} 6605 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6606 * @since 1.6 6607 */ 6608 public void setBinaryStream(String parameterName, java.io.InputStream x) 6609 throws SQLException{ 6610 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6611 } 6612 6613 /** 6614 * Sets the designated parameter to the given {@code Reader} 6615 * object. 6616 * When a very large UNICODE value is input to a {@code LONGVARCHAR} 6617 * parameter, it may be more practical to send it via a 6618 * {@code java.io.Reader} object. The data will be read from the stream 6619 * as needed until end-of-file is reached. The JDBC driver will 6620 * do any necessary conversion from UNICODE to the database char format. 6621 * 6622 * <P><B>Note:</B> This stream object can either be a standard 6623 * Java stream object or your own subclass that implements the 6624 * standard interface. 6625 * <P><B>Note:</B> Consult your JDBC driver documentation to determine if 6626 * it might be more efficient to use a version of 6627 * {@code setCharacterStream} which takes a length parameter. 6628 * 6629 * @param parameterName the name of the parameter 6630 * @param reader the {@code java.io.Reader} object that contains the 6631 * Unicode data 6632 * @exception SQLException if a database access error occurs or 6633 * this method is called on a closed {@code CallableStatement} 6634 * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method 6635 * @since 1.6 6636 */ 6637 public void setCharacterStream(String parameterName, 6638 java.io.Reader reader) throws SQLException{ 6639 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6640 } 6641 6642 /** 6643 * Sets the designated parameter to the given 6644 * {@code java.math.BigDecimal} value. 6645 * The driver converts this to an SQL {@code NUMERIC} value when 6646 * it sends it to the database. 6647 * 6648 * @param parameterName the name of the parameter 6649 * @param x the parameter value 6650 * @exception SQLException if a database access error occurs or 6651 * this method is called on a closed {@code CallableStatement} 6652 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6653 * this method 6654 * @see #getBigDecimal 6655 * @since 1.4 6656 */ 6657 public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException{ 6658 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6659 } 6660 6661 /** 6662 * Sets the designated parameter to the given Java {@code String} value. 6663 * The driver converts this 6664 * to an SQL {@code VARCHAR} or {@code LONGVARCHAR} value 6665 * (depending on the argument's 6666 * size relative to the driver's limits on {@code VARCHAR} values) 6667 * when it sends it to the database. 6668 * 6669 * @param parameterName the name of the parameter 6670 * @param x the parameter value 6671 * @exception SQLException if a database access error occurs or 6672 * this method is called on a closed {@code CallableStatement} 6673 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6674 * this method 6675 * @see #getString 6676 * @since 1.4 6677 */ 6678 public void setString(String parameterName, String x) throws SQLException{ 6679 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6680 } 6681 6682 6683 6684 /** 6685 * Sets the designated parameter to the given Java array of bytes. 6686 * The driver converts this to an SQL {@code VARBINARY} or 6687 * {@code LONGVARBINARY} (depending on the argument's size relative 6688 * to the driver's limits on {@code VARBINARY} values) when it sends 6689 * it to the database. 6690 * 6691 * @param parameterName the name of the parameter 6692 * @param x the parameter value 6693 * @exception SQLException if a database access error occurs or 6694 * this method is called on a closed {@code CallableStatement} 6695 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6696 * this method 6697 * @see #getBytes 6698 * @since 1.4 6699 */ 6700 public void setBytes(String parameterName, byte x[]) throws SQLException{ 6701 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6702 } 6703 6704 /** 6705 * Sets the designated parameter to the given {@code java.sql.Timestamp} value. 6706 * The driver 6707 * converts this to an SQL {@code TIMESTAMP} value when it sends it to the 6708 * database. 6709 * 6710 * @param parameterName the name of the parameter 6711 * @param x the parameter value 6712 * @exception SQLException if a database access error occurs or 6713 * this method is called on a closed {@code CallableStatement} 6714 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6715 * this method 6716 * @see #getTimestamp 6717 * @since 1.4 6718 */ 6719 public void setTimestamp(String parameterName, java.sql.Timestamp x) 6720 throws SQLException{ 6721 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6722 } 6723 6724 /** 6725 * Sets the designated parameter to SQL {@code NULL}. 6726 * 6727 * <P><B>Note:</B> You must specify the parameter's SQL type. 6728 * 6729 * @param parameterName the name of the parameter 6730 * @param sqlType the SQL type code defined in {@code java.sql.Types} 6731 * @exception SQLException if a database access error occurs or 6732 * this method is called on a closed {@code CallableStatement} 6733 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6734 * this method 6735 * @since 1.4 6736 */ 6737 public void setNull(String parameterName, int sqlType) throws SQLException { 6738 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6739 } 6740 6741 /** 6742 * Sets the designated parameter to SQL {@code NULL}. 6743 * This version of the method {@code setNull} should 6744 * be used for user-defined types and REF type parameters. Examples 6745 * of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and 6746 * named array types. 6747 * 6748 * <P><B>Note:</B> To be portable, applications must give the 6749 * SQL type code and the fully-qualified SQL type name when specifying 6750 * a NULL user-defined or REF parameter. In the case of a user-defined type 6751 * the name is the type name of the parameter itself. For a REF 6752 * parameter, the name is the type name of the referenced type. If 6753 * a JDBC driver does not need the type code or type name information, 6754 * it may ignore it. 6755 * 6756 * Although it is intended for user-defined and Ref parameters, 6757 * this method may be used to set a null parameter of any JDBC type. 6758 * If the parameter does not have a user-defined or REF type, the given 6759 * typeName is ignored. 6760 * 6761 * 6762 * @param parameterName the name of the parameter 6763 * @param sqlType a value from {@code java.sql.Types} 6764 * @param typeName the fully-qualified name of an SQL user-defined type; 6765 * ignored if the parameter is not a user-defined type or 6766 * SQL {@code REF} value 6767 * @exception SQLException if a database access error occurs or 6768 * this method is called on a closed {@code CallableStatement} 6769 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6770 * this method 6771 * @since 1.4 6772 */ 6773 public void setNull (String parameterName, int sqlType, String typeName) 6774 throws SQLException{ 6775 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6776 } 6777 6778 /** 6779 * Sets the designated parameter to the given Java {@code boolean} value. 6780 * The driver converts this 6781 * to an SQL {@code BIT} or {@code BOOLEAN} value when it sends it to the database. 6782 * 6783 * @param parameterName the name of the parameter 6784 * @param x the parameter value 6785 * @exception SQLException if a database access error occurs or 6786 * this method is called on a closed {@code CallableStatement} 6787 * @see #getBoolean 6788 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6789 * this method 6790 * @since 1.4 6791 */ 6792 public void setBoolean(String parameterName, boolean x) throws SQLException{ 6793 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6794 } 6795 6796 6797 6798 /** 6799 * Sets the designated parameter to the given Java {@code byte} value. 6800 * The driver converts this 6801 * to an SQL {@code TINYINT} value when it sends it to the database. 6802 * 6803 * @param parameterName the name of the parameter 6804 * @param x the parameter value 6805 * @exception SQLException if a database access error occurs or 6806 * this method is called on a closed {@code CallableStatement} 6807 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6808 * this method 6809 * @see #getByte 6810 * @since 1.4 6811 */ 6812 public void setByte(String parameterName, byte x) throws SQLException{ 6813 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6814 } 6815 6816 6817 /** 6818 * Sets the designated parameter to the given Java {@code short} value. 6819 * The driver converts this 6820 * to an SQL {@code SMALLINT} value when it sends it to the database. 6821 * 6822 * @param parameterName the name of the parameter 6823 * @param x the parameter value 6824 * @exception SQLException if a database access error occurs or 6825 * this method is called on a closed {@code CallableStatement} 6826 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6827 * this method 6828 * @see #getShort 6829 * @since 1.4 6830 */ 6831 public void setShort(String parameterName, short x) throws SQLException{ 6832 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6833 } 6834 6835 6836 /** 6837 * Sets the designated parameter to the given Java {@code int} value. 6838 * The driver converts this 6839 * to an SQL {@code INTEGER} value when it sends it to the database. 6840 * 6841 * @param parameterName the name of the parameter 6842 * @param x the parameter value 6843 * @exception SQLException if a database access error occurs or 6844 * this method is called on a closed {@code CallableStatement} 6845 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6846 * this method 6847 * @see #getInt 6848 * @since 1.4 6849 */ 6850 public void setInt(String parameterName, int x) throws SQLException{ 6851 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6852 } 6853 6854 /** 6855 * Sets the designated parameter to the given Java {@code long} value. 6856 * The driver converts this 6857 * to an SQL {@code BIGINT} value when it sends it to the database. 6858 * 6859 * @param parameterName the name of the parameter 6860 * @param x the parameter value 6861 * @exception SQLException if a database access error occurs or 6862 * this method is called on a closed {@code CallableStatement} 6863 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6864 * this method 6865 * @see #getLong 6866 * @since 1.4 6867 */ 6868 public void setLong(String parameterName, long x) throws SQLException{ 6869 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6870 } 6871 6872 6873 /** 6874 * Sets the designated parameter to the given Java {@code float} value. 6875 * The driver converts this 6876 * to an SQL {@code FLOAT} value when it sends it to the database. 6877 * 6878 * @param parameterName the name of the parameter 6879 * @param x the parameter value 6880 * @exception SQLException if a database access error occurs or 6881 * this method is called on a closed {@code CallableStatement} 6882 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6883 * this method 6884 * @see #getFloat 6885 * @since 1.4 6886 */ 6887 public void setFloat(String parameterName, float x) throws SQLException{ 6888 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6889 } 6890 6891 /** 6892 * Sets the designated parameter to the given Java {@code double} value. 6893 * The driver converts this 6894 * to an SQL {@code DOUBLE} value when it sends it to the database. 6895 * 6896 * @param parameterName the name of the parameter 6897 * @param x the parameter value 6898 * @exception SQLException if a database access error occurs or 6899 * this method is called on a closed {@code CallableStatement} 6900 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support 6901 * this method 6902 * @see #getDouble 6903 * @since 1.4 6904 */ 6905 public void setDouble(String parameterName, double x) throws SQLException{ 6906 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString()); 6907 } 6908 6909 /** 6910 * This method re populates the resBundle 6911 * during the deserialization process 6912 */ 6913 private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException { 6914 // Default state initialization happens here 6915 ois.defaultReadObject(); 6916 // Initialization of transient Res Bundle happens here . 6917 try { 6918 resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle(); 6919 } catch(IOException ioe) {} 6920 6921 } 6922 6923 static final long serialVersionUID = -3591946023893483003L; 6924 6925 //------------------------- JDBC 4.1 ----------------------------------- 6926 6927 public <T> T getObject(int columnIndex, Class<T> type) throws SQLException { 6928 throw new SQLFeatureNotSupportedException("Not supported yet."); 6929 } 6930 6931 public <T> T getObject(String columnLabel, Class<T> type) throws SQLException { |