SSRowSetAdapter


1   /* $Id: SSRowSetAdapter.java,v 1.7 2005/02/10 15:53:10 yoda2 Exp $
2    *
3    * Tab Spacing = 4
4    *
5    * Copyright (c) 2004-2005, The Pangburn Company and Prasanth R. Pasala
6    * All rights reserved.
7    *
8    * Redistribution and use in source and binary forms, with or without
9    * modification, are permitted provided that the following conditions are met:
10   *
11   * Redistributions of source code must retain the above copyright notice, this
12   * list of conditions and the following disclaimer.  Redistributions in binary
13   * form must reproduce the above copyright notice, this list of conditions and
14   * the following disclaimer in the documentation and/or other materials
15   * provided with the distribution.  The names of its contributors may not be
16   * used to endorse or promote products derived from this software without
17   * specific prior written permission.
18   *
19   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
20   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
23   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29   * POSSIBILITY OF SUCH DAMAGE.
30   *
31   */
32  
33   package com.nqadmin.swingSet.datasources;
34  
35   import java.io.Serializable  ;
36   import javax.sql.RowSetListener  ;
37   import java.sql.Date  ;
38   import java.sql.SQLException  ;
39  
40  /**
41   * SSRowSetAdapter.java
42   *<p>
43   * SwingSet - Open Toolkit For Making Swing Controls Database-Aware
44   *<p><pre>
45   * Abstract class that provides empty implementations of all the methods for the
46   * SSRowSet interface.
47   *
48   * This class is provided for convenience. so that users wishing to write their
49   * own SSRowSet implementations can just extend the abstract class and override
50   * the desired methods.
51   *</pre><p>
52   * @author  $Author: yoda2 $
53   * @version $Revision: 1.7 $
54   */
55   public class SSRowSetAdapter implements SSRowSet {
56  
57      /**
58       * Retrieves the value of the designated column in the current row of this DataSet
59       * object as a boolean in the Java programming language.
60       * @param columnIndex - column number . first column is 1, second column is 2....
61       * @return returns the column value of the current row, if the value is null then a false
62       * is returned.
63       * @throws throws an SQL exception if an access error occurs.
64       */
65      public boolean getBoolean(int columnIndex) throws SQLException  {
66          throw new UnsupportedOperationException  ();
67      }
68  
69      /**
70       * Retrieves the value of the designated column in the current row of this DataSet
71       * object as a int in the Java programming language.
72       * @param columnIndex - column number . first column is 1, second column is 2....
73       * @return returns the column value of the current row, if the value is null then 0
74       * is returned.
75       * @throws throws an SQL exception if an access error occurs.
76       */
77      public int getInt(int columnIndex) throws SQLException  {
78          throw new UnsupportedOperationException  ();
79      }
80  
81      /**
82       * Retrieves the value of the designated column in the current row of this DataSet
83       * object as a long in the Java programming language.
84       * @param columnIndex - column number . first column is 1, second column is 2....
85       * @return returns the column value of the current row, if the value is null then 0
86       * is returned.
87       * @throws throws an SQL exception if an access error occurs.
88       */
89      public long getLong(int columnIndex) throws SQLException  {
90          throw new UnsupportedOperationException  ();
91      }
92  
93      /**
94       * Retrieves the value of the designated column in the current row of this DataSet
95       * object as a float in the Java programming language.
96       * @param columnIndex - column number . first column is 1, second column is 2....
97       * @return returns the column value of the current row, if the value is null then 0
98       * is returned.
99       * @throws throws an SQL exception if an access error occurs.
100      */
101     public float getFloat(int columnIndex) throws SQLException  {
102         throw new UnsupportedOperationException  ();
103     }
104 
105     /**
106      * Retrieves the value of the designated column in the current row of this DataSet
107      * object as a double in the Java programming language.
108      * @param columnIndex - column number . first column is 1, second column is 2....
109      * @return returns the column value of the current row, if the value is null then 0
110      * is returned.
111      * @throws throws an SQL exception if an access error occurs.
112      */
113     public double getDouble(int columnIndex) throws SQLException  {
114         throw new UnsupportedOperationException  ();
115     }
116 
117     /**
118      * Retrieves the value of the designated column in the current row of this DataSet
119      * object as a String in the Java programming language.
120      * @param columnIndex - column number . first column is 1, second column is 2....
121      * @return returns the column value of the current row, if the value is null then a null
122      * is returned.
123      * @throws throws an SQL exception if an access error occurs.
124      */
125     public String   getString(int columnIndex) throws SQLException  {
126         throw new UnsupportedOperationException  ();
127     }
128 
129     /**
130      * Retrieves the value of the designated column in the current row of this DataSet
131      * object as a Date in the Java programming language.
132      * @param columnIndex - column number . first column is 1, second column is 2....
133      * @return returns the column value of the current row, if the value is null then null
134      * is returned.
135      * @throws throws an SQL exception if an access error occurs.
136      */
137     public Date   getDate(int columnIndex) throws SQLException  {
138         throw new UnsupportedOperationException  ();
139     }
140     
141     /**
142      * Retrieves the value of the designated column in the current row of this ResultSet
143      * object as a byte array in the Java programming language. The bytes represent the
144      * raw values returned by the driver.
145      * @param columnIndex - index number of the column
146      * @return  returns the column value; if the value is SQL NULL, the value returned is null 
147      * @throws throws an SQLException - if a database access error occurs
148      */ 
149     public byte[] getBytes(int columnIndex) throws SQLException   {
150         throw new UnsupportedOperationException  ();
151     }
152 
153     /**
154      * Updates the designated column with a boolean value. The updater methods are used to
155      * update column values in the current row or the insert row. The updater methods do
156      * not update the underlying data source; instead the updateRow or insertRow methods are called
157      * to update the underlying data source.
158      * @param columnIndex - index number of the column. first column is 1, second column is 2......
159      * @param x - new column value
160      * @throws throws an SQL exception if an access error occurs.
161      */
162     public void updateBoolean(int columnIndex, boolean x) throws SQLException  {
163         throw new UnsupportedOperationException  ();
164     }
165 
166     /**
167      * Updates the designated column with a int value. The updater methods are used to
168      * update column values in the current row or the insert row. The updater methods do
169      * not update the underlying data source; instead the updateRow or insertRow methods are called
170      * to update the underlying data source.
171      * @param columnIndex - index number of the column. first column is 1, second column is 2......
172      * @param x - new column value
173      * @throws throws an SQL exception if an access error occurs.
174      */
175     public void updateInt(int columnIndex, int x) throws SQLException  {
176         throw new UnsupportedOperationException  ();
177     }
178 
179     /**
180      * Updates the designated column with a long value. The updater methods are used to
181      * update column values in the current row or the insert row. The updater methods do
182      * not update the underlying data source; instead the updateRow or insertRow methods are called
183      * to update the underlying data source.
184      * @param columnIndex - index number of the column. first column is 1, second column is 2......
185      * @param x - new column value
186      * @throws throws an SQL exception if an access error occurs.
187      */
188     public void updateLong(int columnIndex, long x) throws SQLException  {
189         throw new UnsupportedOperationException  ();
190     }
191 
192     /**
193      * Updates the designated column with a float value. The updater methods are used to
194      * update column values in the current row or the insert row. The updater methods do
195      * not update the underlying data source; instead the updateRow or insertRow methods are called
196      * to update the underlying data source.
197      * @param columnIndex - index number of the column. first column is 1, second column is 2......
198      * @param x - new column value
199      * @throws throws an SQL exception if an access error occurs.
200      */
201     public void updateFloat(int columnIndex, float x) throws SQLException  {
202         throw new UnsupportedOperationException  ();
203     }
204 
205     /**
206      * Updates the designated column with a double value. The updater methods are used to
207      * update column values in the current row or the insert row. The updater methods do
208      * not update the underlying data source; instead the updateRow or insertRow methods are called
209      * to update the underlying data source.
210      * @param columnIndex - index number of the column. first column is 1, second column is 2......
211      * @param x - new column value
212      * @throws throws an SQL exception if an access error occurs.
213      */
214     public void updateDouble(int columnIndex, double x) throws SQLException  {
215         throw new UnsupportedOperationException  ();
216     }
217 
218     /**
219      * Updates the designated column with a String value. The updater methods are used to
220      * update column values in the current row or the insert row. The updater methods do
221      * not update the underlying data source; instead the updateRow or insertRow methods are called
222      * to update the underlying data source.
223      * @param columnIndex - index number of the column. first column is 1, second column is 2......
224      * @param x - new column value
225      * @throws throws an SQL exception if an access error occurs.
226      */
227     public void updateString(int columnIndex, String   x) throws SQLException  {
228         throw new UnsupportedOperationException  ();
229     }
230 
231     /**
232      * Updates the designated column with a Date value. The updater methods are used to
233      * update column values in the current row or the insert row. The updater methods do
234      * not update the underlying data source; instead the updateRow or insertRow methods are called
235      * to update the underlying data source.
236      * @param columnIndex - index number of the column. first column is 1, second column is 2......
237      * @param x - new column value
238      * @throws throws an SQL exception if an access error occurs.
239      */
240     public void updateDate(int columnIndex, Date   x) throws SQLException  {
241         throw new UnsupportedOperationException  ();
242     }
243     
244     /**
245      * Updates the designated column with a byte array value. The updater methods are
246      * used to update column values in the current row or the insert row. The updater
247      * methods do not update the underlying database; instead the updateRow or insertRow
248      * methods are called to update the database.
249      * @param columnIndex - the index number of the column
250      * @param x - the new column value 
251      * @throws throws an SQLException - if a database access error occurs
252      */
253     public void updateBytes(int columnIndex, byte[] x) throws SQLException   {
254         throw new UnsupportedOperationException  ();
255     }
256 
257     /**
258      * Updates the designated column with a null value. The updater methods are used to
259      * update column values in the current row or the insert row. The updater methods do
260      * not update the underlying data source; instead the updateRow or insertRow methods are called
261      * to update the underlying data source.
262      * @param columnIndex - index number of the column. first column is 1, second column is 2......
263      * @throws throws an SQL exception if an access error occurs.
264      */
265     public void updateNull(int columnIndex) throws SQLException  {
266         throw new UnsupportedOperationException  ();
267     }
268 
269     /**
270      * Retrieves the value of the designated column in the current row of this DataSet
271      * object as a boolean in the Java programming language.
272      * @param columnName - name of the column
273      * @return returns the column value of the current row, if the value is null then a false
274      * is returned.
275      * @throws throws an SQL exception if an access error occurs.
276      */
277     public boolean getBoolean(String   columnName) throws SQLException  {
278         throw new UnsupportedOperationException  ();
279     }
280 
281     /**
282      * Retrieves the value of the designated column in the current row of this DataSet
283      * object as a int in the Java programming language.
284      * @param columnName - name of the column
285      * @return returns the column value of the current row, if the value is null then 0
286      * is returned.
287      * @throws throws an SQL exception if an access error occurs.
288      */
289     public int getInt(String   columnName) throws SQLException  {
290         throw new UnsupportedOperationException  ();
291     }
292 
293     /**
294      * Retrieves the value of the designated column in the current row of this DataSet
295      * object as a long in the Java programming language.
296      * @param columnName - name of the column
297      * @return returns the column value of the current row, if the value is null then 0
298      * is returned.
299      * @throws throws an SQL exception if an access error occurs.
300      */
301     public long getLong(String   columnName) throws SQLException  {
302         throw new UnsupportedOperationException  ();
303     }
304 
305     /**
306      * Retrieves the value of the designated column in the current row of this DataSet
307      * object as a float in the Java programming language.
308      * @param columnName - name of the column
309      * @return returns the column value of the current row, if the value is null then 0
310      * is returned.
311      * @throws throws an SQL exception if an access error occurs.
312      */
313     public float getFloat(String   columnName) throws SQLException  {
314         throw new UnsupportedOperationException  ();
315     }
316 
317     /**
318      * Retrieves the value of the designated column in the current row of this DataSet
319      * object as a double in the Java programming language.
320      * @param columnName - name of the column
321      * @return returns the column value of the current row, if the value is null then 0
322      * is returned.
323      * @throws throws an SQL exception if an access error occurs.
324      */
325     public double getDouble(String   columnName) throws SQLException  {
326         throw new UnsupportedOperationException  ();
327     }
328 
329     /**
330      * Retrieves the value of the designated column in the current row of this DataSet
331      * object as a String in the Java programming language.
332      * @param columnName - name of the column
333      * @return returns the column value of the current row, if the value is null then a null
334      * is returned.
335      * @throws throws an SQL exception if an access error occurs.
336      */
337     public String   getString(String   columnName) throws SQLException  {
338         throw new UnsupportedOperationException  ();
339     }
340 
341     /**
342      * Retrieves the value of the designated column in the current row of this DataSet
343      * object as a Date in the Java programming language.
344      * @param columnName - name of the column
345      * @return returns the column value of the current row, if the value is null then a null
346      * is returned.
347      * @throws throws an SQL exception if an access error occurs.
348      */
349     public Date   getDate(String   columnName) throws SQLException  {
350         throw new UnsupportedOperationException  ();
351     }
352 
353     /**
354      * Retrieves the value of the designated column in the current row of this ResultSet
355      * object as a byte array in the Java programming language. The bytes represent the
356      * raw values returned by the driver.
357      * @param columnName - the SQL name of the column
358      * @return  returns the column value; if the value is SQL NULL, the value returned is null 
359      * @throws throws an SQLException - if a database access error occurs
360      */    
361     public byte[] getBytes(String   columnName) throws SQLException   {
362         throw new UnsupportedOperationException  ();
363     }
364     
365     /**
366      * Updates the designated column with a boolean value. The updater methods are used to
367      * update column values in the current row or the insert row. The updater methods do
368      * not update the underlying data source; instead the updateRow or insertRow methods are called
369      * to update the underlying data source.
370      * @param columnName - name of the column
371      * @param x - new column value
372      * @throws throws an SQL exception if an access error occurs.
373      */
374     public void updateBoolean(String   columnName, boolean x) throws SQLException  {
375         throw new UnsupportedOperationException  ();
376     }
377 
378     /**
379      * Updates the designated column with a int value. The updater methods are used to
380      * update column values in the current row or the insert row. The updater methods do
381      * not update the underlying data source; instead the updateRow or insertRow methods are called
382      * to update the underlying data source.
383      * @param columnName - name of the column
384      * @param x - new column value
385      * @throws throws an SQL exception if an access error occurs.
386      */
387     public void updateInt(String   columnName, int x) throws SQLException  {
388         throw new UnsupportedOperationException  ();
389     }
390 
391     /**
392      * Updates the designated column with a long value. The updater methods are used to
393      * update column values in the current row or the insert row. The updater methods do
394      * not update the underlying data source; instead the updateRow or insertRow methods are called
395      * to update the underlying data source.
396      * @param columnName - name of the column
397      * @param x - new column value
398      * @throws throws an SQL exception if an access error occurs.
399      */
400     public void updateLong(String   columnName, long x) throws SQLException  {
401         throw new UnsupportedOperationException  ();
402     }
403 
404     /**
405      * Updates the designated column with a float value. The updater methods are used to
406      * update column values in the current row or the insert row. The updater methods do
407      * not update the underlying data source; instead the updateRow or insertRow methods are called
408      * to update the underlying data source.
409      * @param columnName - name of the column
410      * @param x - new column value
411      * @throws throws an SQL exception if an access error occurs.
412      */
413     public void updateFloat(String   columnName, float x) throws SQLException  {
414         throw new UnsupportedOperationException  ();
415     }
416 
417     /**
418      * Updates the designated column with a double value. The updater methods are used to
419      * update column values in the current row or the insert row. The updater methods do
420      * not update the underlying data source; instead the updateRow or insertRow methods are called
421      * to update the underlying data source.
422      * @param columnName - name of the column
423      * @param x - new column value
424      * @throws throws an SQL exception if an access error occurs.
425      */
426     public void updateDouble(String   columnName, double x) throws SQLException  {
427         throw new UnsupportedOperationException  ();
428     }
429 
430     /**
431      * Updates the designated column with a String value. The updater methods are used to
432      * update column values in the current row or the insert row. The updater methods do
433      * not update the underlying data source; instead the updateRow or insertRow methods are called
434      * to update the underlying data source.
435      * @param columnName - name of the column
436      * @param x - new column value
437      * @throws throws an SQL exception if an access error occurs.
438      */
439     public void updateString(String   columnName, String   x) throws SQLException  {
440         throw new UnsupportedOperationException  ();
441     }
442 
443     /**
444      * Updates the designated column with a Date value. The updater methods are used to
445      * update column values in the current row or the insert row. The updater methods do
446      * not update the underlying data source; instead the updateRow or insertRow methods are called
447      * to update the underlying data source.
448      * @param columnName - name of the column
449      * @param x - new column value
450      * @throws throws an SQL exception if an access error occurs.
451      */
452     public void updateDate(String   columnName, Date   x) throws SQLException  {
453         throw new UnsupportedOperationException  ();
454     }
455     
456     /**
457      * Updates the designated column with a byte array value. The updater methods are
458      * used to update column values in the current row or the insert row. The updater
459      * methods do not update the underlying database; instead the updateRow or insertRow
460      * methods are called to update the database.
461      * @param columnName - the name of the column
462      * @param x - the new column value 
463      * @throws throws an SQLException - if a database access error occurs
464      */
465     public void updateBytes(String   columnName, byte[] x) throws SQLException   {
466         throw new UnsupportedOperationException  ();
467     }
468 
469     /**
470      * Updates the designated column with a null value. The updater methods are used to
471      * update column values in the current row or the insert row. The updater methods do
472      * not update the underlying data source; instead the updateRow or insertRow methods are called
473      * to update the underlying data source.
474      * @param columnName - name of the column
475      * @throws throws an SQL exception if an access error occurs.
476      */
477     public void updateNull(String   columnName) throws SQLException  {
478         throw new UnsupportedOperationException  ();
479     }
480 
481     /**
482      * The listener will be notified whenever an event occurs on this RowSet object.
483      *
484      * Note: if the RowSetListener object is null, this method silently discards the null
485      * value and does not add a null reference to the set of listeners.
486      *
487      * Note: if the listener is already set, and the new RowSetListerner instance is added
488      * to the set of listeners already registered to receive event notifications from this
489      * RowSet
490      *
491      * @param listener - an object that has implemented the javax.sql.RowSetListener interface
492      * and wants to be notified of any events that occur on this RowSet object; May be null
493      */
494     public void addRowSetListener(RowSetListener   listener){
495         throw new UnsupportedOperationException  ();
496     }
497 
498     /**
499      * Removes the designated object from this RowSet object's list of listeners. If the given
500      * argument is not a registered listener, this method does nothing.
501      * Note: if the RowSetListener object is null, this method silently discards the null value
502      * @param listener - a RowSetListener object that is on the list of listeners for this RowSet object
503      */
504     public void removeRowSetListener(RowSetListener   listener){
505         throw new UnsupportedOperationException  ();
506     }
507 
508     /**
509      * Maps the given column name to its column index
510      * @param columnIndex - column number first column is 1, second column is 2 .....
511      * @return the column name of the given column index
512      * @throws SQLException - if the object does not contain columnIndex or a access
513      * error occurs
514      */
515     public String   getColumnName(int columnIndex) throws SQLException  {
516         throw new UnsupportedOperationException  ();
517     }
518 
519     /**
520      * Get the designated column's index
521      * @param columnName - name of the column
522      * @return returns the corresponding column index.
523      * @throws SQLException - if a data access error
524      */
525     public int getColumnIndex(String   columnName) throws SQLException  {
526         throw new UnsupportedOperationException  ();
527     }
528 
529     /**
530      * Retrieves the designated column's type
531      * @param columnName - name of the column
532      * @return SQL type from java.sql.Types
533      * @throws SQLException - if a data access error occurs
534      */
535     public int getColumnType(String   columnName) throws SQLException  {
536         throw new UnsupportedOperationException  ();
537     }
538 
539     /**
540      * Retrieves the designated column's type
541      * @param columnIndex - column number first column is 1, second column is 2 .....
542      * @return SQL type from java.sql.Types
543      * @throws SQLException - if a data access error occurs
544      */
545     public int getColumnType(int columnIndex) throws SQLException  {
546         throw new UnsupportedOperationException  ();
547     }
548 
549     /**
550      * Retrieves the current row number. The first row is number 1, the second number 2,
551      * and so on.
552      * @return the current row number; 0 if there is no current row
553      * @throws SQLException - if a data access error occurs
554      */
555     public int getRow() throws SQLException  {
556         throw new UnsupportedOperationException  ();
557     }
558 
559     /**
560      * Returns the number of columns in this ResultSet object
561      * @return the number of columns
562      * @throws SQLException - if a data access error occurs
563      */
564     public int getColumnCount() throws SQLException  {
565         throw new UnsupportedOperationException  ();
566     }
567 
568     /**
569      * Moves the cursor down one row from its current position. A ResultSet cursor is
570      * initially positioned before the first row; the first call to the method next makes the
571      * first row the current row; the second call makes the second row the current row,
572      * and so on.
573      * If an input stream is open for the current row, a call to the method next will
574      * implicitly close it. A ResultSet object's warning chain is cleared when a new row
575      * is read.
576      * @return true if the new current row is valid; false if there are no more rows
577      * @throws SQLException - if a data access error occurs
578      */
579     public boolean next() throws SQLException  {
580         throw new UnsupportedOperationException  ();
581     }
582 
583     /**
584      * Moves the cursor to the previous row in this ResultSet object.
585      * @return true if the cursor is on a valid row; false if it is off the result set
586      * @throws SQLException - if a data access error occurs
587      */
588     public boolean previous() throws SQLException  {
589         throw new UnsupportedOperationException  ();
590     }
591 
592     /**
593      * Moves the cursor to the last row in this ResultSet object.
594      * @return true if the cursor is on a valid row; false if there are no rows in the
595      * result set
596      * @throws SQLException - if a data access error occurs
597      */
598     public boolean last() throws SQLException  {
599         throw new UnsupportedOperationException  ();
600     }
601 
602     /**
603      * Moves the cursor to the first row in this ResultSet object.
604      * @return true if the cursor is on a valid row; false if there are no rows in the
605      * result set
606      * @throws SQLException - if a data access error occurs
607      */
608     public boolean first() throws SQLException  {
609         throw new UnsupportedOperationException  ();
610     }
611 
612     /**
613      * Retrieves whether the cursor is on the first row of this ResultSet object.
614      * @return true if the cursor is on the first row; false otherwise
615      * @throws SQLException - if a data access error occurs
616      */
617     public boolean isFirst() throws SQLException  {
618         throw new UnsupportedOperationException  ();
619     }
620 
621     /**
622      * Retrieves whether the cursor is on the last row of this ResultSet object.
623      * Note: Calling the method isLast may be expensive because the JDBC driver might
624      * need to fetch ahead one row in order to determine whether the current row is the
625      * last row in the result set.
626      * @return true if the cursor is on the last row; false otherwise
627      * @throws SQLException - if a data access error occurs
628      */
629     public boolean isLast() throws SQLException  {
630         throw new UnsupportedOperationException  ();
631     }
632 
633     /**
634      * Moves the cursor to the front of this ResultSet object, just before the first row.
635      * This method has no effect if the result set contains no rows.
636      * @throws SQLException - if a data access error occurs
637      */
638     public void beforeFirst() throws SQLException  {
639         throw new UnsupportedOperationException  ();
640     }
641 
642     /**
643      *<pre>
644      * Moves the cursor to the given row number in this ResultSet object.
645      *      If the row number is positive, the cursor moves to the given row number with
646      * respect to the beginning of the result set. The first row is row 1, the second is
647      * row 2, and so on.
648      *      If the given row number is negative, the cursor moves to an absolute row position
649      * with respect to the end of the result set. For example, calling the method absolute(-1)
650      * positions the cursor on the last row; calling the method absolute(-2) moves the cursor
651      * to the next-to-last row, and so on.
652      * An attempt to position the cursor beyond the first/last row in the result set leaves
653      * the cursor before the first row or after the last row.
654      *</pre>
655      * @param row - the number of the row to which the cursor should move.
656      * @return true if the cursor is on the result set; false otherwise
657      * @throws SQLException - if a database access error occurs
658      */
659     public boolean absolute(int row) throws SQLException  {
660         throw new UnsupportedOperationException  ();
661     }
662 
663     /**
664      * Updates the underlying database with the new contents of the current row of this
665      * ResultSet object. This method cannot be called when the cursor is on the insert row.
666      * @throws SQLException - if a data access error occurs or if this method is called when
667      * the cursor is on the insert row
668      */
669     public void updateRow() throws SQLException  {
670         throw new UnsupportedOperationException  ();
671     }
672 
673     /**
674      * Moves the cursor to the remembered cursor position, usually the current row.
675      * This method has no effect if the cursor is not on the insert row.
676      * @throws SQLException - if a data access error occurs
677      */
678     public void moveToCurrentRow() throws SQLException  {
679         throw new UnsupportedOperationException  ();
680     }
681 
682     /**
683      * Moves the cursor to the insert row. The current cursor position is remembered
684      * while the cursor is positioned on the insert row. The insert row is a special
685      * row associated with an updatable result set. It is essentially a buffer where
686      * a new row may be constructed by calling the updater methods prior to inserting
687      * the row into the result set. Only the updater, getter, and insertRow methods may
688      * be called when the cursor is on the insert row. All of the columns in a result
689      * set must be given a value each time this method is called before calling insertRow.
690      * An updater method must be called before a getter method can be called on a column
691      * value.
692      * @throws SQLException - if a data access error occurs
693      */
694     public void moveToInsertRow() throws SQLException  {
695         throw new UnsupportedOperationException  ();
696     }
697 
698     /**
699      * Inserts the contents of the insert row into this ResultSet object and into the
700      * database. The cursor must be on the insert row when this method is called.
701      * @throws SQLException - if a data access error occurs,if this method is called when
702      * the cursor is not on the insert row, or if not all of non-nullable columns in the
703      * insert row have been given a value
704      */
705     public void insertRow() throws SQLException  {
706         throw new UnsupportedOperationException  ();
707     }
708 
709     /**
710      * Deletes the current row from this ResultSet object and from the underlying
711      * database. This method cannot be called when the cursor is on the insert row.
712      * @throws SQLException - if a data access error occurs or if this method is called
713      * when the cursor is on the insert row
714      */
715     public void deleteRow() throws SQLException  {
716         throw new UnsupportedOperationException  ();
717     }
718 
719     /**
720      * Cancels the updates made to the current row in this ResultSet object. This method
721      * may be called after calling an updater method(s) and before calling the method
722      * updateRow to roll back the updates made to a row. If no updates have been made or
723      * updateRow has already been called, this method has no effect
724      * @throws SQLException - if a data access error occurs or if this method is called when
725      * the cursor is on the insert row
726      */
727     public void cancelRowUpdates() throws SQLException  {
728         throw new UnsupportedOperationException  ();
729     }
730 
731     /**
732      * Refreshes the current row with its most recent value in the database. This
733      * method cannot be called when the cursor is on the insert row.
734      * The refreshRow method provides a way for an application to explicitly tell the
735      * JDBC driver to refetch a row(s) from the database. An application may want to
736      * call refreshRow when caching or prefetching is being done by the JDBC driver to
737      * fetch the latest value of a row from the database. The JDBC driver may actually
738      * refresh multiple rows at once if the fetch size is greater than one.
739      * All values are refetched subject to the transaction isolation level and cursor
740      * sensitivity. If refreshRow is called after calling an updater method, but before
741      * calling the method updateRow, then the updates made to the row are lost. Calling
742      * the method refreshRow frequently will likely slow performance
743      * @throws SQLException - if a data access error occurs or if this method is called
744      * when the cursor is on the insert row
745      */
746     public void refreshRow() throws SQLException  {
747         throw new UnsupportedOperationException  ();
748     }
749 
750     /**
751      * Fills this RowSet object with data.
752      * If the required properties have not been set, an exception is thrown. If this
753      * method is successful, the current contents of the rowset are discarded. If there
754      * are outstanding updates, they are ignored.
755      * @throws SQLException - if a data access error occurs or any of the properties necessary
756      * for making a connection have not been set
757      */
758     public void execute() throws SQLException  {
759         throw new UnsupportedOperationException  ();
760     }
761 
762  }
763 
764 /*
765  * $Log: SSRowSetAdapter.java,v $
766  * Revision 1.7  2005/02/10 15:53:10  yoda2
767  * Added class descriptions to JavaDoc.
768  *
769  * Revision 1.6  2005/02/09 23:04:02  yoda2
770  * JavaDoc cleanup.
771  *
772  * Revision 1.5  2005/02/04 22:49:10  yoda2
773  * API cleanup & updated Copyright info.
774  *
775  * Revision 1.4  2005/01/18 20:58:17  prasanth
776  * Added function to get & set bytes.
777  *
778  * Revision 1.3  2004/11/11 14:45:57  yoda2
779  * Using TextPad, converted all tabs to "soft" tabs comprised of four actual spaces.
780  *
781  * Revision 1.2  2004/11/01 15:53:19  yoda2
782  * Fixed various JavaDoc errors.
783  *
784  * Revision 1.1  2004/10/25 21:47:50  prasanth
785  * Initial Commit
786  *
787  */
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags