1 /*
2 * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
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);
148 } catch(SQLException sqle) {
149 System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setshowdeleted").toString() +
150 sqle.getLocalizedMessage());
151 }
152
153 try {
154 setQueryTimeout(0);
155 } catch(SQLException sqle) {
156 System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setquerytimeout").toString() +
157 sqle.getLocalizedMessage());
158 }
159
160 try {
161 setMaxRows(0);
162 } catch(SQLException sqle) {
163 System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setmaxrows").toString() +
164 sqle.getLocalizedMessage());
165 }
166
167 try {
168 setMaxFieldSize(0);
169 } catch(SQLException sqle) {
170 System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setmaxfieldsize").toString() +
171 sqle.getLocalizedMessage());
172 }
173
174 try {
175 setEscapeProcessing(true);
176 } catch(SQLException sqle) {
177 System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setescapeprocessing").toString() +
178 sqle.getLocalizedMessage());
179 }
180
181 try {
182 setConcurrency(ResultSet.CONCUR_UPDATABLE);
183 } catch (SQLException sqle) {
184 System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setconcurrency").toString() +
185 sqle.getLocalizedMessage());
186 }
187
188 setTypeMap(null);
189
190 try {
191 setType(ResultSet.TYPE_SCROLL_INSENSITIVE);
192 } catch(SQLException sqle){
193 System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.settype").toString() +
194 sqle.getLocalizedMessage());
195 }
196
197 setReadOnly(true);
198
199 try {
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);
269 setMaxFieldSize(0);
270
271 setParams();
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.
342
343 setUsername(user);
344 setPassword(password);
345 setUrl(url);
346
347 // set the defaults
348 setShowDeleted(false);
349 setQueryTimeout(0);
350 setMaxRows(0);
351 setMaxFieldSize(0);
352
353 setParams();
354
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();
420 } catch(IOException ioe) {
421 throw new RuntimeException(ioe);
422 }
423
424
425 initParams();
426
427 // get the values from the resultset handle.
428 setShowDeleted(false);
429 setQueryTimeout(0);
430 setMaxRows(0);
431 setMaxFieldSize(0);
432
433 setParams();
434
435 setReadOnly(true);
436 setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
437 setEscapeProcessing(true);
438 setTypeMap(null);
439
440 // Get a handle to ResultSetMetaData
441 // Construct RowSetMetaData out of it.
442
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));
490 md.setTableName(col, rsmd.getTableName(col));
491 md.setCatalogName(col, rsmd.getCatalogName(col));
492 md.setColumnType(col, rsmd.getColumnType(col));
493 md.setColumnTypeName(col, rsmd.getColumnTypeName(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
552 * at us...
553 *
554 */
555
556 prepare();
557
558 // set the properties of our shiny new statement
559 setProperties(ps);
560
561
562 // set the parameters
563 decodeParams(getParams(), ps);
564
565
566 // execute the statement
567 rs = ps.executeQuery();
568
569
570 // notify listeners
571 notifyRowSetChanged();
572
573
574 }
575
576 protected void setProperties(PreparedStatement ps) throws SQLException {
577
578 try {
579 ps.setEscapeProcessing(getEscapeProcessing());
580 } catch (SQLException ex) {
581 System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setescapeprocessing").toString() +
582 ex.getLocalizedMessage());
583 }
584
585 try {
586 ps.setMaxFieldSize(getMaxFieldSize());
587 } catch (SQLException ex) {
588 System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setmaxfieldsize").toString() +
589 ex.getLocalizedMessage());
590 }
591
592 try {
593 ps.setMaxRows(getMaxRows());
594 } catch (SQLException ex) {
595 System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setmaxrows").toString() +
596 ex.getLocalizedMessage());
597 }
598
599 try {
600 ps.setQueryTimeout(getQueryTimeout());
601 } catch (SQLException ex) {
602 System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setquerytimeout").toString() +
603 ex.getLocalizedMessage());
604 }
605
606 }
607
608 private Connection connect() throws SQLException {
609
610 // Get a JDBC connection.
611
612 // First check for Connection handle object as such if
613 // "this" initialized using conn.
614
615 if(conn != null) {
616 return conn;
617
618 } else if (getDataSourceName() != null) {
619
620 // Connect using JNDI.
621 try {
622 Context ctx = new InitialContext();
623 DataSource ds = (DataSource)ctx.lookup
624 (getDataSourceName());
625 //return ds.getConnection(getUsername(),getPassword());
626
627 if(getUsername() != null && !getUsername().equals("")) {
628 return ds.getConnection(getUsername(),getPassword());
629 } else {
630 return ds.getConnection();
631 }
632 }
633 catch (javax.naming.NamingException ex) {
634 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.connect").toString());
635 }
636
637 } else if (getUrl() != null) {
638 // Check only for getUrl() != null because
639 // user, passwd can be null
640 // Connect using the driver manager.
641
642 return DriverManager.getConnection
643 (getUrl(), getUsername(), getPassword());
644 }
645 else {
646 return null;
647 }
648
649 }
650
651
652 protected PreparedStatement prepare() throws SQLException {
653 // get a connection
654 conn = connect();
655
656 try {
657
658 Map<String, Class<?>> aMap = getTypeMap();
659 if( aMap != null) {
660 conn.setTypeMap(aMap);
661 }
662 ps = conn.prepareStatement(getCommand(),ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
663 } catch (SQLException ex) {
664 System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.prepare").toString() +
665 ex.getLocalizedMessage());
666
667 if (ps != null)
668 ps.close();
669 if (conn != null)
670 conn.close();
671
672 throw new SQLException(ex.getMessage());
673 }
674
675 return ps;
676 }
677
678 @SuppressWarnings("deprecation")
679 private void decodeParams(Object[] params, PreparedStatement ps)
680 throws SQLException {
681
682 // There is a corresponding decodeParams in JdbcRowSetImpl
683 // which does the same as this method. This is a design flaw.
684 // Update the CachedRowsetReader.decodeParams when you update
685 // this method.
686
687 // Adding the same comments to CachedRowsetReader.decodeParams.
688
689 int arraySize;
690 Object[] param = null;
691
692 for (int i=0; i < params.length; i++) {
693 if (params[i] instanceof Object[]) {
694 param = (Object[])params[i];
695
696 if (param.length == 2) {
697 if (param[0] == null) {
698 ps.setNull(i + 1, ((Integer)param[1]).intValue());
699 continue;
700 }
701
702 if (param[0] instanceof java.sql.Date ||
703 param[0] instanceof java.sql.Time ||
704 param[0] instanceof java.sql.Timestamp) {
705 System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.detecteddate"));
706 if (param[1] instanceof java.util.Calendar) {
707 System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.detectedcalendar"));
708 ps.setDate(i + 1, (java.sql.Date)param[0],
709 (java.util.Calendar)param[1]);
710 continue;
711 }
712 else {
713 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.paramtype").toString());
714 }
715 }
716
717 if (param[0] instanceof Reader) {
718 ps.setCharacterStream(i + 1, (Reader)param[0],
719 ((Integer)param[1]).intValue());
720 continue;
721 }
722
723 /*
724 * What's left should be setObject(int, Object, scale)
725 */
726 if (param[1] instanceof Integer) {
727 ps.setObject(i + 1, param[0], ((Integer)param[1]).intValue());
728 continue;
729 }
730
731 } else if (param.length == 3) {
732
733 if (param[0] == null) {
734 ps.setNull(i + 1, ((Integer)param[1]).intValue(),
735 (String)param[2]);
736 continue;
737 }
738
739 if (param[0] instanceof java.io.InputStream) {
740 switch (((Integer)param[2]).intValue()) {
741 case JdbcRowSetImpl.UNICODE_STREAM_PARAM:
742 ps.setUnicodeStream(i + 1,
743 (java.io.InputStream)param[0],
744 ((Integer)param[1]).intValue());
745 break;
746 case JdbcRowSetImpl.BINARY_STREAM_PARAM:
747 ps.setBinaryStream(i + 1,
748 (java.io.InputStream)param[0],
749 ((Integer)param[1]).intValue());
750 break;
751 case JdbcRowSetImpl.ASCII_STREAM_PARAM:
752 ps.setAsciiStream(i + 1,
753 (java.io.InputStream)param[0],
754 ((Integer)param[1]).intValue());
755 break;
756 default:
757 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.paramtype").toString());
758 }
759 }
760
761 /*
762 * no point at looking at the first element now;
763 * what's left must be the setObject() cases.
764 */
765 if (param[1] instanceof Integer && param[2] instanceof Integer) {
766 ps.setObject(i + 1, param[0], ((Integer)param[1]).intValue(),
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 this 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 this 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 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 }
4596
4597 /**
4598 * Retrieves whether this ResultSet object has been closed. A ResultSet is closed if the
4599 * method close has been called on it, or if it is automatically closed.
4600 * @return true if this ResultSet object is closed; false if it is still open
4601 * @throws SQLException if a database access error occurs
4602 * @since 1.6
4603 */
4604 public boolean isClosed() throws SQLException {
4605 throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
4606 }
4607
4608 /**
4609 * This method is used for updating columns that support National Character sets.
4610 * It can be used for updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
4611 * @param columnIndex the first column is 1, the second 2, ...
4612 * @param nString the value for the column to be updated
4613 * @throws SQLException if a database access error occurs
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 {
6911 throw new SQLFeatureNotSupportedException("Not supported yet.");
6912 }
6913 }