Source code: jdbc/db/TestResultSetImpl.java
1 /**
2 * Redistribution and use of this software and associated documentation
3 * ("Software"), with or without modification, are permitted provided
4 * that the following conditions are met:
5 *
6 * 1. Redistributions of source code must retain copyright
7 * statements and notices. Redistributions must also contain a
8 * copy of this document.
9 *
10 * 2. Redistributions in binary form must reproduce the
11 * above copyright notice, this list of conditions and the
12 * following disclaimer in the documentation and/or other
13 * materials provided with the distribution.
14 *
15 * 3. The name "Exolab" must not be used to endorse or promote
16 * products derived from this Software without prior written
17 * permission of Intalio Technologies. For written permission,
18 * please contact info@exolab.org.
19 *
20 * 4. Products derived from this Software may not be called "Exolab"
21 * nor may "Exolab" appear in their names without prior written
22 * permission of Intalio Technologies. Exolab is a registered
23 * trademark of Intalio Technologies.
24 *
25 * 5. Due credit should be given to the Exolab Project
26 * (http://www.exolab.org/).
27 *
28 * THIS SOFTWARE IS PROVIDED BY EXOFFICE TECHNOLOGIES AND CONTRIBUTORS
29 * ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
30 * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
31 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
32 * EXOFFICE TECHNOLOGIES OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
33 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
34 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
35 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
36 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
37 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
38 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
39 * OF THE POSSIBILITY OF SUCH DAMAGE.
40 *
41 * Copyright 2000 (C) Intalio Technologies Inc. All Rights Reserved.
42 *
43 */
44
45
46 package jdbc.db;
47
48 import java.math.BigDecimal;
49 import java.sql.*;
50 import java.util.*;
51
52 /////////////////////////////////////////////////////////////////////
53 // TestResultSetImpl
54 /////////////////////////////////////////////////////////////////////
55
56 /**
57 * Test implementation of java.sql.ResultSet.
58 * The result set is always empty.
59 *
60 * @author <a href="mohammed@intalio.com">Riad Mohammed</a>
61 */
62 public final class TestResultSetImpl
63 implements ResultSet
64 {
65 /**
66 * The statement
67 */
68 private TestStatementImpl _statement;
69
70
71 /**
72 * Create the TestResultSetImpl
73 *
74 * @param statement the statement
75 */
76 TestResultSetImpl(TestStatementImpl statement)
77 {
78 if (null == statement) {
79 throw new IllegalArgumentException("The argument 'statement' is null.");
80 }
81 _statement = statement;
82 }
83
84 /**
85 * Return false - result set is empty.
86 *
87 * @return false
88 * @exception SQLException
89 */
90 public boolean next()
91 throws SQLException
92 {
93 return false;
94 }
95
96
97 /**
98 * Does nothing
99 *
100 * @exception SQLException
101 */
102 public void close()
103 throws SQLException
104 {
105
106 }
107
108 /**
109 * Not supported. Throws SQLException.
110 *
111 * @exception SQLException
112 */
113 public boolean wasNull()
114 throws SQLException
115 {
116 throw new SQLException("wasNull method not supported.");
117 }
118
119 //======================================================================
120 // Methods for accessing results by column index
121 //======================================================================
122
123 /**
124 * Not supported. Throws SQLException.
125 *
126 * @param columnIndex the first column is 1, the second is 2, ...
127 * @exception SQLException
128 */
129 public String getString(int columnIndex)
130 throws SQLException
131 {
132 throw new SQLException("getString method not supported.");
133 }
134
135 /**
136 * Not supported. Throws SQLException.
137 *
138 * @param columnIndex the first column is 1, the second is 2, ...
139 * @exception SQLException
140 */
141 public boolean getBoolean(int columnIndex)
142 throws SQLException
143 {
144 throw new SQLException("getBoolean method not supported.");
145 }
146
147 /**
148 * Not supported. Throws SQLException.
149 *
150 * @param columnIndex the first column is 1, the second is 2, ...
151 * @exception SQLException
152 */
153 public byte getByte(int columnIndex)
154 throws SQLException
155 {
156 throw new SQLException("getByte method not supported.");
157 }
158
159 /**
160 * Not supported. Throws SQLException.
161 *
162 * @param columnIndex the first column is 1, the second is 2, ...
163 * @exception SQLException
164 */
165 public short getShort(int columnIndex)
166 throws SQLException
167 {
168 throw new SQLException("getShort method not supported.");
169 }
170
171 /**
172 * Not supported. Throws SQLException.
173 *
174 * @param columnIndex the first column is 1, the second is 2, ...
175 * @exception SQLException
176 */
177 public int getInt(int columnIndex)
178 throws SQLException
179 {
180 throw new SQLException("getInt method not supported.");
181 }
182
183 /**
184 * Not supported. Throws SQLException.
185 *
186 * @param columnIndex the first column is 1, the second is 2, ...
187 * @exception SQLException
188 */
189 public long getLong(int columnIndex)
190 throws SQLException
191 {
192 throw new SQLException("getLong method not supported.");
193 }
194
195 /**
196 * Not supported. Throws SQLException.
197 *
198 * @param columnIndex the first column is 1, the second is 2, ...
199 * @exception SQLException
200 */
201 public float getFloat(int columnIndex)
202 throws SQLException
203 {
204 throw new SQLException("getFloat method not supported.");
205 }
206
207 /**
208 * Not supported. Throws SQLException.
209 *
210 * @param columnIndex the first column is 1, the second is 2, ...
211 * @exception SQLException
212 */
213 public double getDouble(int columnIndex)
214 throws SQLException
215 {
216 throw new SQLException("getDouble method not supported.");
217 }
218
219 /**
220 * Not supported. Throws SQLException.
221 *
222 * @param columnIndex the first column is 1, the second is 2, ...
223 * @param scale the number of digits to the right of the decimal point
224 * @exception SQLException
225 * @deprecated
226 */
227 public BigDecimal getBigDecimal(int columnIndex, int scale)
228 throws SQLException
229 {
230 throw new SQLException("getBigDecimal method not supported.");
231 }
232
233 /**
234 * Not supported. Throws SQLException.
235 *
236 * @param columnIndex the first column is 1, the second is 2, ...
237 * @exception SQLException
238 */
239 public byte[] getBytes(int columnIndex)
240 throws SQLException
241 {
242 throw new SQLException("getBytes method not supported.");
243 }
244
245 /**
246 * Not supported. Throws SQLException.
247 *
248 * @param columnIndex the first column is 1, the second is 2, ...
249 * @exception SQLException
250 */
251 public java.sql.Date getDate(int columnIndex)
252 throws SQLException
253 {
254 throw new SQLException("getDate method not supported.");
255 }
256
257 /**
258 * Gets the value of the designated column in the current row
259 * of this <code>ResultSet</code> object as
260 * a <code>java.sql.Time</code> object in the Java programming language.
261 *
262 * @param columnIndex the first column is 1, the second is 2, ...
263 * @return the column value; if the value is SQL <code>NULL</code>, the
264 * value returned is <code>null</code>
265 * @exception SQLException
266 */
267 public java.sql.Time getTime(int columnIndex)
268 throws SQLException
269 {
270 throw new SQLException("getTime method not supported.");
271 }
272
273 /**
274 * Gets the value of the designated column in the current row
275 * of this <code>ResultSet</code> object as
276 * a <code>java.sql.Timestamp</code> object in the Java programming language.
277 *
278 * @param columnIndex the first column is 1, the second is 2, ...
279 * @return the column value; if the value is SQL <code>NULL</code>, the
280 * value returned is <code>null</code>
281 * @exception SQLException
282 */
283 public java.sql.Timestamp getTimestamp(int columnIndex)
284 throws SQLException
285 {
286 throw new SQLException("getTimestamp method not supported.");
287 }
288
289 /**
290 * Gets the value of the designated column in the current row
291 * of this <code>ResultSet</code> object as
292 * a stream of ASCII characters. The value can then be read in chunks from the
293 * stream. This method is particularly
294 * suitable for retrieving large <char>LONGVARCHAR</char> values.
295 * The JDBC driver will
296 * do any necessary conversion from the database format into ASCII.
297 *
298 * <P><B>Note:</B> All the data in the returned stream must be
299 * read prior to getting the value of any other column. The next
300 * call to a <code>getXXX</code> method implicitly closes the stream. Also, a
301 * stream may return <code>0</code> when the method
302 * <code>InputStream.available</code>
303 * is called whether there is data available or not.
304 *
305 * @param columnIndex the first column is 1, the second is 2, ...
306 * @return a Java input stream that delivers the database column value
307 * as a stream of one-byte ASCII characters;
308 * if the value is SQL <code>NULL</code>, the
309 * value returned is <code>null</code>
310 * @exception SQLException
311 */
312 public java.io.InputStream getAsciiStream(int columnIndex)
313 throws SQLException
314 {
315 throw new SQLException("getAsciiStream method not supported.");
316 }
317
318 /**
319 * Gets the value of a column in the current row as a stream of
320 * Gets the value of the designated column in the current row
321 * of this <code>ResultSet</code> object as
322 * as a stream of Unicode characters.
323 * The value can then be read in chunks from the
324 * stream. This method is particularly
325 * suitable for retrieving large<code>LONGVARCHAR</code>values. The JDBC driver will
326 * do any necessary conversion from the database format into Unicode.
327 * The byte format of the Unicode stream must be Java UTF-8,
328 * as specified in the Java virtual machine specification.
329 *
330 * <P><B>Note:</B> All the data in the returned stream must be
331 * read prior to getting the value of any other column. The next
332 * call to a <code>getXXX</code> method implicitly closes the stream. Also, a
333 * stream may return <code>0</code> when the method
334 * <code>InputStream.available</code>
335 * is called whether there is data available or not.
336 *
337 * @param columnIndex the first column is 1, the second is 2, ...
338 * @return a Java input stream that delivers the database column value
339 * as a stream in Java UTF-8 byte format;
340 * if the value is SQL <code>NULL</code>, the value returned is <code>null</code>
341 * @exception SQLException
342 * @deprecated use <code>getCharacterStream</code> in place of
343 * <code>getUnicodeStream</code>
344 */
345 public java.io.InputStream getUnicodeStream(int columnIndex)
346 throws SQLException
347 {
348 throw new SQLException("getUnicodeStream method not supported.");
349 }
350
351 /**
352 * Gets the value of a column in the current row as a stream of
353 * Gets the value of the designated column in the current row
354 * of this <code>ResultSet</code> object as a binary stream of
355 * uninterpreted bytes. The value can then be read in chunks from the
356 * stream. This method is particularly
357 * suitable for retrieving large <code>LONGVARBINARY</code> values.
358 *
359 * <P><B>Note:</B> All the data in the returned stream must be
360 * read prior to getting the value of any other column. The next
361 * call to a <code>getXXX</code> method implicitly closes the stream. Also, a
362 * stream may return <code>0</code> when the method
363 * <code>InputStream.available</code>
364 * is called whether there is data available or not.
365 *
366 * @param columnIndex the first column is 1, the second is 2, ...
367 * @return a Java input stream that delivers the database column value
368 * as a stream of uninterpreted bytes;
369 * if the value is SQL <code>NULL</code>, the value returned is <code>null</code>
370 * @exception SQLException
371 */
372 public java.io.InputStream getBinaryStream(int columnIndex)
373 throws SQLException
374 {
375 throw new SQLException("getBinaryStream method not supported.");
376 }
377
378
379 //======================================================================
380 // Methods for accessing results by column name
381 //======================================================================
382
383 /**
384 * Gets the value of the designated column in the current row
385 * of this <code>ResultSet</code> object as
386 * a <code>String</code> in the Java programming language.
387 *
388 * @param columnName the SQL name of the column
389 * @return the column value; if the value is SQL <code>NULL</code>, the
390 * value returned is <code>null</code>
391 * @exception SQLException
392 */
393 public String getString(String columnName)
394 throws SQLException
395 {
396 throw new SQLException("getString method not supported.");
397 }
398
399 /**
400 * Gets the value of the designated column in the current row
401 * of this <code>ResultSet</code> object as
402 * a <code>boolean</code> in the Java programming language.
403 *
404 * @param columnName the SQL name of the column
405 * @return the column value; if the value is SQL <code>NULL</code>, the
406 * value returned is <code>false</code>
407 * @exception SQLException
408 */
409 public boolean getBoolean(String columnName)
410 throws SQLException
411 {
412 throw new SQLException("getBoolean method not supported.");
413 }
414
415 /**
416 * Gets the value of the designated column in the current row
417 * of this <code>ResultSet</code> object as
418 * a <code>byte</code> in the Java programming language.
419 *
420 * @param columnName the SQL name of the column
421 * @return the column value; if the value is SQL <code>NULL</code>, the
422 * value returned is <code>0</code>
423 * @exception SQLException
424 */
425 public byte getByte(String columnName)
426 throws SQLException
427 {
428 throw new SQLException("getByte method not supported.");
429 }
430
431 /**
432 * Gets the value of the designated column in the current row
433 * of this <code>ResultSet</code> object as
434 * a <code>short</code> in the Java programming language.
435 *
436 * @param columnName the SQL name of the column
437 * @return the column value; if the value is SQL <code>NULL</code>, the
438 * value returned is <code>0</code>
439 * @exception SQLException
440 */
441 public short getShort(String columnName)
442 throws SQLException
443 {
444 throw new SQLException("getShort method not supported.");
445 }
446
447 /**
448 * Gets the value of the designated column in the current row
449 * of this <code>ResultSet</code> object as
450 * an <code>int</code> in the Java programming language.
451 *
452 * @param columnName the SQL name of the column
453 * @return the column value; if the value is SQL <code>NULL</code>, the
454 * value returned is <code>0</code>
455 * @exception SQLException
456 */
457 public int getInt(String columnName)
458 throws SQLException
459 {
460 throw new SQLException("getInt method not supported.");
461 }
462
463 /**
464 * Gets the value of the designated column in the current row
465 * of this <code>ResultSet</code> object as
466 * a <code>long</code> in the Java programming language.
467 *
468 * @param columnName the SQL name of the column
469 * @return the column value; if the value is SQL <code>NULL</code>, the
470 * value returned is <code>0</code>
471 * @exception SQLException
472 */
473 public long getLong(String columnName)
474 throws SQLException
475 {
476 throw new SQLException("getLong method not supported.");
477 }
478
479 /**
480 * Gets the value of the designated column in the current row
481 * of this <code>ResultSet</code> object as
482 * a <code>float</code> in the Java programming language.
483 *
484 * @param columnName the SQL name of the column
485 * @return the column value; if the value is SQL <code>NULL</code>, the
486 * value returned is <code>0</code>
487 * @exception SQLException
488 */
489 public float getFloat(String columnName)
490 throws SQLException
491 {
492 throw new SQLException("getFloat method not supported.");
493 }
494
495 /**
496 * Gets the value of the designated column in the current row
497 * of this <code>ResultSet</code> object as
498 * a <code>double</code> in the Java programming language.
499 *
500 * @param columnName the SQL name of the column
501 * @return the column value; if the value is SQL <code>NULL</code>, the
502 * value returned is <code>0</code>
503 * @exception SQLException
504 */
505 public double getDouble(String columnName)
506 throws SQLException
507 {
508 throw new SQLException("getDouble method not supported.");
509 }
510
511 /**
512 * Gets the value of the designated column in the current row
513 * of this <code>ResultSet</code> object as
514 * a <code>java.math.BigDecimal</code> in the Java programming language.
515 *
516 * @param columnName the SQL name of the column
517 * @param scale the number of digits to the right of the decimal point
518 * @return the column value; if the value is SQL <code>NULL</code>, the
519 * value returned is <code>null</code>
520 * @exception SQLException
521 * @deprecated
522 */
523 public BigDecimal getBigDecimal(String columnName, int scale)
524 throws SQLException
525 {
526 throw new SQLException("getBigDecimal method not supported.");
527 }
528
529 /**
530 * Gets the value of the designated column in the current row
531 * of this <code>ResultSet</code> object as
532 * a <code>byte</code> array in the Java programming language.
533 * The bytes represent the raw values returned by the driver.
534 *
535 * @param columnName the SQL name of the column
536 * @return the column value; if the value is SQL <code>NULL</code>, the
537 * value returned is <code>null</code>
538 * @exception SQLException
539 */
540 public byte[] getBytes(String columnName)
541 throws SQLException
542 {
543 throw new SQLException("getBytes method not supported.");
544 }
545
546 /**
547 * Gets the value of the designated column in the current row
548 * of this <code>ResultSet</code> object as
549 * a <code>java.sql.Date</code> object 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>null</code>
554 * @exception SQLException
555 */
556 public java.sql.Date getDate(String columnName)
557 throws SQLException
558 {
559 throw new SQLException("getDate method not supported.");
560 }
561
562 /**
563 * Gets the value of the designated column in the current row
564 * of this <code>ResultSet</code> object as
565 * a <code>java.sql.Time</code> object in the Java programming language.
566 *
567 * @param columnName the SQL name of the column
568 * @return the column value;
569 * if the value is SQL <code>NULL</code>,
570 * the value returned is <code>null</code>
571 * @exception SQLException
572 */
573 public java.sql.Time getTime(String columnName)
574 throws SQLException
575 {
576 throw new SQLException("getTime method not supported.");
577 }
578
579 /**
580 * Gets the value of the designated column in the current row
581 * of this <code>ResultSet</code> object as
582 * a <code>java.sql.Timestamp</code> object.
583 *
584 * @param columnName the SQL name of the column
585 * @return the column value; if the value is SQL <code>NULL</code>, the
586 * value returned is <code>null</code>
587 * @exception SQLException
588 */
589 public java.sql.Timestamp getTimestamp(String columnName)
590 throws SQLException
591 {
592 throw new SQLException("getTimestamp method not supported.");
593 }
594
595 /**
596 * Gets the value of the designated column in the current row
597 * of this <code>ResultSet</code> object as a stream of
598 * ASCII characters. The value can then be read in chunks from the
599 * stream. This method is particularly
600 * suitable for retrieving large <code>LONGVARCHAR</code> values.
601 * The JDBC driver will
602 * do any necessary conversion from the database format into ASCII.
603 *
604 * <P><B>Note:</B> All the data in the returned stream must be
605 * read prior to getting the value of any other column. The next
606 * call to a <code>getXXX</code> method implicitly closes the stream. Also, a
607 * stream may return <code>0</code> when the method <code>available</code>
608 * is called whether there is data available or not.
609 *
610 * @param columnName the SQL name of the column
611 * @return a Java input stream that delivers the database column value
612 * as a stream of one-byte ASCII characters.
613 * If the value is SQL <code>NULL</code>,
614 * the value returned is <code>null</code>.
615 * @exception SQLException
616 */
617 public java.io.InputStream getAsciiStream(String columnName)
618 throws SQLException
619 {
620 throw new SQLException("getAsciiStream method not supported.");
621 }
622
623 /**
624 * Gets the value of the designated column in the current row
625 * of this <code>ResultSet</code> object as a stream of
626 * Unicode characters. The value can then be read in chunks from the
627 * stream. This method is particularly
628 * suitable for retrieving large <code>LONGVARCHAR</code> values.
629 * The JDBC driver will
630 * do any necessary conversion from the database format into Unicode.
631 * The byte format of the Unicode stream must be Java UTF-8,
632 * as defined in the Java virtual machine specification.
633 *
634 * <P><B>Note:</B> All the data in the returned stream must be
635 * read prior to getting the value of any other column. The next
636 * call to a <code>getXXX</code> method implicitly closes the stream. Also, a
637 * stream may return <code>0</code> when the method <code>available</code>
638 * is called whether there is data available or not.
639 *
640 * @param columnName the SQL name of the column
641 * @return a Java input stream that delivers the database column value
642 * as a stream of two-byte Unicode characters.
643 * If the value is SQL <code>NULL</code>,
644 * the value returned is <code>null</code>.
645 * @exception SQLException
646 * @deprecated
647 */
648 public java.io.InputStream getUnicodeStream(String columnName)
649 throws SQLException
650 {
651 throw new SQLException("getUnicodeStream method not supported.");
652 }
653
654 /**
655 * Gets the value of the designated column in the current row
656 * of this <code>ResultSet</code> object as a stream of uninterpreted
657 * <code>byte</code>s.
658 * The value can then be read in chunks from the
659 * stream. This method is particularly
660 * suitable for retrieving large <code>LONGVARBINARY</code>
661 * values.
662 *
663 * <P><B>Note:</B> All the data in the returned stream must be
664 * read prior to getting the value of any other column. The next
665 * call to a <code>getXXX</code> method implicitly closes the stream. Also, a
666 * stream may return <code>0</code> when the method <code>available</code>
667 * is called whether there is data available or not.
668 *
669 * @param columnName the SQL name of the column
670 * @return a Java input stream that delivers the database column value
671 * as a stream of uninterpreted bytes;
672 * if the value is SQL <code>NULL</code>, the result is <code>null</code>
673 * @exception SQLException
674 */
675 public java.io.InputStream getBinaryStream(String columnName)
676 throws SQLException
677 {
678 throw new SQLException("getBinaryStream method not supported.");
679 }
680
681
682 //=====================================================================
683 // Advanced features:
684 //=====================================================================
685
686 /**
687 * Returns the first warning reported by calls on this
688 * <code>ResultSet</code> object.
689 * Subsequent warnings on this <code>ResultSet</code> object
690 * will be chained to the <code>SQLWarning</code> object that
691 * this method returns.
692 *
693 * <P>The warning chain is automatically cleared each time a new
694 * row is read.
695 *
696 * <P><B>Note:</B> This warning chain only covers warnings caused
697 * by <code>ResultSet</code> methods. Any warning caused by
698 * <code>Statement</code> methods
699 * (such as reading OUT parameters) will be chained on the
700 * <code>Statement</code> object.
701 *
702 * @return the first <code>SQLWarning</code> object reported or <code>null</code>
703 * @exception SQLException
704 */
705 public SQLWarning getWarnings()
706 throws SQLException
707 {
708 throw new SQLException("getWarnings method not supported.");
709 }
710
711 /**
712 * Clears all warnings reported on this <code>ResultSet</code> object.
713 * After this method is called, the method <code>getWarnings</code>
714 * returns <code>null</code> until a new warning is
715 * reported for this <code>ResultSet</code> object.
716 *
717 * @exception SQLException
718 */
719 public void clearWarnings()
720 throws SQLException
721 {
722 throw new SQLException("clearWarnings method not supported.");
723 }
724
725 /**
726 * Gets the name of the SQL cursor used by this <code>ResultSet</code>
727 * object.
728 *
729 * <P>In SQL, a result table is retrieved through a cursor that is
730 * named. The current row of a result set can be updated or deleted
731 * using a positioned update/delete statement that references the
732 * cursor name. To insure that the cursor has the proper isolation
733 * level to support update, the cursor's <code>select</code> statement should be
734 * of the form 'select for update'. If the 'for update' clause is
735 * omitted, the positioned updates may fail.
736 *
737 * <P>The JDBC API supports this SQL feature by providing the name of the
738 * SQL cursor used by a <code>ResultSet</code> object.
739 * The current row of a <code>ResultSet</code> object
740 * is also the current row of this SQL cursor.
741 *
742 * <P><B>Note:</B> If positioned update is not supported, a
743 * <code>SQLException</code> is thrown.
744 *
745 * @return the SQL name for this <code>ResultSet</code> object's cursor
746 * @exception SQLException
747 */
748 public String getCursorName()
749 throws SQLException
750 {
751 throw new SQLException("getCursorName method not supported.");
752 }
753
754 /**
755 * Retrieves the number, types and properties of
756 * this <code>ResultSet</code> object's columns.
757 *
758 * @return the description of this <code>ResultSet</code> object's columns
759 * @exception SQLException
760 */
761 public ResultSetMetaData getMetaData()
762 throws SQLException
763 {
764 throw new SQLException("getMetaData method not supported.");
765 }
766
767 /**
768 * <p>Gets the value of the designated column in the current row
769 * of this <code>ResultSet</code> object as
770 * an <code>Object</code> in the Java programming language.
771 *
772 * <p>This method will return the value of the given column as a
773 * Java object. The type of the Java object will be the default
774 * Java object type corresponding to the column's SQL type,
775 * following the mapping for built-in types specified in the JDBC
776 * specification.
777 *
778 * <p>This method may also be used to read datatabase-specific
779 * abstract data types.
780 *
781 * In the JDBC 2.0 API, the behavior of method
782 * <code>getObject</code> is extended to materialize
783 * data of SQL user-defined types. When a column contains
784 * a structured or distinct value, the behavior of this method is as
785 * if it were a call to: <code>getObject(columnIndex,
786 * this.getStatement().getConnection().getTypeMap())</code>.
787 *
788 * @param columnIndex the first column is 1, the second is 2, ...
789 * @return a <code>java.lang.Object</code> holding the column value
790 * @exception SQLException
791 */
792 public Object getObject(int columnIndex)
793 throws SQLException
794 {
795 throw new SQLException("getObject method not supported.");
796 }
797
798 /**
799 * <p>Gets the value of the designated column in the current row
800 * of this <code>ResultSet</code> object as
801 * an <code>Object</code> in the Java programming language.
802 *
803 * <p>This method will return the value of the given column as a
804 * Java object. The type of the Java object will be the default
805 * Java object type corresponding to the column's SQL type,
806 * following the mapping for built-in types specified in the JDBC
807 * specification.
808 *
809 * <p>This method may also be used to read datatabase-specific
810 * abstract data types.
811 *
812 * In the JDBC 2.0 API, the behavior of the method
813 * <code>getObject</code> is extended to materialize
814 * data of SQL user-defined types. When a column contains
815 * a structured or distinct value, the behavior of this method is as
816 * if it were a call to: <code>getObject(columnIndex,
817 * this.getStatement().getConnection().getTypeMap())</code>.
818 *
819 * @param columnName the SQL name of the column
820 * @return a <code>java.lang.Object</code> holding the column value
821 * @exception SQLException
822 */
823 public Object getObject(String columnName)
824 throws SQLException
825 {
826 throw new SQLException("getObject method not supported.");
827 }
828
829 //----------------------------------------------------------------
830
831 /**
832 * Maps the given <code>ResultSet</code> column name to its
833 * <code>ResultSet</code> column index.
834 *
835 * @param columnName the name of the column
836 * @return the column index of the given column name
837 * @exception SQLException
838 */
839 public int findColumn(String columnName)
840 throws SQLException
841 {
842 throw new SQLException("findColumn method not supported.");
843 }
844
845
846 //--------------------------JDBC 2.0-----------------------------------
847
848 //---------------------------------------------------------------------
849 // Getters and Setters
850 //---------------------------------------------------------------------
851
852 /**
853 * Gets the value of the designated column in the current row
854 * of this <code>ResultSet</code> object as a
855 * <code>java.io.Reader</code> object.
856 * @return a <code>java.io.Reader</code> object that contains the column
857 * value; if the value is SQL <code>NULL</code>, the value returned is
858 * <code>null</code> in the Java programming language.
859 * @param columnIndex the first column is 1, the second is 2, ...
860 * @since 1.2
861 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
862 * 2.0 API</a>
863 */
864 public java.io.Reader getCharacterStream(int columnIndex)
865 throws SQLException
866 {
867 throw new SQLException("getCharacterStream method not supported.");
868 }
869
870 /**
871 * Gets the value of the designated column in the current row
872 * of this <code>ResultSet</code> object as a
873 * <code>java.io.Reader</code> object.
874 *
875 * @return a <code>java.io.Reader</code> object that contains the column
876 * value; if the value is SQL <code>NULL</code>, the value returned is
877 * <code>null</code> in the Java programming language.
878 * @param columnName the name of the column
879 * @return the value in the specified column as a <code>java.io.Reader</code>
880 * @since 1.2
881 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
882 * 2.0 API</a>
883 */
884 public java.io.Reader getCharacterStream(String columnName)
885 throws SQLException
886 {
887 throw new SQLException("getCharacterStream method not supported.");
888 }
889
890 /**
891 * Gets the value of the designated column in the current row
892 * of this <code>ResultSet</code> object as a
893 * <code>java.math.BigDecimal</code> with full precision.
894 *
895 * @param columnIndex the first column is 1, the second is 2, ...
896 * @return the column value (full precision);
897 * if the value is SQL <code>NULL</code>, the value returned is
898 * <code>null</code> in the Java programming language.
899 * @exception SQLException
900 * @since 1.2
901 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
902 * 2.0 API</a>
903 */
904 public BigDecimal getBigDecimal(int columnIndex)
905 throws SQLException
906 {
907 throw new SQLException("getBigDecimal method not supported.");
908 }
909
910 /**
911 * Gets the value of the designated column in the current row
912 * of this <code>ResultSet</code> object as a
913 * <code>java.math.BigDecimal</code> with full precision.
914 *
915 * @param columnName the column name
916 * @return the column value (full precision);
917 * if the value is SQL <code>NULL</code>, the value returned is
918 * <code>null</code> in the Java programming language.
919 * @exception SQLException
920 * @since 1.2
921 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
922 * 2.0 API</a>
923 *
924 */
925 public BigDecimal getBigDecimal(String columnName)
926 throws SQLException
927 {
928 throw new SQLException("getBigDecimal method not supported.");
929 }
930
931 //---------------------------------------------------------------------
932 // Traversal/Positioning
933 //---------------------------------------------------------------------
934
935 /**
936 * Indicates whether the cursor is before the first row in
937 * this <code>ResultSet</code> object.
938 *
939 * @return <code>true</code> if the cursor is before the first row;
940 * <code>false</code> if the cursor is at any other position or the
941 * result set contains no rows
942 * @exception SQLException
943 * @since 1.2
944 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
945 * 2.0 API</a>
946 */
947 public boolean isBeforeFirst()
948 throws SQLException
949 {
950 return false;
951 }
952
953 /**
954 * Indicates whether the cursor is after the last row in
955 * this <code>ResultSet</code> object.
956 *
957 * @return <code>true</code> if the cursor is after the last row;
958 * <code>false</code> if the cursor is at any other position or the
959 * result set contains no rows
960 * @exception SQLException
961 * @since 1.2
962 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
963 * 2.0 API</a>
964 */
965 public boolean isAfterLast()
966 throws SQLException
967 {
968 return false;
969 }
970
971 /**
972 * Indicates whether the cursor is on the first row of
973 * this <code>ResultSet</code> object.
974 *
975 * @return <code>true</code> if the cursor is on the first row;
976 * <code>false</code> otherwise
977 * @exception SQLException
978 * @since 1.2
979 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
980 * 2.0 API</a>
981 */
982 public boolean isFirst()
983 throws SQLException
984 {
985 return false;
986 }
987
988 /**
989 * Indicates whether the cursor is on the last row of
990 * this <code>ResultSet</code> object.
991 * Note: Calling the method <code>isLast</code> may be expensive
992 * because the JDBC driver
993 * might need to fetch ahead one row in order to determine
994 * whether the current row is the last row in the result set.
995 *
996 * @return <code>true</code> if the cursor is on the last row;
997 * <code>false</code> otherwise
998 * @exception SQLException
999 * @since 1.2
1000 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1001 * 2.0 API</a>
1002 */
1003 public boolean isLast()
1004 throws SQLException
1005 {
1006 return false;
1007 }
1008
1009 /**
1010 * Moves the cursor to the front of
1011 * this <code>ResultSet</code> object, just before the
1012 * first row. This method has no effect if the result set contains no rows.
1013 *
1014 * @exception SQLException if a database access error
1015 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1016 * @since 1.2
1017 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1018 * 2.0 API</a>
1019 */
1020 public void beforeFirst()
1021 throws SQLException
1022 {
1023 throw new SQLException("beforeFirst method not supported.");
1024 }
1025
1026 /**
1027 * Moves the cursor to the end of
1028 * this <code>ResultSet</code> object, just after the
1029 * last row. This method has no effect if the result set contains no rows.
1030 * @exception SQLException if a database access error
1031 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1032 * @since 1.2
1033 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1034 * 2.0 API</a>
1035 */
1036 public void afterLast()
1037 throws SQLException
1038 {
1039 throw new SQLException("afterLast method not supported.");
1040 }
1041
1042 /**
1043 * Moves the cursor to the first row in
1044 * this <code>ResultSet</code> object.
1045 *
1046 * @return <code>true</code> if the cursor is on a valid row;
1047 * <code>false</code> if there are no rows in the result set
1048 * @exception SQLException if a database access error
1049 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1050 * @since 1.2
1051 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1052 * 2.0 API</a>
1053 */
1054 public boolean first()
1055 throws SQLException
1056 {
1057 throw new SQLException("first method not supported.");
1058 }
1059
1060 /**
1061 * Moves the cursor to the last row in
1062 * this <code>ResultSet</code> object.
1063 *
1064 * @return <code>true</code> if the cursor is on a valid row;
1065 * <code>false</code> if there are no rows in the result set
1066 * @exception SQLException if a database access error
1067 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1068 * @since 1.2
1069 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1070 * 2.0 API</a>
1071 */
1072 public boolean last()
1073 throws SQLException
1074 {
1075 throw new SQLException("last method not supported.");
1076 }
1077
1078 /**
1079 * Retrieves the current row number. The first row is number 1, the
1080 * second number 2, and so on.
1081 *
1082 * @return the current row number; <code>0</code> if there is no current row
1083 * @exception SQLException
1084 * @since 1.2
1085 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1086 * 2.0 API</a>
1087 */
1088 public int getRow()
1089 throws SQLException
1090 {
1091 throw new SQLException("getRow method not supported.");
1092 }
1093
1094 /**
1095 * Moves the cursor to the given row number in
1096 * this <code>ResultSet</code> object.
1097 *
1098 * <p>If the row number is positive, the cursor moves to
1099 * the given row number with respect to the
1100 * beginning of the result set. The first row is row 1, the second
1101 * is row 2, and so on.
1102 *
1103 * <p>If the given row number is negative, the cursor moves to
1104 * an absolute row position with respect to
1105 * the end of the result set. For example, calling the method
1106 * <code>absolute(-1)</code> positions the
1107 * cursor on the last row; calling the method <code>absolute(-2)</code>
1108 * moves the cursor to the next-to-last row, and so on.
1109 *
1110 * <p>An attempt to position the cursor beyond the first/last row in
1111 * the result set leaves the cursor before the first row or after
1112 * the last row.
1113 *
1114 * <p><B>Note:</B> Calling <code>absolute(1)</code> is the same
1115 * as calling <code>first()</code>. Calling <code>absolute(-1)</code>
1116 * is the same as calling <code>last()</code>.
1117 *
1118 * @return <code>true</code> if the cursor is on the result set;
1119 * <code>false</code> otherwise
1120 * @exception SQLException if a database access error
1121 * occurs, the row is <code>0</code>, or the result set type is
1122 * <code>TYPE_FORWARD_ONLY</code>
1123 * @since 1.2
1124 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1125 * 2.0 API</a>
1126 */
1127 public boolean absolute( int row )
1128 throws SQLException
1129 {
1130 throw new SQLException("absolute method not supported.");
1131 }
1132
1133 /**
1134 * Moves the cursor a relative number of rows, either positive or negative.
1135 * Attempting to move beyond the first/last row in the
1136 * result set positions the cursor before/after the
1137 * the first/last row. Calling <code>relative(0)</code> is valid, but does
1138 * not change the cursor position.
1139 *
1140 * <p>Note: Calling the method <code>relative(1)</code>
1141 * is different from calling the method <code>next()</code>
1142 * because is makes sense to call <code>next()</code> when there
1143 * is no current row,
1144 * for example, when the cursor is positioned before the first row
1145 * or after the last row of the result set.
1146 *
1147 * @return <code>true</code> if the cursor is on a row;
1148 * <code>false</code> otherwise
1149 * @exception SQLException,
1150 * there is no current row, or the result set type is
1151 * <code>TYPE_FORWARD_ONLY</code>
1152 * @since 1.2
1153 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1154 * 2.0 API</a>
1155 */
1156 public boolean relative( int rows )
1157 throws SQLException
1158 {
1159 throw new SQLException("relative method not supported.");
1160 }
1161
1162 /**
1163 * Moves the cursor to the previous row in this
1164 * <code>ResultSet</code> object.
1165 *
1166 * <p><B>Note:</B> Calling the method <code>previous()</code> is not the same as
1167 * calling the method <code>relative(-1)</code> because it
1168 * makes sense to call</code>previous()</code> when there is no current row.
1169 *
1170 * @return <code>true</code> if the cursor is on a valid row;
1171 * <code>false</code> if it is off the result set
1172 * @exception SQLException if a database access error
1173 * occurs or the result set type is <code>TYPE_FORWARD_ONLY</code>
1174 * @since 1.2
1175 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1176 * 2.0 API</a>
1177 */
1178 public boolean previous()
1179 throws SQLException
1180 {
1181 throw new SQLException("previous method not supported.");
1182 }
1183
1184 //---------------------------------------------------------------------
1185 // Properties
1186 //---------------------------------------------------------------------
1187
1188 /**
1189 * The constant indicating that the rows in a result set will be
1190 * processed in a forward direction; first-to-last.
1191 * This constant is used by the method <code>setFetchDirection</code>
1192 * as a hint to the driver, which the driver may ignore.
1193 * @since 1.2
1194 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1195 * 2.0 API</a>
1196 */
1197 int FETCH_FORWARD = 1000;
1198
1199 /**
1200 * The constant indicating that the rows in a result set will be
1201 * processed in a reverse direction; last-to-first.
1202 * This constant is used by the method <code>setFetchDirection</code>
1203 * as a hint to the driver, which the driver may ignore.
1204 * @since 1.2
1205 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1206 * 2.0 API</a>
1207 */
1208 int FETCH_REVERSE = 1001;
1209
1210 /**
1211 * The constant indicating that the order in which rows in a
1212 * result set will be processed is unknown.
1213 * This constant is used by the method <code>setFetchDirection</code>
1214 * as a hint to the driver, which the driver may ignore.
1215 */
1216 int FETCH_UNKNOWN = 1002;
1217
1218 /**
1219 * Gives a hint as to the direction in which the rows in this
1220 * <code>ResultSet</code> object will be processed.
1221 * The initial value is determined by the
1222 * <code>Statement</code> object
1223 * that produced this <code>ResultSet</code> object.
1224 * The fetch direction may be changed at any time.
1225 *
1226 * @exception SQLException or
1227 * the result set type is <code>TYPE_FORWARD_ONLY</code> and the fetch
1228 * direction is not <code>FETCH_FORWARD</code>
1229 * @since 1.2
1230 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1231 * 2.0 API</a>
1232 * @see Statement#setFetchDirection
1233 */
1234 public void setFetchDirection(int direction)
1235 throws SQLException
1236 {
1237 throw new SQLException("setFetchDirection method not supported.");
1238 }
1239
1240 /**
1241 * Returns the fetch direction for this
1242 * <code>ResultSet</code> object.
1243 *
1244 * @return the current fetch direction for this <code>ResultSet</code> object
1245 * @exception SQLException
1246 * @since 1.2
1247 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1248 * 2.0 API</a>
1249 */
1250 public int getFetchDirection()
1251 throws SQLException
1252 {
1253 throw new SQLException("getFetchDirection method not supported.");
1254 }
1255
1256 /**
1257 * Gives the JDBC driver a hint as to the number of rows that should
1258 * be fetched from the database when more rows are needed for this
1259 * <code>ResultSet</code> object.
1260 * If the fetch size specified is zero, the JDBC driver
1261 * ignores the value and is free to make its own best guess as to what
1262 * the fetch size should be. The default value is set by the
1263 * <code>Statement</code> object
1264 * that created the result set. The fetch size may be changed at any time.
1265 *
1266 * @param rows the number of rows to fetch
1267 * @exception SQLException or the
1268 * condition <code>0 <= rows <= this.getMaxRows()</code> is not satisfied
1269 * @since 1.2
1270 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1271 * 2.0 API</a>
1272 */
1273 public void setFetchSize(int rows)
1274 throws SQLException
1275 {
1276 throw new SQLException("setFetchSize method not supported.");
1277 }
1278
1279 /**
1280 *
1281 * Returns the fetch size for this
1282 * <code>ResultSet</code> object.
1283 *
1284 * @return the current fetch size for this <code>ResultSet</code> object
1285 * @exception SQLException
1286 * @since 1.2
1287 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1288 * 2.0 API</a>
1289 */
1290 public int getFetchSize()
1291 throws SQLException
1292 {
1293 throw new SQLException("getFetchSize method not supported.");
1294 }
1295
1296 /**
1297 * Returns the type of this <code>ResultSet</code> object.
1298 * The type is determined by the <code>Statement</code> object
1299 * that created the result set.
1300 *
1301 * @return <code>TYPE_FORWARD_ONLY</code>,
1302 * <code>TYPE_SCROLL_INSENSITIVE</code>,
1303 * or <code>TYPE_SCROLL_SENSITIVE</code>
1304 * @exception SQLException
1305 * @since 1.2
1306 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1307 * 2.0 API</a>
1308 */
1309 public int getType()
1310 throws SQLException
1311 {
1312 throw new SQLException("getType method not supported.");
1313 }
1314
1315 /**
1316 * Returns the concurrency mode of this <code>ResultSet</code> object.
1317 * The concurrency used is determined by the
1318 * <code>Statement</code> object that created the result set.
1319 *
1320 * @return the concurrency type, either <code>CONCUR_READ_ONLY</code>
1321 * or <code>CONCUR_UPDATABLE</code>
1322 * @exception SQLException
1323 * @since 1.2
1324 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1325 * 2.0 API</a>
1326 */
1327 public int getConcurrency()
1328 throws SQLException
1329 {
1330 throw new SQLException("getConcurrency method not supported.");
1331 }
1332
1333 //---------------------------------------------------------------------
1334 // Updates
1335 //---------------------------------------------------------------------
1336
1337 /**
1338 * Indicates whether the current row has been updated. The value returned
1339 * depends on whether or not the result set can detect updates.
1340 *
1341 * @return <code>true</code> if the row has been visibly updated
1342 * by the owner or another, and updates are detected
1343 * @exception SQLException
1344 *
1345 * @see DatabaseMetaData#updatesAreDetected
1346 * @since 1.2
1347 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1348 * 2.0 API</a>
1349 */
1350 public boolean rowUpdated()
1351 throws SQLException
1352 {
1353 throw new SQLException("rowUpdated method not supported.");
1354 }
1355
1356 /**
1357 * Indicates whether the current row has had an insertion.
1358 * The value returned depends on whether or not this
1359 * <code>ResultSet</code> object can detect visible inserts.
1360 *
1361 * @return <code>true</code> if a row has had an insertion
1362 * and insertions are detected; <code>false</code> otherwise
1363 * @exception SQLException
1364 *
1365 * @see DatabaseMetaData#insertsAreDetected
1366 * @since 1.2
1367 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1368 * 2.0 API</a>
1369 */
1370 public boolean rowInserted()
1371 throws SQLException
1372 {
1373 throw new SQLException("rowInserted method not supported.");
1374 }
1375
1376 /**
1377 * Indicates whether a row has been deleted. A deleted row may leave
1378 * a visible "hole" in a result set. This method can be used to
1379 * detect holes in a result set. The value returned depends on whether
1380 * or not this <code>ResultSet</code> object can detect deletions.
1381 *
1382 * @return <code>true</code> if a row was deleted and deletions are detected;
1383 * <code>false</code> otherwise
1384 * @exception SQLException
1385 *
1386 * @see DatabaseMetaData#deletesAreDetected
1387 * @since 1.2
1388 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1389 * 2.0 API</a>
1390 */
1391 public boolean rowDeleted()
1392 throws SQLException
1393 {
1394 throw new SQLException("rowDeleted method not supported.");
1395 }
1396
1397 /**
1398 * Gives a nullable column a null value.
1399 *
1400 * The <code>updateXXX</code> methods are used to update column values in the
1401 * current row or the insert row. The <code>updateXXX</code> methods do not
1402 * update the underlying database; instead the <code>updateRow</code>
1403 * or <code>insertRow</code> methods are called to update the database.
1404 *
1405 * @param columnIndex the first column is 1, the second is 2, ...
1406 * @exception SQLException
1407 * @since 1.2
1408 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1409 * 2.0 API</a>
1410 */
1411 public void updateNull(int columnIndex)
1412 throws SQLException
1413 {
1414 throw new SQLException("updateNull method not supported.");
1415 }
1416
1417 /**
1418 * Updates the designated column with a <code>boolean</code> value.
1419 * The <code>updateXXX</code> methods are used to update column values in the
1420 * current row or the insert row. The <code>updateXXX</code> methods do not
1421 * update the underlying database; instead the <code>updateRow</code> or
1422 * <code>insertRow</code> methods are called to update the database.
1423 *
1424 * @param columnIndex the first column is 1, the second is 2, ...
1425 * @param x the new column value
1426 * @exception SQLException
1427 * @since 1.2
1428 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1429 * 2.0 API</a>
1430 */
1431 public void updateBoolean(int columnIndex, boolean x)
1432 throws SQLException
1433 {
1434 throw new SQLException("updateBoolean method not supported.");
1435 }
1436
1437 /**
1438 * Updates the designated column with a <code>byte</code> value.
1439 * The <code>updateXXX</code> methods are used to update column values in the
1440 * current row or the insert row. The <code>updateXXX</code> methods do not
1441 * update the underlying database; instead the <code>updateRow</code> or
1442 * <code>insertRow</code> methods are called to update the database.
1443 *
1444 *
1445 * @param columnIndex the first column is 1, the second is 2, ...
1446 * @param x the new column value
1447 * @exception SQLException
1448 * @since 1.2
1449 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1450 * 2.0 API</a>
1451 */
1452 public void updateByte(int columnIndex, byte x)
1453 throws SQLException
1454 {
1455 throw new SQLException("updateByte method not supported.");
1456 }
1457
1458 /**
1459 * Updates the designated column with a <code>short</code> value.
1460 * The <code>updateXXX</code> methods are used to update column values in the
1461 * current row or the insert row. The <code>updateXXX</code> methods do not
1462 * update the underlying database; instead the <code>updateRow</code> or
1463 * <code>insertRow</code> methods are called to update the database.
1464 *
1465 * @param columnIndex the first column is 1, the second is 2, ...
1466 * @param x the new column value
1467 * @exception SQLException
1468 * @since 1.2
1469 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1470 * 2.0 API</a>
1471 */
1472 public void updateShort(int columnIndex, short x)
1473 throws SQLException
1474 {
1475 throw new SQLException("updateShort method not supported.");
1476 }
1477
1478 /**
1479 * Updates the designated column with an <code>int</code> value.
1480 * The <code>updateXXX</code> methods are used to update column values in the
1481 * current row or the insert row. The <code>updateXXX</code> methods do not
1482 * update the underlying database; instead the <code>updateRow</code> or
1483 * <code>insertRow</code> methods are called to update the database.
1484 *
1485 * @param columnIndex the first column is 1, the second is 2, ...
1486 * @param x the new column value
1487 * @exception SQLException
1488 * @since 1.2
1489 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1490 * 2.0 API</a>
1491 */
1492 public void updateInt(int columnIndex, int x)
1493 throws SQLException
1494 {
1495 throw new SQLException("updateInt method not supported.");
1496 }
1497
1498 /**
1499 * Updates the designated column with a <code>long</code> value.
1500 * The <code>updateXXX</code> methods are used to update column values in the
1501 * current row or the insert row. The <code>updateXXX</code> 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
1508 * @since 1.2
1509 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1510 * 2.0 API</a>
1511 */
1512 public void updateLong(int columnIndex, long x)
1513 throws SQLException
1514 {
1515 throw new SQLException("updateLong method not supported.");
1516 }
1517
1518 /**
1519 * Updates the designated column with a <code>float</code> value.
1520 * The <code>updateXXX</code> methods are used to update column values in the
1521 * current row or the insert row. The <code>updateXXX</code> methods do not
1522 * update the underlying database; instead the <code>updateRow</code> or
1523 * <code>insertRow</code> methods are called to update the database.
1524 *
1525 * @param columnIndex the first column is 1, the second is 2, ...
1526 * @param x the new column value
1527 * @exception SQLException
1528 * @since 1.2
1529 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1530 * 2.0 API</a>
1531 */
1532 public void updateFloat(int columnIndex, float x)
1533 throws SQLException
1534 {
1535 throw new SQLException("updateFloat method not supported.");
1536 }
1537
1538 /**
1539 * Updates the designated column with a <code>double</code> value.
1540 * The <code>updateXXX</code> methods are used to update column values in the
1541 * current row or the insert row. The <code>updateXXX</code> methods do not
1542 * update the underlying database; instead the <code>updateRow</code> or
1543 * <code>insertRow</code> methods are called to update the database.
1544 *
1545 * @param columnIndex the first column is 1, the second is 2, ...
1546 * @param x the new column value
1547 * @exception SQLException
1548 * @since 1.2
1549 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1550 * 2.0 API</a>
1551 */
1552 public void updateDouble(int columnIndex, double x)
1553 throws SQLException
1554 {
1555 throw new SQLException("updateDouble method not supported.");
1556 }
1557
1558 /**
1559 * Updates the designated column with a <code>java.math.BigDecimal</code>
1560 * value.
1561 * The <code>updateXXX</code> methods are used to update column values in the
1562 * current row or the insert row. The <code>updateXXX</code> methods do not
1563 * update the underlying database; instead the <code>updateRow</code> or
1564 * <code>insertRow</code> methods are called to update the database.
1565 *
1566 * @param columnIndex the first column is 1, the second is 2, ...
1567 * @param x the new column value
1568 * @exception SQLException
1569 * @since 1.2
1570 * @see <a href="package-summary.html#2.0 API">What Is in the JDBC
1571