Java > Open Source Codes > com > internetcds > jdbc > tds > ResultSet_2_0


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.1 2006/06/23 10:39:30 sinisa 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(&lt;structured-type&gt;) 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(&lt;structured-type&gt;) 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}
1861

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags