1 //
2 // Copyright 1999 Craig Spannring
3 //
4 // All rights reserved.
5 //
6 // Redistribution and use in source and binary forms, with or without
7 // modification, are permitted provided that the following conditions are met:
8 // 1. Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // 2. Redistributions in binary form must reproduce the above copyright
11 // notice, this list of conditions and the following disclaimer in the
12 // documentation and/or other materials provided with the distribution.
13 // 3. All advertising materials mentioning features or use of this software
14 // must display the following acknowledgement:
15 // This product includes software developed by Craig Spannring
16 // 4. The name of Craig Spannring may not be used to endorse or promote
17 // products derived from this software without specific prior
18 // written permission.
19 //
20 // THIS SOFTWARE IS PROVIDED BY CRAIG SPANNRING ``AS IS'' AND
21 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 // ARE DISCLAIMED. IN NO EVENT SHALL CRAIG SPANNRING BE LIABLE
24 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 // OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 // HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 // OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 // SUCH DAMAGE.
31 //
32
33
34 package com.internetcds.jdbc.tds;
35
36
37 import java.sql.*;
38 import java.math.BigDecimal;
39 import java.util.Vector;
40 // import java.util.Calendar;
41 import java.util.GregorianCalendar;
42 import java.util.Calendar;
43 import java.net.URL;
44
45
46
47 public class ResultSet_2_0
48 extends com.internetcds.jdbc.tds.ResultSet_base
49 implements java.sql.ResultSet
50 {
51 public static final String cvsVersion = "$Id: ResultSet_2_0.java,v 1.3 2007/01/15 11:03:43 alex Exp $";
52
53
54 public ResultSet_2_0(Tds tds_,
55 com.internetcds.jdbc.tds.Statement stmt_,
56 Columns columns_)
57 {
58 super(tds_, stmt_, columns_);
59 }
60
61
62 //---------------------------------------------------------------------
63 // Getter's and Setter's
64 //---------------------------------------------------------------------
65
66 /***
67 * JDBC 2.0
68 *
69 * <p>Gets the value of a column in the current row as a java.io.Reader.
70 * @param columnIndex the first column is 1, the second is 2, ...
71 */
72 public java.io.Reader getCharacterStream(int columnIndex) throws SQLException
73 {
74 String val = getString(columnIndex);
75 if (val == null)
76 return null;
77
78 return new java.io.StringReader(val);
79 }
80
81
82 /***
83 * JDBC 2.0
84 *
85 * <p>Gets the value of a column in the current row as a java.io.Reader.
86 * @param columnName the name of the column
87 * @return the value in the specified column as a <code>java.io.Reader</code>
88 */
89 public java.io.Reader getCharacterStream(String columnName) throws SQLException
90 {
91 return getCharacterStream(findColumn(columnName));
92 }
93
94
95 /***
96 * JDBC 2.0
97 *
98 * Gets the value of a column in the current row as a java.math.BigDecimal
99 * object with full precision.
100 *
101 * @param columnIndex the first column is 1, the second is 2, ...
102 * @return the column value (full precision); if the value is SQL NULL,
103 * the result is null
104 * @exception SQLException if a database access error occurs
105 */
106 public BigDecimal getBigDecimal(int columnIndex) throws SQLException
107 {
108 return getBigDecimal(columnIndex, 0);
109 // NotImplemented();
110 // return null;
111 }
112
113
114 /***
115 * JDBC 2.0
116 *
117 * Gets the value of a column in the current row as a java.math.BigDecimal
118 * object with full precision.
119 * @param columnName the column name
120 * @return the column value (full precision); if the value is SQL NULL,
121 * the result is null
122 * @exception SQLException if a database access error occurs
123 *
124 */
125 public BigDecimal getBigDecimal(String columnName) throws SQLException
126 {
127
128 return getBigDecimal(findColumn(columnName), 0);
129 // NotImplemented();
130 // return null;
131 }
132
133
134 //---------------------------------------------------------------------
135 // Traversal/Positioning
136 //---------------------------------------------------------------------
137
138 /***
139 * JDBC 2.0
140 *
141 * <p>Indicates whether the cursor is before the first row in the result
142 * set.
143 *
144 * @return true if the cursor is before the first row,
145 * false otherwise. Returns
146 * false when the result set contains no rows.
147 * @exception SQLException if a database access error occurs
148 */
149 public boolean isBeforeFirst() throws SQLException
150 {
151 NotImplemented();
152 return false;
153 }
154
155
156 /***
157 * JDBC 2.0
158 *
159 * <p>Indicates whether the cursor is after the last row in the result
160 * set.
161 *
162 * @return true if the cursor is after the last row, false otherwise. Returns
163 * false when the result set contains no rows.
164 * @exception SQLException if a database access error occurs
165 */
166 public boolean isAfterLast() throws SQLException
167 {
168 NotImplemented();
169 return false;
170 }
171
172
173 /***
174 * JDBC 2.0
175 *
176 * <p>Indicates whether the cursor is on the first row of the result set.
177 *
178 * @return true if the cursor is on the first row, false otherwise.
179 * @exception SQLException if a database access error occurs
180 */
181 public boolean isFirst() throws SQLException
182 {
183 NotImplemented();
184 return false;
185 }
186
187
188 /***
189 * JDBC 2.0
190 *
191 * <p>Indicates whether the cursor is on the last row of the result set.
192 * Note: Calling the method <code>isLast</code> may be expensive
193 * because the JDBC driver
194 * might need to fetch ahead one row in order to determine
195 * whether the current row is the last row in the result set.
196 *
197 * @return true if the cursor is on the last row, false otherwise.
198 * @exception SQLException if a database access error occurs
199 */
200 public boolean isLast() throws SQLException
201 {
202 NotImplemented();
203 return false;
204 }
205
206
207 /***
208 * JDBC 2.0
209 *
210 * <p>Moves the cursor to the front of the result set, just before the
211 * first row. Has no effect if the result set contains no rows.
212 *
213 * @exception SQLException if a database access error occurs or the
214 * result set type is TYPE_FORWARD_ONLY
215 */
216 public void beforeFirst() throws SQLException
217 {
218 NotImplemented();
219 }
220
221
222 /***
223 * JDBC 2.0
224 *
225 * <p>Moves the cursor to the end of the result set, just after the last
226 * row. Has no effect if the result set contains no rows.
227 *
228 * @exception SQLException if a database access error occurs or the
229 * result set type is TYPE_FORWARD_ONLY
230 */
231 public void afterLast() throws SQLException
232 {
233 NotImplemented();
234 }
235
236
237 /***
238 * JDBC 2.0
239 *
240 * <p>Moves the cursor to the first row in the result set.
241 *
242 * @return true if the cursor is on a valid row; false if
243 * there are no rows in the result set
244 * @exception SQLException if a database access error occurs or the
245 * result set type is TYPE_FORWARD_ONLY
246 */
247 public boolean first() throws SQLException
248 {
249 NotImplemented();
250 return false;
251 }
252
253
254 /***
255 * JDBC 2.0
256 *
257 * <p>Moves the cursor to the last row in the result set.
258 *
259 * @return true if the cursor is on a valid row;
260 * false if there are no rows in the result set
261 * @exception SQLException if a database access error occurs or the
262 * result set type is TYPE_FORWARD_ONLY.
263 */
264 public boolean last() throws SQLException
265 {
266 NotImplemented();
267 return false;
268 }
269
270
271 /***
272 * JDBC 2.0
273 *
274 * <p>Retrieves the current row number. The first row is number 1, the
275 * second number 2, and so on.
276 *
277 * @return the current row number; 0 if there is no current row
278 * @exception SQLException if a database access error occurs
279 */
280 public int getRow() throws SQLException
281 {
282 NotImplemented();
283 return 0;
284 }
285
286
287 /***
288 * JDBC 2.0
289 *
290 * <p>Moves the cursor to the given row number in the result set.
291 *
292 * <p>If the row number is positive, the cursor moves to
293 * the given row number with respect to the
294 * beginning of the result set. The first row is row 1, the second
295 * is row 2, and so on.
296 *
297 * <p>If the given row number is negative, the cursor moves to
298 * an absolute row position with respect to
299 * the end of the result set. For example, calling
300 * <code>absolute(-1)</code> positions the
301 * cursor on the last row, <code>absolute(-2)</code> indicates the next-to-last
302 * row, and so on.
303 *
304 * <p>An attempt to position the cursor beyond the first/last row in
305 * the result set leaves the cursor before/after the first/last
306 * row, respectively.
307 *
308 * <p>Note: Calling <code>absolute(1)</code> is the same
309 * as calling <code>first()</code>.
310 * Calling <code>absolute(-1)</code> is the same as calling <code>last()</code>.
311 *
312 * @return true if the cursor is on the result set; false otherwise
313 * @exception SQLException if a database access error occurs or
314 * row is 0, or result set type is TYPE_FORWARD_ONLY.
315 */
316 public boolean absolute( int row ) throws SQLException
317 {
318 NotImplemented();
319 return false;
320 }
321
322
323 /***
324 * JDBC 2.0
325 *
326 * <p>Moves the cursor a relative number of rows, either positive or negative.
327 * Attempting to move beyond the first/last row in the
328 * result set positions the cursor before/after the
329 * the first/last row. Calling <code>relative(0)</code> is valid, but does
330 * not change the cursor position.
331 *
332 * <p>Note: Calling <code>relative(1)</code>
333 * is different from calling <code>next()</code>
334 * because is makes sense to call <code>next()</code> when there is no current row,
335 * for example, when the cursor is positioned before the first row
336 * or after the last row of the result set.
337 *
338 * @return true if the cursor is on a row; false otherwise
339 * @exception SQLException if a database access error occurs, there
340 * is no current row, or the result set type is TYPE_FORWARD_ONLY
341 */
342 public boolean relative( int rows ) throws SQLException
343 {
344 NotImplemented();
345 return false;
346 }
347
348
349 /***
350 * JDBC 2.0
351 *
352 * <p>Moves the cursor to the previous row in the result set.
353 *
354 * <p>Note: <code>previous()</code> is not the same as
355 * <code>relative(-1)</code> because it
356 * makes sense to call</code>previous()</code> when there is no current row.
357 *
358 * @return true if the cursor is on a valid row; false if it is off the result set
359 * @exception SQLException if a database access error occurs or the
360 * result set type is TYPE_FORWARD_ONLY
361 */
362 public boolean previous() throws SQLException
363 {
364 NotImplemented();
365 return false;
366 }
367
368
369 //---------------------------------------------------------------------
370 // Properties
371 //---------------------------------------------------------------------
372
373 /***
374 * JDBC 2.0
375 *
376 * The rows in a result set will be processed in a forward direction;
377 * first-to-last.
378 */
379 int FETCH_FORWARD = 1000;
380
381 /***
382 * JDBC 2.0
383 *
384 * The rows in a result set will be processed in a reverse direction;
385 * last-to-first.
386 */
387 int FETCH_REVERSE = 1001;
388
389 /***
390 * JDBC 2.0
391 *
392 * The order in which rows in a result set will be processed is unknown.
393 */
394 int FETCH_UNKNOWN = 1002;
395
396 /***
397 * JDBC 2.0
398 *
399 * Gives a hint as to the direction in which the rows in this result set
400 * will be processed. The initial value is determined by the statement
401 * that produced the result set. The fetch direction may be changed
402 * at any time.
403 *
404 * @exception SQLException if a database access error occurs or
405 * the result set type is TYPE_FORWARD_ONLY and the fetch direction is not
406 * FETCH_FORWARD.
407 */
408 public void setFetchDirection(int direction) throws SQLException
409 {
410 NotImplemented();
411 }
412
413
414 /***
415 * JDBC 2.0
416 *
417 * Returns the fetch direction for this result set.
418 *
419 * @return the current fetch direction for this result set
420 * @exception SQLException if a database access error occurs
421 */
422 public int getFetchDirection() throws SQLException
423 {
424 NotImplemented();
425 return 0;
426 }
427
428
429 /***
430 * JDBC 2.0
431 *
432 * Gives the JDBC driver a hint as to the number of rows that should
433 * be fetched from the database when more rows are needed for this result
434 * set. If the fetch size specified is zero, the JDBC driver
435 * ignores the value and is free to make its own best guess as to what
436 * the fetch size should be. The default value is set by the statement
437 * that created the result set. The fetch size may be changed at any
438 * time.
439 *
440 * @param rows the number of rows to fetch
441 * @exception SQLException if a database access error occurs or the
442 * condition 0 <= rows <= this.getMaxRows() is not satisfied.
443 */
444 public void setFetchSize(int rows) throws SQLException
445 {
446 NotImplemented();
447 }
448
449
450 /***
451 * JDBC 2.0
452 *
453 * Returns the fetch size for this result set.
454 *
455 * @return the current fetch size for this result set
456 * @exception SQLException if a database access error occurs
457 */
458 public int getFetchSize() throws SQLException
459 {
460 NotImplemented();
461 return 0;
462 }
463
464
465 /***
466 * JDBC 2.0
467 * The type for a <code>ResultSet</code> object whose cursor may
468 * move only forward.
469 */
470 int TYPE_FORWARD_ONLY = 1003;
471
472 /***
473 * JDBC 2.0
474 * The type for a <code>ResultSet</code> object that is scrollable
475 * but generally not sensitive to changes made by others.
476 *
477 */
478 int TYPE_SCROLL_INSENSITIVE = 1004;
479
480 /***
481 * JDBC 2.0
482 * The type for a <code>ResultSet</code> object that is scrollable
483 * and generally sensitive to changes made by others.
484 */
485 int TYPE_SCROLL_SENSITIVE = 1005;
486
487 /***
488 * JDBC 2.0
489 *
490 * Returns the type of this result set. The type is determined by
491 * the statement that created the result set.
492 *
493 * @return TYPE_FORWARD_ONLY, TYPE_SCROLL_INSENSITIVE, or
494 * TYPE_SCROLL_SENSITIVE
495 * @exception SQLException if a database access error occurs
496 */
497 public int getType() throws SQLException
498 {
499 NotImplemented();
500 return 0;
501 }
502
503
504 /***
505 * JDBC 2.0
506 * The concurrency mode for a <code>ResultSet</code> object
507 * that may NOT be updated.
508 *
509 */
510 int CONCUR_READ_ONLY = 1007;
511
512 /***
513 * JDBC 2.0
514 * The concurrency mode for a <code>ResultSet</code> object
515 * that may be updated.
516 *
517 */
518 int CONCUR_UPDATABLE = 1008;
519
520 /***
521 * JDBC 2.0
522 *
523 * Returns the concurrency mode of this result set. The concurrency
524 * used is determined by the statement that created the result set.
525 *
526 * @return the concurrency type, CONCUR_READ_ONLY or CONCUR_UPDATABLE
527 * @exception SQLException if a database access error occurs
528 */
529 public int getConcurrency() throws SQLException
530 {
531 NotImplemented();
532 return 0;
533 }
534
535
536 //---------------------------------------------------------------------
537 // Updates
538 //---------------------------------------------------------------------
539
540 /***
541 * JDBC 2.0
542 *
543 * Indicates whether the current row has been updated. The value returned
544 * depends on whether or not the result set can detect updates.
545 *
546 * @return true if the row has been visibly updated by the owner or
547 * another, and updates are detected
548 * @exception SQLException if a database access error occurs
549 *
550 * @see DatabaseMetaData#updatesAreDetected
551 */
552 public boolean rowUpdated() throws SQLException
553 {
554 NotImplemented();
555 return false;
556 }
557
558
559 /***
560 * JDBC 2.0
561 *
562 * Indicates whether the current row has had an insertion. The value returned
563 * depends on whether or not the result set can detect visible inserts.
564 *
565 * @return true if a row has had an insertion and insertions are detected
566 * @exception SQLException if a database access error occurs
567 *
568 * @see DatabaseMetaData#insertsAreDetected
569 */
570 public boolean rowInserted() throws SQLException
571 {
572 NotImplemented();
573 return false;
574 }
575
576
577 /***
578 * JDBC 2.0
579 *
580 * Indicates whether a row has been deleted. A deleted row may leave
581 * a visible "hole" in a result set. This method can be used to
582 * detect holes in a result set. The value returned depends on whether
583 * or not the result set can detect deletions.
584 *
585 * @return true if a row was deleted and deletions are detected
586 * @exception SQLException if a database access error occurs
587 *
588 * @see DatabaseMetaData#deletesAreDetected
589 */
590 public boolean rowDeleted() throws SQLException
591 {
592 NotImplemented();
593 return false;
594 }
595
596
597 /***
598 * JDBC 2.0
599 *
600 * Give a nullable column a null value.
601 *
602 * The <code>updateXXX</code> methods are used to update column values in the
603 * current row, or the insert row. The <code>updateXXX</code> methods do not
604 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
605 * methods are called to update the database.
606 *
607 * @param columnIndex the first column is 1, the second is 2, ...
608 * @exception SQLException if a database access error occurs
609 */
610 public void updateNull(int columnIndex) throws SQLException
611 {
612 NotImplemented();
613 }
614
615
616 /***
617 * JDBC 2.0
618 *
619 * Updates a column with a boolean value.
620 *
621 * The <code>updateXXX</code> methods are used to update column values in the
622 * current row, or the insert row. The <code>updateXXX</code> methods do not
623 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
624 * methods are called to update the database.
625 *
626 * @param columnIndex the first column is 1, the second is 2, ...
627 * @param x the new column value
628 * @exception SQLException if a database access error occurs
629 */
630 public void updateBoolean(int columnIndex, boolean x) throws SQLException
631 {
632 NotImplemented();
633 }
634
635
636 /***
637 * JDBC 2.0
638 *
639 * Updates a column with a byte value.
640 *
641 * The <code>updateXXX</code> methods are used to update column values in the
642 * current row, or the insert row. The <code>updateXXX</code> methods do not
643 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
644 * methods are called to update the database.
645 *
646 * @param columnIndex the first column is 1, the second is 2, ...
647 * @param x the new column value
648 * @exception SQLException if a database access error occurs
649 */
650 public void updateByte(int columnIndex, byte x) throws SQLException
651 {
652 NotImplemented();
653 }
654
655
656 /***
657 * JDBC 2.0
658 *
659 * Updates a column with a short value.
660 *
661 * The <code>updateXXX</code> methods are used to update column values in the
662 * current row, or the insert row. The <code>updateXXX</code> methods do not
663 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
664 * methods are called to update the database.
665 *
666 * @param columnIndex the first column is 1, the second is 2, ...
667 * @param x the new column value
668 * @exception SQLException if a database access error occurs
669 */
670 public void updateShort(int columnIndex, short x) throws SQLException
671 {
672 NotImplemented();
673 }
674
675
676 /***
677 * JDBC 2.0
678 *
679 * Updates a column with an integer value.
680 *
681 * The <code>updateXXX</code> methods are used to update column values in the
682 * current row, or the insert row. The <code>updateXXX</code> methods do not
683 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
684 * methods are called to update the database.
685 *
686 * @param columnIndex the first column is 1, the second is 2, ...
687 * @param x the new column value
688 * @exception SQLException if a database access error occurs
689 */
690 public void updateInt(int columnIndex, int x) throws SQLException
691 {
692 NotImplemented();
693 }
694
695
696 /***
697 * JDBC 2.0
698 *
699 * Updates a column with a long value.
700 *
701 * The <code>updateXXX</code> methods are used to update column values in the
702 * current row, or the insert row. The <code>updateXXX</code> methods do not
703 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
704 * methods are called to update the database.
705 *
706 * @param columnIndex the first column is 1, the second is 2, ...
707 * @param x the new column value
708 * @exception SQLException if a database access error occurs
709 */
710 public void updateLong(int columnIndex, long x) throws SQLException
711 {
712 NotImplemented();
713 }
714
715
716 /***
717 * JDBC 2.0
718 *
719 * Updates a column with a float value.
720 *
721 * The <code>updateXXX</code> methods are used to update column values in the
722 * current row, or the insert row. The <code>updateXXX</code> methods do not
723 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
724 * methods are called to update the database.
725 *
726 * @param columnIndex the first column is 1, the second is 2, ...
727 * @param x the new column value
728 * @exception SQLException if a database access error occurs
729 */
730 public void updateFloat(int columnIndex, float x) throws SQLException
731 {
732 NotImplemented();
733 }
734
735
736 /***
737 * JDBC 2.0
738 *
739 * Updates a column with a Double value.
740 *
741 * The <code>updateXXX</code> methods are used to update column values in the
742 * current row, or the insert row. The <code>updateXXX</code> methods do not
743 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
744 * methods are called to update the database.
745 *
746 * @param columnIndex the first column is 1, the second is 2, ...
747 * @param x the new column value
748 * @exception SQLException if a database access error occurs
749 */
750 public void updateDouble(int columnIndex, double x) throws SQLException
751 {
752 NotImplemented();
753 }
754
755
756 /***
757 * JDBC 2.0
758 *
759 * Updates a column with a BigDecimal value.
760 *
761 * The <code>updateXXX</code> methods are used to update column values in the
762 * current row, or the insert row. The <code>updateXXX</code> methods do not
763 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
764 * methods are called to update the database.
765 *
766 * @param columnIndex the first column is 1, the second is 2, ...
767 * @param x the new column value
768 * @exception SQLException if a database access error occurs
769 */
770 public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException
771 {
772 NotImplemented();
773 }
774
775
776 /***
777 * JDBC 2.0
778 *
779 * Updates a column with a String value.
780 *
781 * The <code>updateXXX</code> methods are used to update column values in the
782 * current row, or the insert row. The <code>updateXXX</code> methods do not
783 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
784 * methods are called to update the database.
785 *
786 * @param columnIndex the first column is 1, the second is 2, ...
787 * @param x the new column value
788 * @exception SQLException if a database access error occurs
789 */
790 public void updateString(int columnIndex, String x) throws SQLException
791 {
792 NotImplemented();
793 }
794
795
796 /***
797 * JDBC 2.0
798 *
799 * Updates a column with a byte array value.
800 *
801 * The <code>updateXXX</code> methods are used to update column values in the
802 * current row, or the insert row. The <code>updateXXX</code> methods do not
803 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
804 * methods are called to update the database.
805 *
806 * @param columnIndex the first column is 1, the second is 2, ...
807 * @param x the new column value
808 * @exception SQLException if a database access error occurs
809 */
810 public void updateBytes(int columnIndex, byte x[]) throws SQLException
811 {
812 NotImplemented();
813 }
814
815
816 /***
817 * JDBC 2.0
818 *
819 * Updates a column with a Date value.
820 *
821 * The <code>updateXXX</code> methods are used to update column values in the
822 * current row, or the insert row. The <code>updateXXX</code> methods do not
823 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
824 * methods are called to update the database.
825 *
826 * @param columnIndex the first column is 1, the second is 2, ...
827 * @param x the new column value
828 * @exception SQLException if a database access error occurs
829 */
830 public void updateDate(int columnIndex, java.sql.Date x) throws SQLException
831 {
832 NotImplemented();
833 }
834
835
836 /***
837 * JDBC 2.0
838 *
839 * Updates a column with a Time value.
840 *
841 * The <code>updateXXX</code> methods are used to update column values in the
842 * current row, or the insert row. The <code>updateXXX</code> methods do not
843 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
844 * methods are called to update the database.
845 *
846 * @param columnIndex the first column is 1, the second is 2, ...
847 * @param x the new column value
848 * @exception SQLException if a database access error occurs
849 */
850 public void updateTime(int columnIndex, java.sql.Time x) throws SQLException
851 {
852 NotImplemented();
853 }
854
855 /***
856 * JDBC 2.0
857 *
858 * Updates a column with a Timestamp value.
859 *
860 * The <code>updateXXX</code> methods are used to update column values in the
861 * current row, or the insert row. The <code>updateXXX</code> methods do not
862 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
863 * methods are called to update the database.
864 *
865 * @param columnIndex the first column is 1, the second is 2, ...
866 * @param x the new column value
867 * @exception SQLException if a database access error occurs
868 */
869 public void updateTimestamp(int columnIndex, java.sql.Timestamp x) throws SQLException
870 {
871 NotImplemented();
872 }
873
874
875 /***
876 * JDBC 2.0
877 *
878 * Updates a column with an ascii stream value.
879 *
880 * The <code>updateXXX</code> methods are used to update column values in the
881 * current row, or the insert row. The <code>updateXXX</code> methods do not
882 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
883 * methods are called to update the database.
884 *
885 * @param columnIndex the first column is 1, the second is 2, ...
886 * @param x the new column value
887 * @param length the length of the stream
888 * @exception SQLException if a database access error occurs
889 */
890 public void updateAsciiStream(int columnIndex,
891 java.io.InputStream x,
892 int length) throws SQLException
893 {
894 NotImplemented();
895 }
896
897
898 /***
899 * JDBC 2.0
900 *
901 * Updates a column with a binary stream value.
902 *
903 * The <code>updateXXX</code> methods are used to update column values in the
904 * current row, or the insert row. The <code>updateXXX</code> methods do not
905 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
906 * methods are called to update the database.
907 *
908 * @param columnIndex the first column is 1, the second is 2, ...
909 * @param x the new column value
910 * @param length the length of the stream
911 * @exception SQLException if a database access error occurs
912 */
913 public void updateBinaryStream(int columnIndex,
914 java.io.InputStream x,
915 int length) throws SQLException
916 {
917 NotImplemented();
918 }
919
920
921 /***
922 * JDBC 2.0
923 *
924 * Updates a column with a character stream value.
925 *
926 * The <code>updateXXX</code> methods are used to update column values in the
927 * current row, or the insert row. The <code>updateXXX</code> methods do not
928 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
929 * methods are called to update the database.
930 *
931 * @param columnIndex the first column is 1, the second is 2, ...
932 * @param x the new column value
933 * @param length the length of the stream
934 * @exception SQLException if a database access error occurs
935 */
936 public void updateCharacterStream(int columnIndex,
937 java.io.Reader x,
938 int length) throws SQLException
939 {
940 NotImplemented();
941 }
942
943 /***
944 * JDBC 2.0
945 *
946 * Updates a column with an Object value.
947 *
948 * The <code>updateXXX</code> methods are used to update column values in the
949 * current row, or the insert row. The <code>updateXXX</code> methods do not
950 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
951 * methods are called to update the database.
952 *
953 * @param columnIndex the first column is 1, the second is 2, ...
954 * @param x the new column value
955 * @param scale For java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types
956 * this is the number of digits after the decimal. For all other
957 * types this value will be ignored.
958 * @exception SQLException if a database access error occurs
959 */
960 public void updateObject(int columnIndex, Object x, int scale) throws SQLException
961 {
962 NotImplemented();
963 }
964
965
966 /***
967 * JDBC 2.0
968 *
969 * Updates a column with an Object value.
970 *
971 * The <code>updateXXX</code> methods are used to update column values in the
972 * current row, or the insert row. The <code>updateXXX</code> methods do not
973 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
974 * methods are called to update the database.
975 *
976 * @param columnIndex the first column is 1, the second is 2, ...
977 * @param x the new column value
978 * @exception SQLException if a database access error occurs
979 */
980 public void updateObject(int columnIndex, Object x) throws SQLException
981 {
982 NotImplemented();
983 }
984
985
986 /***
987 * JDBC 2.0
988 *
989 * Updates a column with a null value.
990 *
991 * The <code>updateXXX</code> methods are used to update column values in the
992 * current row, or the insert row. The <code>updateXXX</code> methods do not
993 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
994 * methods are called to update the database.
995 *
996 * @param columnName the name of the column
997 * @exception SQLException if a database access error occurs
998 */
999 public void updateNull(String columnName) throws SQLException
1000 {
1001 NotImplemented();
1002 }
1003
1004
1005 /***
1006 * JDBC 2.0
1007 *
1008 * Updates a column with a boolean value.
1009 *
1010 * The <code>updateXXX</code> methods are used to update column values in the
1011 * current row, or the insert row. The <code>updateXXX</code> methods do not
1012 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1013 * methods are called to update the database.
1014 *
1015 * @param columnName the name of the column
1016 * @param x the new column value
1017 * @exception SQLException if a database access error occurs
1018 */
1019 public void updateBoolean(String columnName, boolean x) throws SQLException
1020 {
1021 NotImplemented();
1022 }
1023
1024
1025 /***
1026 * JDBC 2.0
1027 *
1028 * Updates a column with a byte value.
1029 *
1030 * The <code>updateXXX</code> methods are used to update column values in the
1031 * current row, or the insert row. The <code>updateXXX</code> methods do not
1032 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1033 * methods are called to update the database.
1034 *
1035 * @param columnName the name of the column
1036 * @param x the new column value
1037 * @exception SQLException if a database access error occurs
1038 */
1039 public void updateByte(String columnName, byte x) throws SQLException
1040 {
1041 NotImplemented();
1042 }
1043
1044
1045 /***
1046 * JDBC 2.0
1047 *
1048 * Updates a column with a short value.
1049 *
1050 * The <code>updateXXX</code> methods are used to update column values in the
1051 * current row, or the insert row. The <code>updateXXX</code> methods do not
1052 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1053 * methods are called to update the database.
1054 *
1055 * @param columnName the name of the column
1056 * @param x the new column value
1057 * @exception SQLException if a database access error occurs
1058 */
1059 public void updateShort(String columnName, short x) throws SQLException
1060 {
1061 NotImplemented();
1062 }
1063
1064
1065 /***
1066 * JDBC 2.0
1067 *
1068 * Updates a column with an integer value.
1069 *
1070 * The <code>updateXXX</code> methods are used to update column values in the
1071 * current row, or the insert row. The <code>updateXXX</code> methods do not
1072 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1073 * methods are called to update the database.
1074 *
1075 * @param columnName the name of the column
1076 * @param x the new column value
1077 * @exception SQLException if a database access error occurs
1078 */
1079 public void updateInt(String columnName, int x) throws SQLException
1080 {
1081 NotImplemented();
1082 }
1083
1084
1085 /***
1086 * JDBC 2.0
1087 *
1088 * Updates a column with a long value.
1089 *
1090 * The <code>updateXXX</code> methods are used to update column values in the
1091 * current row, or the insert row. The <code>updateXXX</code> methods do not
1092 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1093 * methods are called to update the database.
1094 *
1095 * @param columnName the name of the column
1096 * @param x the new column value
1097 * @exception SQLException if a database access error occurs
1098 */
1099 public void updateLong(String columnName, long x) throws SQLException
1100 {
1101 NotImplemented();
1102 }
1103
1104
1105 /***
1106 * JDBC 2.0
1107 *
1108 * Updates a column with a float value.
1109 *
1110 * The <code>updateXXX</code> methods are used to update column values in the
1111 * current row, or the insert row. The <code>updateXXX</code> methods do not
1112 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1113 * methods are called to update the database.
1114 *
1115 * @param columnName the name of the column
1116 * @param x the new column value
1117 * @exception SQLException if a database access error occurs
1118 */
1119 public void updateFloat(String columnName, float x) throws SQLException
1120 {
1121 NotImplemented();
1122 }
1123
1124
1125 /***
1126 * JDBC 2.0
1127 *
1128 * Updates a column with a double value.
1129 *
1130 * The <code>updateXXX</code> methods are used to update column values in the
1131 * current row, or the insert row. The <code>updateXXX</code> methods do not
1132 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1133 * methods are called to update the database.
1134 *
1135 * @param columnName the name of the column
1136 * @param x the new column value
1137 * @exception SQLException if a database access error occurs
1138 */
1139 public void updateDouble(String columnName, double x) throws SQLException
1140 {
1141 NotImplemented();
1142 }
1143
1144
1145 /***
1146 * JDBC 2.0
1147 *
1148 * Updates a column with a BigDecimal value.
1149 *
1150 * The <code>updateXXX</code> methods are used to update column values in the
1151 * current row, or the insert row. The <code>updateXXX</code> methods do not
1152 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1153 * methods are called to update the database.
1154 *
1155 * @param columnName the name of the column
1156 * @param x the new column value
1157 * @exception SQLException if a database access error occurs
1158 */
1159 public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException
1160 {
1161 NotImplemented();
1162 }
1163
1164
1165 /***
1166 * JDBC 2.0
1167 *
1168 * Updates a column with a String value.
1169 *
1170 * The <code>updateXXX</code> methods are used to update column values in the
1171 * current row, or the insert row. The <code>updateXXX</code> methods do not
1172 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1173 * methods are called to update the database.
1174 *
1175 * @param columnName the name of the column
1176 * @param x the new column value
1177 * @exception SQLException if a database access error occurs
1178 */
1179 public void updateString(String columnName, String x) throws SQLException
1180 {
1181 NotImplemented();
1182 }
1183
1184
1185 /***
1186 * JDBC 2.0
1187 *
1188 * Updates a column with a byte array value.
1189 *
1190 * The <code>updateXXX</code> methods are used to update column values in the
1191 * current row, or the insert row. The <code>updateXXX</code> methods do not
1192 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1193 * methods are called to update the database.
1194 *
1195 * @param columnName the name of the column
1196 * @param x the new column value
1197 * @exception SQLException if a database access error occurs
1198 */
1199 public void updateBytes(String columnName, byte x[]) throws SQLException
1200 {
1201 NotImplemented();
1202 }
1203
1204
1205 /***
1206 * JDBC 2.0
1207 *
1208 * Updates a column with a Date value.
1209 *
1210 * The <code>updateXXX</code> methods are used to update column values in the
1211 * current row, or the insert row. The <code>updateXXX</code> methods do not
1212 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1213 * methods are called to update the database.
1214 *
1215 * @param columnName the name of the column
1216 * @param x the new column value
1217 * @exception SQLException if a database access error occurs
1218 */
1219 public void updateDate(String columnName, java.sql.Date x) throws SQLException
1220 {
1221 NotImplemented();
1222 }
1223
1224
1225 /***
1226 * JDBC 2.0
1227 *
1228 * Updates a column with a Time value.
1229 *
1230 * The <code>updateXXX</code> methods are used to update column values in the
1231 * current row, or the insert row. The <code>updateXXX</code> methods do not
1232 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1233 * methods are called to update the database.
1234 *
1235 * @param columnName the name of the column
1236 * @param x the new column value
1237 * @exception SQLException if a database access error occurs
1238 */
1239 public void updateTime(String columnName, java.sql.Time x) throws SQLException
1240 {
1241 NotImplemented();
1242 }
1243
1244
1245 /***
1246 * JDBC 2.0
1247 *
1248 * Updates a column with a Timestamp value.
1249 *
1250 * The <code>updateXXX</code> methods are used to update column values in the
1251 * current row, or the insert row. The <code>updateXXX</code> methods do not
1252 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1253 * methods are called to update the database.
1254 *
1255 * @param columnName the name of the column
1256 * @param x the new column value
1257 * @exception SQLException if a database access error occurs
1258 */
1259 public void updateTimestamp(String columnName, java.sql.Timestamp x) throws SQLException
1260 {
1261 NotImplemented();
1262 }
1263
1264
1265 /***
1266 * JDBC 2.0
1267 *
1268 * Updates a column with an ascii stream value.
1269 *
1270 * The <code>updateXXX</code> methods are used to update column values in the
1271 * current row, or the insert row. The <code>updateXXX</code> methods do not
1272 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1273 * methods are called to update the database.
1274 *
1275 * @param columnName the name of the column
1276 * @param x the new column value
1277 * @param length of the stream
1278 * @exception SQLException if a database access error occurs
1279 */
1280 public void updateAsciiStream(String columnName,
1281 java.io.InputStream x,
1282 int length) throws SQLException
1283 {
1284 NotImplemented();
1285 }
1286
1287
1288 /***
1289 * JDBC 2.0
1290 *
1291 * Updates a column with a binary stream value.
1292 *
1293 * The <code>updateXXX</code> methods are used to update column values in the
1294 * current row, or the insert row. The <code>updateXXX</code> methods do not
1295 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1296 * methods are called to update the database.
1297 *
1298 * @param columnName the name of the column
1299 * @param x the new column value
1300 * @param length of the stream
1301 * @exception SQLException if a database access error occurs
1302 */
1303 public void updateBinaryStream(String columnName,
1304 java.io.InputStream x,
1305 int length) throws SQLException
1306 {
1307 NotImplemented();
1308 }
1309
1310
1311 /***
1312 * JDBC 2.0
1313 *
1314 * Updates a column with a character stream value.
1315 *
1316 * The <code>updateXXX</code> methods are used to update column values in the
1317 * current row, or the insert row. The <code>updateXXX</code> methods do not
1318 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1319 * methods are called to update the database.
1320 *
1321 * @param columnName the name of the column
1322 * @param x the new column value
1323 * @param length of the stream
1324 * @exception SQLException if a database access error occurs
1325 */
1326 public void updateCharacterStream(String columnName,
1327 java.io.Reader reader,
1328 int length) throws SQLException
1329 {
1330 NotImplemented();
1331 }
1332
1333
1334 /***
1335 * JDBC 2.0
1336 *
1337 * Updates a column with an Object value.
1338 *
1339 * The <code>updateXXX</code> methods are used to update column values in the
1340 * current row, or the insert row. The <code>updateXXX</code> methods do not
1341 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1342 * methods are called to update the database.
1343 *
1344 * @param columnName the name of the column
1345 * @param x the new column value
1346 * @param scale For java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types
1347 * this is the number of digits after the decimal. For all other
1348 * types this value will be ignored.
1349 * @exception SQLException if a database access error occurs
1350 */
1351 public void updateObject(String columnName, Object x, int scale) throws SQLException
1352 {
1353 NotImplemented();
1354 }
1355
1356
1357 /***
1358 * JDBC 2.0
1359 *
1360 * Updates a column with an Object value.
1361 *
1362 * The <code>updateXXX</code> methods are used to update column values in the
1363 * current row, or the insert row. The <code>updateXXX</code> methods do not
1364 * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
1365 * methods are called to update the database.
1366 *
1367 * @param columnName the name of the column
1368 * @param x the new column value
1369 * @exception SQLException if a database access error occurs
1370 */
1371 public void updateObject(String columnName, Object x) throws SQLException
1372 {
1373 NotImplemented();
1374 }
1375
1376
1377 /***
1378 * JDBC 2.0
1379 *
1380 * Inserts the contents of the insert row into the result set and
1381 * the database. Must be on the insert row when this method is called.
1382 *
1383 * @exception SQLException if a database access error occurs,
1384 * if called when not on the insert row, or if not all of non-nullable columns in
1385 * the insert row have been given a value
1386 */
1387 public void insertRow() throws SQLException
1388 {
1389 NotImplemented();
1390 }
1391
1392
1393 /***
1394 * JDBC 2.0
1395 *
1396 * Updates the underlying database with the new contents of the
1397 * current row. Cannot be called when on the insert row.
1398 *
1399 * @exception SQLException if a database access error occurs or
1400 * if called when on the insert row
1401 */
1402 public void updateRow() throws SQLException
1403 {
1404 NotImplemented();
1405 }
1406
1407
1408 /***
1409 * JDBC 2.0
1410 *
1411 * Deletes the current row from the result set and the underlying
1412 * database. Cannot be called when on the insert row.
1413 *
1414 * @exception SQLException if a database access error occurs or if
1415 * called when on the insert row.
1416 */
1417 public void deleteRow() throws SQLException
1418 {
1419 NotImplemented();
1420 }
1421
1422
1423 /***
1424 * JDBC 2.0
1425 *
1426 * Refreshes the current row with its most recent value in
1427 * the database. Cannot be called when on the insert row.
1428 *
1429 * The <code>refreshRow</code> method provides a way for an application to
1430 * explicitly tell the JDBC driver to refetch a row(s) from the
1431 * database. An application may want to call <code>refreshRow</code> when
1432 * caching or prefetching is being done by the JDBC driver to
1433 * fetch the latest value of a row from the database. The JDBC driver
1434 * may actually refresh multiple rows at once if the fetch size is
1435 * greater than one.
1436 *
1437 * All values are refetched subject to the transaction isolation
1438 * level and cursor sensitivity. If <code>refreshRow</code> is called after
1439 * calling <code>updateXXX</code>, but before calling <code>updateRow</code>, then the
1440 * updates made to the row are lost. Calling the method <code>refreshRow</code> frequently
1441 * will likely slow performance.
1442 *
1443 * @exception SQLException if a database access error occurs or if
1444 * called when on the insert row
1445 */
1446 public void refreshRow() throws SQLException
1447 {
1448 NotImplemented();
1449 }
1450
1451
1452 /***
1453 * JDBC 2.0
1454 *
1455 * Cancels the updates made to a row.
1456 * This method may be called after calling an
1457 * <code>updateXXX</code> method(s) and before calling <code>updateRow</code> to rollback
1458 * the updates made to a row. If no updates have been made or
1459 * <code>updateRow</code> has already been called, then this method has no
1460 * effect.
1461 *
1462 * @exception SQLException if a database access error occurs or if
1463 * called when on the insert row
1464 *
1465 */
1466 public void cancelRowUpdates() throws SQLException
1467 {
1468 NotImplemented();
1469 }
1470
1471
1472 /***
1473 * JDBC 2.0
1474 *
1475 * Moves the cursor to the insert row. The current cursor position is
1476 * remembered while the cursor is positioned on the insert row.
1477 *
1478 * The insert row is a special row associated with an updatable
1479 * result set. It is essentially a buffer where a new row may
1480 * be constructed by calling the <code>updateXXX</code> methods prior to
1481 * inserting the row into the result set.
1482 *
1483 * Only the <code>updateXXX</code>, <code>getXXX</code>,
1484 * and <code>insertRow</code> methods may be
1485 * called when the cursor is on the insert row. All of the columns in
1486 * a result set must be given a value each time this method is
1487 * called before calling <code>insertRow</code>.
1488 * The method <code>updateXXX</code> must be called before a
1489 * <code>getXXX</code> method can be called on a column value.
1490 *
1491 * @exception SQLException if a database access error occurs
1492 * or the result set is not updatable
1493 */
1494 public void moveToInsertRow() throws SQLException
1495 {
1496 NotImplemented();
1497 }
1498
1499
1500 /***
1501 * JDBC 2.0
1502 *
1503 * Moves the cursor to the remembered cursor position, usually the
1504 * current row. This method has no effect if the cursor is not on the insert
1505 * row.
1506 *
1507 * @exception SQLException if a database access error occurs
1508 * or the result set is not updatable
1509 */
1510 public void moveToCurrentRow() throws SQLException
1511 {
1512 NotImplemented();
1513 }
1514
1515
1516 /***
1517 * JDBC 2.0
1518 *
1519 * Returns the Statement that produced this <code>ResultSet</code> object.
1520 * If the result set was generated some other way, such as by a
1521 * <code>DatabaseMetaData</code> method, this method returns <code>null</code>.
1522 *
1523 * @return the Statment that produced the result set or
1524 * null if the result set was produced some other way
1525 * @exception SQLException if a database access error occurs
1526 */
1527 public java.sql.Statement getStatement() throws SQLException
1528 {
1529 return stmt;
1530 }
1531
1532
1533 /***
1534 * JDBC 2.0
1535 *
1536 * Returns the value of a column in the current row as a Java object.
1537 * This method uses the given <code>Map</code> object
1538 * for the custom mapping of the
1539 * SQL structured or distinct type that is being retrieved.
1540 *
1541 * @param i the first column is 1, the second is 2, ...
1542 * @param map the mapping from SQL type names to Java classes
1543 * @return an object representing the SQL value
1544 */
1545 public Object getObject(int i, java.util.Map map) throws SQLException
1546 {
1547 NotImplemented();
1548 return null;
1549 }
1550
1551
1552 /***
1553 * JDBC 2.0
1554 *
1555 * Gets a REF(<structured-type>) column value from the current row.
1556 *
1557 * @param i the first column is 1, the second is 2, ...
1558 * @return a <code>Ref</code> object representing an SQL REF value
1559 */
1560 public Ref getRef(int i) throws SQLException
1561 {
1562 NotImplemented();
1563 return null;
1564 }
1565
1566
1567 /***
1568 * JDBC 2.0
1569 *
1570 * Gets a BLOB value in the current row of this <code>ResultSet</code> object.
1571 *
1572 * @param i the first column is 1, the second is 2, ...
1573 * @return a <code>Blob</code> object representing the SQL BLOB value in
1574 * the specified column
1575 */
1576 public Blob getBlob(int i) throws SQLException
1577 {
1578 NotImplemented();
1579 return null;
1580 }
1581
1582
1583 /***
1584 * JDBC 2.0
1585 *
1586 * Gets a CLOB value in the current row of this <code>ResultSet</code> object.
1587 *
1588 * @param i the first column is 1, the second is 2, ...
1589 * @return a <code>Clob</code> object representing the SQL CLOB value in
1590 * the specified column
1591 */
1592 public Clob getClob(int i) throws SQLException
1593 {
1594 NotImplemented();
1595 return null;
1596 }
1597
1598
1599 /***
1600 * JDBC 2.0
1601 *
1602 * Gets an SQL ARRAY value from the current row of this <code>ResultSet</code> object.
1603 *
1604 * @param i the first column is 1, the second is 2, ...
1605 * @return an <code>Array</code> object representing the SQL ARRAY value in
1606 * the specified column
1607 */
1608 public Array getArray(int i) throws SQLException
1609 {
1610 NotImplemented();
1611 return null;
1612 }
1613
1614
1615 /***
1616 * JDBC 2.0
1617 *
1618 * Returns the value in the specified column as a Java object.
1619 * This method uses the specified <code>Map</code> object for
1620 * custom mapping if appropriate.
1621 *
1622 * @param colName the name of the column from which to retrieve the value
1623 * @param map the mapping from SQL type names to Java classes
1624 * @return an object representing the SQL value in the specified column
1625 */
1626 public Object getObject(String colName, java.util.Map map) throws SQLException
1627 {
1628 NotImplemented();
1629 return null;
1630 }
1631
1632
1633 /***
1634 * JDBC 2.0
1635 *
1636 * Gets a REF(<structured-type>) column value from the current row.
1637 *
1638 * @param colName the column name
1639 * @return a <code>Ref</code> object representing the SQL REF value in
1640 * the specified column
1641 */
1642 public Ref getRef(String colName) throws SQLException
1643 {
1644 NotImplemented();
1645 return null;
1646 }
1647
1648
1649 /***
1650 * JDBC 2.0
1651 *
1652 * Gets a BLOB value in the current row of this <code>ResultSet</code> object.
1653 *
1654 * @param colName the name of the column from which to retrieve the value
1655 * @return a <code>Blob</code> object representing the SQL BLOB value in
1656 * the specified column
1657 */
1658 public Blob getBlob(String colName) throws SQLException
1659 {
1660 NotImplemented();
1661 return null;
1662 }
1663
1664
1665 /***
1666 * JDBC 2.0
1667 *
1668 * Gets a CLOB value in the current row of this <code>ResultSet</code> object.
1669 *
1670 * @param colName the name of the column from which to retrieve the value
1671 * @return a <code>Clob</code> object representing the SQL CLOB value in
1672 * the specified column
1673 */
1674 public Clob getClob(String colName) throws SQLException
1675 {
1676 NotImplemented();
1677 return null;
1678 }
1679
1680
1681 /***
1682 * JDBC 2.0
1683 *
1684 * Gets an SQL ARRAY value in the current row of this <code>ResultSet</code> object.
1685 *
1686 * @param colName the name of the column from which to retrieve the value
1687 * @return an <code>Array</code> object representing the SQL ARRAY value in
1688 * the specified column
1689 */
1690 public Array getArray(String colName) throws SQLException
1691 {
1692 NotImplemented();
1693 return null;
1694 }
1695
1696
1697
1698 /***
1699 * Gets the value of a column in the current row as a java.sql.Timestamp
1700 * object. This method uses the given calendar to construct an
1701 * appropriate millisecond value for the Timestamp if the underlying
1702 * database does not store timezone information.
1703 *
1704 * @param columnIndex the first column is 1, the second is 2, ...
1705 * @param cal the calendar to use in constructing the timestamp
1706 * @return the column value; if the value is SQL NULL, the result is null
1707 * @exception SQLException if a database access error occurs
1708 */
1709 public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal)
1710 throws SQLException
1711 {
1712 NotImplemented();
1713 return null;
1714 }
1715
1716
1717 /***
1718 * Gets the value of a column in the current row as a
1719 * java.sql.Timestamp object. This method uses the given calendar
1720 * to construct an appropriate millisecond value for the Timestamp
1721 * if the underlying database does not store timezone information.
1722 *
1723 * @param columnName the SQL name of the column
1724 * @param cal the calendar to use in constructing the timestamp
1725 * @return the column value; if the value is SQL NULL, the result is null
1726 * @exception SQLException if a database access error occurs
1727 */
1728 public java.sql.Timestamp getTimestamp(String columnName, Calendar cal)
1729 throws SQLException
1730 {
1731 NotImplemented();
1732 return null;
1733 }
1734
1735
1736
1737 /***
1738 * JDBC 2.0
1739 *
1740 * Gets the value of a column in the current row as a
1741 * java.sql.Date object. This method uses the given calendar to
1742 * construct an appropriate millisecond value for the Date if the
1743 * underlying database does not store timezone information.
1744 *
1745 * @param columnIndex the first column is 1, the second is 2, ...
1746 * @param cal the calendar to use in constructing the date
1747 * @return the column value; if the value is SQL NULL, the result is null
1748 * @exception SQLException if a database access error occurs
1749 */
1750 public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLException
1751 {
1752 NotImplemented();
1753 return null;
1754 }
1755
1756
1757 /***
1758 * Gets the value of a column in the current row as a
1759 * java.sql.Date object. This method uses the given calendar to
1760 * construct an appropriate millisecond value for the Date, if the
1761 * underlying database does not store timezone information.
1762 *
1763 * @param columnName the SQL name of the column from which to retrieve the value
1764 * @param cal the calendar to use in constructing the date
1765 * @return the column value; if the value is SQL NULL, the result is null
1766 * @exception SQLException if a database access error occurs
1767 */
1768 public java.sql.Date getDate(String columnName, Calendar cal) throws SQLException
1769 {
1770 NotImplemented();
1771 return null;
1772 }
1773
1774
1775 /***
1776 * Gets the value of a column in the current row as a
1777 * java.sql.Time object. This method uses the given calendar to
1778 * construct an appropriate millisecond value for the Time if the
1779 * underlying database does not store timezone information.
1780 *
1781 * @param columnIndex the first column is 1, the second is 2, ...
1782 * @param cal the calendar to use in constructing the time
1783 * @return the column value; if the value is SQL NULL, the result is null
1784 * @exception SQLException if a database access error occurs
1785 */
1786 public java.sql.Time getTime(int columnIndex, Calendar cal)
1787 throws SQLException
1788 {
1789 NotImplemented();
1790 return null;
1791 }
1792
1793
1794 /***
1795 * Gets the value of a column in the current row as a java.sql.Time
1796 * object. This method uses the given calendar to construct an
1797 * appropriate millisecond
1798 * value for the Time if the underlying database does not store
1799 * timezone information.
1800 *
1801 * @param columnName the SQL name of the column
1802 * @param cal the calendar to use in constructing the time
1803 * @return the column value; if the value is SQL NULL, the result is null
1804 * @exception SQLException if a database access error occurs
1805 */
1806 public java.sql.Time getTime(String columnName, Calendar cal)
1807 throws SQLException
1808 {
1809 NotImplemented();
1810 return null;
1811 }
1812
1813 //---------------------------------------------------------------------
1814 // JDBC 3.0
1815 //---------------------------------------------------------------------
1816
1817 public URL getURL(int columnIndex) throws SQLException {
1818 throw new UnsupportedOperationException("ResultSet.getURL(int) unsupported");
1819 }
1820
1821 public URL getURL(String columnName) throws SQLException {
1822 throw new UnsupportedOperationException("ResultSet.getURL(String) unsupported");
1823 }
1824
1825 public void updateRef(int columnIndex, Ref x) throws SQLException {
1826 throw new UnsupportedOperationException("ResultSet.updateRef(int,java.sql.Ref) unsupported");
1827 }
1828
1829 public void updateRef(String columnName, Ref x) throws SQLException {
1830 throw new UnsupportedOperationException("ResultSet.updateRef(String,java.sql.Ref) unsupported");
1831 }
1832
1833 public void updateBlob(int columnIndex, Blob x) throws SQLException {
1834 throw new UnsupportedOperationException("ResultSet.updateBlob(int,java.sql.Blob) unsupported");
1835 }
1836
1837 public void updateBlob(String columnName, Blob x) throws SQLException {
1838 throw new UnsupportedOperationException("ResultSet.updateBlob(String,java.sql.Blob) unsupported");
1839 }
1840
1841 public void updateClob(int columnIndex, Clob x) throws SQLException {
1842 throw new UnsupportedOperationException("ResultSet.updateClob(int,java.sql.Clob) unsupported");
1843 }
1844
1845 public void updateClob(String columnName, Clob x) throws SQLException {
1846 throw new UnsupportedOperationException("ResultSet.updateClob(String,java.sql.Clob) unsupported");
1847 }
1848
1849 public void updateArray(int columnIndex, Array x) throws SQLException {
1850 throw new UnsupportedOperationException("ResultSet.updateArray(int,java.sql.Array) unsupported");
1851 }
1852
1853 public void updateArray(String columnName, Array x) throws SQLException {
1854 throw new UnsupportedOperationException("ResultSet.updateArray(String,java.sql.Array) unsupported");
1855 }
1856
1857
1858
1859
1860 }
This page was automatically generated by Maven