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