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 <