History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/com/sun/rowset/internal/SyncResolverImpl.java (1 of 18352 files). Show all

Unified · Split

java/pkg/com/sun/rowset/internal/SyncResolverImpl.java+4860−0
@@ -0,0 +1,4860 @@
1+/*
2+ * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
3+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+ *
5+ * This code is free software; you can redistribute it and/or modify it
6+ * under the terms of the GNU General Public License version 2 only, as
7+ * published by the Free Software Foundation. Oracle designates this
8+ * particular file as subject to the "Classpath" exception as provided
9+ * by Oracle in the LICENSE file that accompanied this code.
10+ *
11+ * This code is distributed in the hope that it will be useful, but WITHOUT
12+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+ * version 2 for more details (a copy is included in the LICENSE file that
15+ * accompanied this code).
16+ *
17+ * You should have received a copy of the GNU General Public License version
18+ * 2 along with this work; if not, write to the Free Software Foundation,
19+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+ *
21+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+ * or visit www.oracle.com if you need additional information or have any
23+ * questions.
24+ */
25+
26+package com.sun.rowset.internal;
27+
28+import java.sql.*;
29+import javax.sql.*;
30+import java.util.*;
31+import java.math.BigDecimal;
32+
33+import javax.sql.rowset.*;
34+import javax.sql.rowset.spi.*;
35+
36+import com.sun.rowset.*;
37+import java.io.IOException;
38+import java.io.ObjectInputStream;
39+
40+/**
41+ * There will be two sets of data which will be maintained by the rowset at the
42+ * time of synchronization. The <code>SyncProvider</code> will utilize the
43+ * <code>SyncResolver</code> to synchronize the changes back to database.
44+ */
45+public class SyncResolverImpl extends CachedRowSetImpl implements SyncResolver {
46+ /**
47+ * This CachedRowSet object will encapsulate a rowset
48+ * which will be sync'ed with the datasource but will
49+ * contain values in rows where there is conflict.
50+ * For rows other than conflict, it will *not* contain
51+ * any data. For rows containing conflict it will
52+ * return either of the three values set by SyncResolver.*_CONFLICT
53+ * from getStatus()
54+ */
55+ private CachedRowSetImpl crsRes;
56+
57+ /**
58+ * This is the actual CachedRowSet object
59+ * which is being synchronized back to
60+ * datasource.
61+ */
62+ private CachedRowSetImpl crsSync;
63+
64+ /**
65+ * This ArrayList will contain the status of a row
66+ * from the SyncResolver.* values else it will be null.
67+ */
68+ private ArrayList stats;
69+
70+ /**
71+ * The RowSetWriter associated with the original
72+ * CachedRowSet object which is being synchronized.
73+ */
74+ private CachedRowSetWriter crw;
75+
76+ /**
77+ * Row number identifier
78+ */
79+ private int rowStatus;
80+
81+ /**
82+ * This will contain the size of the <code>CachedRowSet</code> object
83+ */
84+ private int sz;
85+
86+ /**
87+ * The <code>Connection</code> handle used to synchronize the changes
88+ * back to datasource. This is the same connection handle as was passed
89+ * to the CachedRowSet while fetching the data.
90+ */
91+ private transient Connection con;
92+
93+ /**
94+ * The <code>CachedRowSet</code> object which will encapsulate
95+ * a row at any time. This will be built from CachedRowSet and
96+ * SyncResolver values. Synchronization takes place on a row by
97+ * row basis encapsulated as a CahedRowSet.
98+ */
99+ private CachedRowSet row;
100+
101+ private JdbcRowSetResourceBundle resBundle;
102+
103+ /**
104+ * Public constructor
105+ */
106+ public SyncResolverImpl() throws SQLException {
107+ try {
108+ crsSync = new CachedRowSetImpl();
109+ crsRes = new CachedRowSetImpl();
110+ crw = new CachedRowSetWriter();
111+ row = new CachedRowSetImpl();
112+ rowStatus = 1;
113+ try {
114+ resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
115+ } catch(IOException ioe) {
116+ throw new RuntimeException(ioe);
117+ }
118+
119+ } catch(SQLException sqle) {
120+ }
121+ }
122+
123+
124+ /**
125+ * Retrieves the conflict status of the current row of this
126+ * <code>SyncResolver</code>, which indicates the operationthe <code>RowSet</code>
127+ * object was attempting when the conflict occurred.
128+ *
129+ * @return one of the following constants:
130+ * <code>SyncResolver.UPDATE_ROW_CONFLICT</code>,
131+ * <code>SyncResolver.DELETE_ROW_CONFLICT</code>, or
132+ * <code>SyncResolver.INSERT_ROW_CONFLICT</code>
133+ */
134+ public int getStatus() {
135+ return ((Integer)stats.get(rowStatus-1)).intValue();
136+ }
137+
138+ /**
139+ * Retrieves the value in the designated column in the current row of this
140+ * <code>SyncResolver</code> object, which is the value that caused a conflict.
141+ *
142+ * @param index <code>int</code> designating the column in this row of this
143+ * <code>SyncResolver</code> object from which to retrieve the value
144+ * causing a conflict
145+ */
146+ public Object getConflictValue(int index) throws SQLException {
147+ try {
148+ return crsRes.getObject(index);
149+ } catch(SQLException sqle) {
150+ throw new SQLException(sqle.getMessage());
151+ }
152+ }
153+
154+ /**
155+ * Retrieves the value in the designated column in the current row of this
156+ * <code>SyncResolver</code> object, which is the value that caused a conflict.
157+ *
158+ * @param columnName a <code>String</code> object designating the column in this row of this
159+ * <code>SyncResolver</code> object from which to retrieve the value
160+ * causing a conflict
161+ */
162+ public Object getConflictValue(String columnName) throws SQLException {
163+ try {
164+ return crsRes.getObject(columnName);
165+ } catch(SQLException sqle) {
166+ throw new SQLException(sqle.getMessage());
167+ }
168+ }
169+
170+ /**
171+ * Sets <i>obj</i> as the value in column <i>index</i> in the current row of the
172+ * <code>RowSet</code> object. This value is the resolved value that is to be
173+ * persisted in the data source.
174+ *
175+ * @param index an <code>int</code> giving the number of the column into which to
176+ * set the value to be persisted
177+ * @param obj an <code>Object</code> that is the value to be set in the data source
178+ */
179+ public void setResolvedValue(int index, Object obj) throws SQLException {
180+ // modify method to throw SQLException in spec
181+
182+ /**
183+ * When a value is resolved properly make it to null
184+ * inside crsRes for that column.
185+ *
186+ * For more than one conflicts in the row,
187+ * check for the last resolved value of the current row
188+ * (Note: it can be resolved randomly for same row)
189+ * then sync back immediately.
190+ **/
191+ try {
192+ // check whether the index is in range
193+ if(index<=0 || index > crsSync.getMetaData().getColumnCount() ) {
194+ throw new SQLException(resBundle.handleGetObject("syncrsimpl.indexval").toString()+ index);
195+ }
196+ // check whether index col is in conflict
197+ if(crsRes.getObject(index) == null) {
198+ throw new SQLException(resBundle.handleGetObject("syncrsimpl.noconflict").toString());
199+ }
200+ } catch (SQLException sqle) {
201+ // modify method to throw for SQLException
202+ throw new SQLException(sqle.getMessage());
203+ }
204+ try {
205+ boolean bool = true;
206+ /** Check resolved value to be either of conflict
207+ * or in rowset else throw sql exception.
208+ * If we allow a value other than that in CachedRowSet or
209+ * datasource we will end up in looping the loop of exceptions.
210+ **/
211+
212+ if( ((crsSync.getObject(index)).toString()).equals(obj.toString()) ||
213+ ((crsRes.getObject(index)).toString()).equals(obj.toString()) ) {
214+
215+ /**
216+ * Check whether this is the only conflict in the row.
217+ * If yes, synchronize this row back
218+ * which has been resolved, else wait
219+ * for all conflicts of current row to be resolved
220+ *
221+ * Step 1: Update crsRes and make the index col as null
222+ * i.e. resolved
223+ * crsRes.updateObject(index, obj);
224+ **/
225+ crsRes.updateNull(index);
226+ crsRes.updateRow();
227+
228+ /**
229+ * Step 2: Change the value in the CachedRowSetImpl object
230+ * crsSync.updateObject(index, obj);
231+ * crsSync.updateRow();
232+ **/
233+ if(row.size() != 1) {
234+ row = buildCachedRow();
235+ }
236+
237+ row.updateObject(index, obj);
238+ row.updateRow();
239+
240+ for(int j=1; j < crsRes.getMetaData().getColumnCount(); j++) {
241+ if(crsRes.getObject(j) != null) {
242+ bool = false;
243+ break;
244+ // break out of loop and wait for other cols
245+ // in same row to get resolved
246+ } //end if
247+
248+ } //end for
249+
250+ if(bool) {
251+ /**
252+ * sync data back using CachedRowSetWriter
253+ * construct the present row and pass it to the writer
254+ * to write back to db.
255+ **/
256+ try {
257+ /**
258+ * Note : The use of CachedRowSetWriter to get *same* Connection handle.
259+ * The CachedRowSetWriter uses the connection handle
260+ * from the reader, Hence will use the same connection handle
261+ * as of original CachedRowSetImpl
262+ **/
263+
264+ writeData(row);
265+
266+ //crw.writeData( (RowSetInternal)crsRow);
267+ //System.out.printlnt.println("12");
268+
269+ } catch(SyncProviderException spe) {
270+ /**
271+ * This will occur if db is not allowing
272+ * even after resolving the conflicts
273+ * due to some reasons.
274+ * Also will prevent from going into a loop of SPE's
275+ **/
276+ throw new SQLException(resBundle.handleGetObject("syncrsimpl.syncnotpos").toString());
277+ }
278+ } //end if(bool)
279+
280+ } else {
281+ throw new SQLException(resBundle.handleGetObject("syncrsimpl.valtores").toString());
282+ } //end if (crs.getObject ...) block
283+
284+
285+ } catch(SQLException sqle) {
286+ throw new SQLException(sqle.getMessage());
287+ }
288+ }
289+
290+ /**
291+ * This passes a CachedRowSet as a row the the CachedRowSetWriter
292+ * after the values have been resolved, back to the datasource.
293+ *
294+ * @param row a <code>CachedRowSet</code> object which will hold the
295+ * values of a particular row after they have been resolved by
296+ * the user to synchronize back to datasource.
297+ * @throws SQLException if synchronization does not happen properly
298+ * maybe beacuse <code>Connection</code> has timed out.
299+ **/
300+ private void writeData(CachedRowSet row) throws SQLException {
301+ crw.updateResolvedConflictToDB(row, crw.getReader().connect((RowSetInternal)crsSync));
302+ }
303+
304+ /**
305+ * This function builds a row as a <code>CachedRowSet</code> object
306+ * which has been resolved and is ready to be synchrinized to the datasource
307+ *
308+ * @throws SQLException if there is problem in building
309+ * the metadata of the row.
310+ **/
311+ private CachedRowSet buildCachedRow() throws SQLException {
312+ int iColCount;
313+ CachedRowSetImpl crsRow = new CachedRowSetImpl();
314+
315+ RowSetMetaDataImpl rsmd = new RowSetMetaDataImpl();
316+ RowSetMetaDataImpl rsmdWrite = (RowSetMetaDataImpl)crsSync.getMetaData();
317+ RowSetMetaDataImpl rsmdRow = new RowSetMetaDataImpl();
318+
319+ iColCount = rsmdWrite.getColumnCount();
320+ rsmdRow.setColumnCount(iColCount);
321+
322+ for(int i =1;i<=iColCount;i++) {
323+ rsmdRow.setColumnType(i,rsmdWrite.getColumnType(i));
324+ rsmdRow.setColumnName(i,rsmdWrite.getColumnName(i));
325+ rsmdRow.setNullable(i,ResultSetMetaData.columnNullableUnknown);
326+
327+ try {
328+ rsmdRow.setCatalogName(i, rsmdWrite.getCatalogName(i));
329+ rsmdRow.setSchemaName(i, rsmdWrite.getSchemaName(i));
330+ } catch(SQLException e) {
331+ e.printStackTrace();
332+ }
333+ } //end for
334+
335+ crsRow.setMetaData(rsmdRow);
336+
337+ crsRow.moveToInsertRow();
338+
339+ for(int col=1;col<=crsSync.getMetaData().getColumnCount();col++) {
340+ crsRow.updateObject(col, crsSync.getObject(col));
341+ }
342+
343+ crsRow.insertRow();
344+ crsRow.moveToCurrentRow();
345+
346+ crsRow.absolute(1);
347+ crsRow.setOriginalRow();
348+
349+ try {
350+ crsRow.setUrl(crsSync.getUrl());
351+ } catch(SQLException sqle) {
352+
353+ }
354+
355+ try {
356+ crsRow.setDataSourceName(crsSync.getCommand());
357+ } catch(SQLException sqle) {
358+
359+ }
360+
361+ try {
362+ if(crsSync.getTableName()!= null){
363+ crsRow.setTableName(crsSync.getTableName());
364+ }
365+ } catch(SQLException sqle) {
366+
367+ }
368+
369+ try {
370+ if(crsSync.getCommand() != null)
371+ crsRow.setCommand(crsSync.getCommand());
372+ } catch(SQLException sqle) {
373+
374+ }
375+
376+ try {
377+ crsRow.setKeyColumns(crsSync.getKeyColumns());
378+ } catch(SQLException sqle) {
379+
380+ }
381+ return crsRow;
382+ }
383+
384+
385+
386+ /**
387+ * Sets <i>obj</i> as the value in column <i>columnName</i> in the current row of the
388+ * <code>RowSet</code> object. This value is the resolved value that is to be
389+ * persisted in the data source.
390+ *
391+ * @param columnName a <code>String</code> object giving the name of the column
392+ * into which to set the value to be persisted
393+ * @param obj an <code>Object</code> that is the value to be set in the data source
394+ */
395+ public void setResolvedValue(String columnName, Object obj) throws SQLException {
396+ // modify method to throw SQLException in spec
397+ // %%% Missing implementation!
398+ }
399+
400+ /**
401+ * This function is package private,
402+ * i.e. cannot be accesses outside this package.
403+ * This is used to set the actual CachedRowSet
404+ * which is being synchronized to the database
405+ **/
406+ void setCachedRowSet(CachedRowSet crs) {
407+ crsSync = (CachedRowSetImpl)crs;
408+ }
409+
410+ /**
411+ * This function is package private,
412+ * i.e. cannot be accesses outside this package.
413+ * This is used to set the CachedRowSet formed
414+ * with conflict values.
415+ **/
416+ void setCachedRowSetResolver(CachedRowSet crs){
417+ try {
418+ crsRes = (CachedRowSetImpl)crs;
419+ crsRes.afterLast();
420+ sz = crsRes.size();
421+ } catch (SQLException sqle) {
422+ // do nothing
423+ }
424+ }
425+
426+ /**
427+ * This function is package private,
428+ * i.e. cannot be accesses outside this package.
429+ * This is used to set the status of each row
430+ * to either of the values SyncResolver.*_CONFLICT
431+ **/
432+ void setStatus(ArrayList status){
433+ stats = status;
434+ }
435+
436+ /**
437+ * This function is package private,
438+ * i.e. cannot be accesses outside this package.
439+ * This is used to set the handle to the writer object
440+ * which will write the resolved values back to datasource
441+ **/
442+ void setCachedRowSetWriter(CachedRowSetWriter CRWriter) {
443+ crw = CRWriter;
444+ }
445+
446+ /**
447+ * Moves the cursor down one row from its current position. A <code>SyncResolver</code>
448+ * cursor is initially positioned before the first conflict row; the first call to the
449+ * method <code>nextConflict()</code> makes the first conflict row the current row;
450+ * the second call makes the second conflict row the current row, and so on.
451+ * <p>
452+ * If an input stream is open for the current row, a call to the method next will
453+ * implicitly close it. A <code>SyncResolver</code> object's warning chain is cleared
454+ * when a new row
455+ *
456+ * @return true if the new current row is valid; false if there are no more rows
457+ * @throws SQLException if a database access occurs
458+ *
459+ */
460+ public boolean nextConflict() throws SQLException {
461+ /**
462+ * The next() method will hop from
463+ * one conflict to another
464+ *
465+ * Internally do a crs.next() until
466+ * next conflict.
467+ **/
468+ boolean bool = false;
469+
470+ crsSync.setShowDeleted(true);
471+ while(crsSync.next()) {
472+ crsRes.previous();
473+ rowStatus++; //sz--;
474+
475+ if((rowStatus-1) >= stats.size()) {
476+ bool = false;
477+ break;
478+ }
479+
480+ if(((Integer)stats.get(rowStatus-1)).intValue() == SyncResolver.NO_ROW_CONFLICT) {
481+ // do nothing
482+ // bool remains as false
483+ ;
484+ } else {
485+ bool = true;
486+ break;
487+ } //end if
488+
489+ } //end while
490+
491+ crsSync.setShowDeleted(false);
492+ return bool;
493+ } // end next() method
494+
495+
496+ /**
497+ * Moves the cursor to the previous conflict row in this <code>SyncResolver</code> object.
498+ *
499+ * @return <code>true</code> if the cursor is on a valid row; <code>false</code>
500+ * if it is off the result set
501+ * @throws SQLException if a database access error occurs or the result set type
502+ * is TYPE_FORWARD_ONLY
503+ */
504+ public boolean previousConflict() throws SQLException {
505+ throw new UnsupportedOperationException();
506+ }
507+
508+ //-----------------------------------------------------------------------
509+ // Properties
510+ //-----------------------------------------------------------------------
511+
512+ /**
513+ * Sets this <code>CachedRowSetImpl</code> object's command property
514+ * to the given <code>String</code> object and clears the parameters,
515+ * if any, that were set for the previous command.
516+ * <P>
517+ * The command property may not be needed
518+ * if the rowset is produced by a data source, such as a spreadsheet,
519+ * that does not support commands. Thus, this property is optional
520+ * and may be <code>null</code>.
521+ *
522+ * @param cmd a <code>String</code> object containing an SQL query
523+ * that will be set as the command; may be <code>null</code>
524+ * @throws SQLException if an error occurs
525+ */
526+ public void setCommand(String cmd) throws SQLException {
527+ throw new UnsupportedOperationException();
528+ }
529+
530+
531+ //---------------------------------------------------------------------
532+ // Reading and writing data
533+ //---------------------------------------------------------------------
534+
535+ /**
536+ * Populates this <code>CachedRowSetImpl</code> object with data from
537+ * the given <code>ResultSet</code> object. This
538+ * method is an alternative to the method <code>execute</code>
539+ * for filling the rowset with data. The method <code>populate</code>
540+ * does not require that the properties needed by the method
541+ * <code>execute</code>, such as the <code>command</code> property,
542+ * be set. This is true because the method <code>populate</code>
543+ * is given the <code>ResultSet</code> object from
544+ * which to get data and thus does not need to use the properties
545+ * required for setting up a connection and executing this
546+ * <code>CachedRowSetImpl</code> object's command.
547+ * <P>
548+ * After populating this rowset with data, the method
549+ * <code>populate</code> sets the rowset's metadata and
550+ * then sends a <code>RowSetChangedEvent</code> object
551+ * to all registered listeners prior to returning.
552+ *
553+ * @param data the <code>ResultSet</code> object containing the data
554+ * to be read into this <code>CachedRowSetImpl</code> object
555+ * @throws SQLException if an error occurs; or the max row setting is
556+ * violated while populating the RowSet
557+ * @see #execute
558+ */
559+ public void populate(ResultSet data) throws SQLException {
560+ throw new UnsupportedOperationException();
561+ }
562+
563+ /**
564+ * Populates this <code>CachedRowSetImpl</code> object with data,
565+ * using the given connection to produce the result set from
566+ * which data will be read. A second form of this method,
567+ * which takes no arguments, uses the values from this rowset's
568+ * user, password, and either url or data source properties to
569+ * create a new database connection. The form of <code>execute</code>
570+ * that is given a connection ignores these properties.
571+ *
572+ * @param conn A standard JDBC <code>Connection</code> object that this
573+ * <code>CachedRowSet</code> object can pass to a synchronization provider
574+ * to establish a connection to the data source
575+ * @throws SQLException if an invalid <code>Connection</code> is supplied
576+ * or an error occurs in establishing the connection to the
577+ * data source
578+ * @see #populate
579+ * @see java.sql.Connection
580+ */
581+ public void execute(Connection conn) throws SQLException {
582+ throw new UnsupportedOperationException();
583+ }
584+
585+ /**
586+ * Propagates all row update, insert, and delete changes to the
587+ * underlying data source backing this <code>CachedRowSetImpl</code>
588+ * object.
589+ * <P>
590+ * <b>Note</b>In the reference implementation an optimistic concurrency implementation
591+ * is provided as a sample implementation of a the <code>SyncProvider</code>
592+ * abstract class.
593+ * <P>
594+ * This method fails if any of the updates cannot be propagated back
595+ * to the data source. When it fails, the caller can assume that
596+ * none of the updates are reflected in the data source.
597+ * When an exception is thrown, the current row
598+ * is set to the first "updated" row that resulted in an exception
599+ * unless the row that caused the exception is a "deleted" row.
600+ * In that case, when deleted rows are not shown, which is usually true,
601+ * the current row is not affected.
602+ * <P>
603+ * If no <code>SyncProvider</code> is configured, the reference implementation
604+ * leverages the <code>RIOptimisticProvider</code> available which provides the
605+ * default and reference synchronization capabilities for disconnected
606+ * <code>RowSets</code>.
607+ *
608+ * @throws SQLException if the cursor is on the insert row or the underlying
609+ * reference synchronization provider fails to commit the updates
610+ * to the datasource
611+ * @throws SyncProviderException if an internal error occurs within the
612+ * <code>SyncProvider</code> instance during either during the
613+ * process or at any time when the <code>SyncProvider</code>
614+ * instance touches the data source.
615+ * @see #acceptChanges(java.sql.Connection)
616+ * @see javax.sql.RowSetWriter
617+ * @see javax.sql.rowset.spi.SyncProvider
618+ */
619+ public void acceptChanges() throws SyncProviderException {
620+ throw new UnsupportedOperationException();
621+ }
622+
623+ /**
624+ * Propagates all row update, insert, and delete changes to the
625+ * data source backing this <code>CachedRowSetImpl</code> object
626+ * using the given <code>Connection</code> object.
627+ * <P>
628+ * The reference implementation <code>RIOptimisticProvider</code>
629+ * modifies its synchronization to a write back function given
630+ * the updated connection
631+ * The reference implementation modifies its synchronization behaviour
632+ * via the <code>SyncProvider</code> to ensure the synchronization
633+ * occurs according to the updated JDBC <code>Connection</code>
634+ * properties.
635+ *
636+ * @param con a standard JDBC <code>Connection</code> object
637+ * @throws SQLException if the cursor is on the insert row or the underlying
638+ * synchronization provider fails to commit the updates
639+ * back to the data source
640+ * @see #acceptChanges
641+ * @see javax.sql.RowSetWriter
642+ * @see javax.sql.rowset.spi.SyncFactory
643+ * @see javax.sql.rowset.spi.SyncProvider
644+ */
645+ public void acceptChanges(Connection con) throws SyncProviderException{
646+ throw new UnsupportedOperationException();
647+ }
648+
649+ /**
650+ * Restores this <code>CachedRowSetImpl</code> object to its original state,
651+ * that is, its state before the last set of changes.
652+ * <P>
653+ * Before returning, this method moves the cursor before the first row
654+ * and sends a <code>rowSetChanged</code> event to all registered
655+ * listeners.
656+ * @throws SQLException if an error is occurs rolling back the RowSet
657+ * state to the definied original value.
658+ * @see javax.sql.RowSetListener#rowSetChanged
659+ */
660+ public void restoreOriginal() throws SQLException {
661+ throw new UnsupportedOperationException();
662+ }
663+
664+ /**
665+ * Releases the current contents of this <code>CachedRowSetImpl</code>
666+ * object and sends a <code>rowSetChanged</code> event object to all
667+ * registered listeners.
668+ *
669+ * @throws SQLException if an error occurs flushing the contents of
670+ * RowSet.
671+ * @see javax.sql.RowSetListener#rowSetChanged
672+ */
673+ public void release() throws SQLException {
674+ throw new UnsupportedOperationException();
675+ }
676+
677+ /**
678+ * Cancels deletion of the current row and notifies listeners that
679+ * a row has changed.
680+ * <P>
681+ * Note: This method can be ignored if deleted rows are not being shown,
682+ * which is the normal case.
683+ *
684+ * @throws SQLException if the cursor is not on a valid row
685+ */
686+ public void undoDelete() throws SQLException {
687+ throw new UnsupportedOperationException();
688+ }
689+
690+ /**
691+ * Immediately removes the current row from this
692+ * <code>CachedRowSetImpl</code> object if the row has been inserted, and
693+ * also notifies listeners the a row has changed. An exception is thrown
694+ * if the row is not a row that has been inserted or the cursor is before
695+ * the first row, after the last row, or on the insert row.
696+ * <P>
697+ * This operation cannot be undone.
698+ *
699+ * @throws SQLException if an error occurs,
700+ * the cursor is not on a valid row,
701+ * or the row has not been inserted
702+ */
703+ public void undoInsert() throws SQLException {
704+ throw new UnsupportedOperationException();
705+ }
706+
707+ /**
708+ * Immediately reverses the last update operation if the
709+ * row has been modified. This method can be
710+ * called to reverse updates on a all columns until all updates in a row have
711+ * been rolled back to their originating state since the last synchronization
712+ * (<code>acceptChanges</code>) or population. This method may also be called
713+ * while performing updates to the insert row.
714+ * <P>
715+ * <code>undoUpdate</code may be called at any time during the life-time of a
716+ * rowset, however after a synchronization has occurs this method has no
717+ * affect until further modification to the RowSet data occurs.
718+ *
719+ * @throws SQLException if cursor is before the first row, after the last
720+ * row in rowset.
721+ * @see #undoDelete
722+ * @see #undoInsert
723+ * @see java.sql.ResultSet#cancelRowUpdates
724+ */
725+ public void undoUpdate() throws SQLException {
726+ throw new UnsupportedOperationException();
727+
728+ }
729+
730+ //--------------------------------------------------------------------
731+ // Views
732+ //--------------------------------------------------------------------
733+
734+ /**
735+ * Returns a new <code>RowSet</code> object backed by the same data as
736+ * that of this <code>CachedRowSetImpl</code> object and sharing a set of cursors
737+ * with it. This allows cursors to interate over a shared set of rows, providing
738+ * multiple views of the underlying data.
739+ *
740+ * @return a <code>RowSet</code> object that is a copy of this <code>CachedRowSetImpl</code>
741+ * object and shares a set of cursors with it
742+ * @throws SQLException if an error occurs or cloning is
743+ * not supported
744+ * @see javax.sql.RowSetEvent
745+ * @see javax.sql.RowSetListener
746+ */
747+ public RowSet createShared() throws SQLException {
748+ throw new UnsupportedOperationException();
749+ }
750+
751+ /**
752+ * Returns a new <code>RowSet</code> object containing by the same data
753+ * as this <code>CachedRowSetImpl</code> object. This method
754+ * differs from the method <code>createCopy</code> in that it throws a
755+ * <code>CloneNotSupportedException</code> object instead of an
756+ * <code>SQLException</code> object, as the method <code>createShared</code>
757+ * does. This <code>clone</code>
758+ * method is called internally by the method <code>createShared</code>,
759+ * which catches the <code>CloneNotSupportedException</code> object
760+ * and in turn throws a new <code>SQLException</code> object.
761+ *
762+ * @return a copy of this <code>CachedRowSetImpl</code> object
763+ * @throws CloneNotSupportedException if an error occurs when
764+ * attempting to clone this <code>CachedRowSetImpl</code> object
765+ * @see #createShared
766+ */
767+ protected Object clone() throws CloneNotSupportedException {
768+ throw new UnsupportedOperationException();
769+ }
770+
771+ /**
772+ * Creates a <code>RowSet</code> object that is a deep copy of
773+ * this <code>CachedRowSetImpl</code> object's data, including
774+ * constraints. Updates made
775+ * on a copy are not visible to the original rowset;
776+ * a copy of a rowset is completely independent from the original.
777+ * <P>
778+ * Making a copy saves the cost of creating an identical rowset
779+ * from first principles, which can be quite expensive.
780+ * For example, it can eliminate the need to query a
781+ * remote database server.
782+ * @return a new <code>CachedRowSet</code> object that is a deep copy
783+ * of this <code>CachedRowSet</code> object and is
784+ * completely independent from this <code>CachedRowSetImpl</code>
785+ * object.
786+ * @throws SQLException if an error occurs in generating the copy of this
787+ * of the <code>CachedRowSetImpl</code>
788+ * @see #createShared
789+ * @see javax.sql.RowSetEvent
790+ * @see javax.sql.RowSetListener
791+ */
792+ public CachedRowSet createCopy() throws SQLException {
793+ throw new UnsupportedOperationException();
794+ }
795+
796+ /**
797+ * Creates a <code>RowSet</code> object that is a copy of
798+ * this <code>CachedRowSetImpl</code> object's table structure
799+ * and the constraints only.
800+ * There will be no data in the object being returned.
801+ * Updates made on a copy are not visible to the original rowset.
802+ * <P>
803+ * This helps in getting the underlying XML schema which can
804+ * be used as the basis for populating a <code>WebRowSet</code>.
805+ *
806+ * @return a new <code>CachedRowSet</code> object that is a copy
807+ * of this <code>CachedRowSetImpl</code> object's schema and
808+ * retains all the constraints on the original rowset but contains
809+ * no data
810+ * @throws SQLException if an error occurs in generating the copy
811+ * of the <code>CachedRowSet</code> object
812+ * @see #createShared
813+ * @see #createCopy
814+ * @see #createCopyNoConstraints
815+ * @see javax.sql.RowSetEvent
816+ * @see javax.sql.RowSetListener
817+ */
818+ public CachedRowSet createCopySchema() throws SQLException {
819+ throw new UnsupportedOperationException();
820+ }
821+
822+ /**
823+ * Creates a <code>CachedRowSet</code> object that is a copy of
824+ * this <code>CachedRowSetImpl</code> object's data only.
825+ * All constraints set in this object will not be there
826+ * in the returning object. Updates made
827+ * on a copy are not visible to the original rowset.
828+ *
829+ * @return a new <code>CachedRowSet</code> object that is a deep copy
830+ * of this <code>CachedRowSetImpl</code> object and is
831+ * completely independent from this <code>CachedRowSetImpl</code> object
832+ * @throws SQLException if an error occurs in generating the copy of the
833+ * of the <code>CachedRowSet</code>
834+ * @see #createShared
835+ * @see #createCopy
836+ * @see #createCopySchema
837+ * @see javax.sql.RowSetEvent
838+ * @see javax.sql.RowSetListener
839+ */
840+ public CachedRowSet createCopyNoConstraints() throws SQLException {
841+ throw new UnsupportedOperationException();
842+ }
843+
844+ /**
845+ * Converts this <code>CachedRowSetImpl</code> object to a collection
846+ * of tables. The sample implementation utilitizes the <code>TreeMap</code>
847+ * collection type.
848+ * This class guarantees that the map will be in ascending key order,
849+ * sorted according to the natural order for the key's class.
850+ *
851+ * @return a <code>Collection</code> object consisting of tables,
852+ * each of which is a copy of a row in this
853+ * <code>CachedRowSetImpl</code> object
854+ * @throws SQLException if an error occurs in generating the collection
855+ * @see #toCollection(int)
856+ * @see #toCollection(String)
857+ * @see java.util.TreeMap
858+ */
859+ public Collection toCollection() throws SQLException {
860+ throw new UnsupportedOperationException();
861+ }
862+
863+ /**
864+ * Returns the specified column of this <code>CachedRowSetImpl</code> object
865+ * as a <code>Collection</code> object. This method makes a copy of the
866+ * column's data and utilitizes the <code>Vector</code> to establish the
867+ * collection. The <code>Vector</code> class implements a growable array
868+ * objects allowing the individual components to be accessed using an
869+ * an integer index similar to that of an array.
870+ *
871+ * @return a <code>Collection</code> object that contains the value(s)
872+ * stored in the specified column of this
873+ * <code>CachedRowSetImpl</code>
874+ * object
875+ * @throws SQLException if an error occurs generated the collection; or
876+ * an invalid column is provided.
877+ * @see #toCollection()
878+ * @see #toCollection(String)
879+ * @see java.util.Vector
880+ */
881+ public Collection toCollection(int column) throws SQLException {
882+ throw new UnsupportedOperationException();
883+ }
884+
885+ /**
886+ * Returns the specified column of this <code>CachedRowSetImpl</code> object
887+ * as a <code>Collection</code> object. This method makes a copy of the
888+ * column's data and utilitizes the <code>Vector</code> to establish the
889+ * collection. The <code>Vector</code> class implements a growable array
890+ * objects allowing the individual components to be accessed using an
891+ * an integer index similar to that of an array.
892+ *
893+ * @return a <code>Collection</code> object that contains the value(s)
894+ * stored in the specified column of this
895+ * <code>CachedRowSetImpl</code>
896+ * object
897+ * @throws SQLException if an error occurs generated the collection; or
898+ * an invalid column is provided.
899+ * @see #toCollection()
900+ * @see #toCollection(int)
901+ * @see java.util.Vector
902+ */
903+ public Collection toCollection(String column) throws SQLException {
904+ throw new UnsupportedOperationException();
905+ }
906+
907+ //--------------------------------------------------------------------
908+ // Advanced features
909+ //--------------------------------------------------------------------
910+
911+
912+ /**
913+ * Returns the <code>SyncProvider</code> implementation being used
914+ * with this <code>CachedRowSetImpl</code> implementation rowset.
915+ *
916+ * @return the SyncProvider used by the rowset. If not provider was
917+ * set when the rowset was instantiated, the reference
918+ * implementation (default) provider is returned.
919+ * @throws SQLException if error occurs while return the
920+ * <code>SyncProvider</code> instance.
921+ */
922+ public SyncProvider getSyncProvider() throws SQLException {
923+ throw new UnsupportedOperationException();
924+ }
925+
926+ /**
927+ * Sets the active <code>SyncProvider</code> and attempts to load
928+ * load the new provider using the <code>SyncFactory</code> SPI.
929+ *
930+ * @throws SQLException if an error occurs while resetting the
931+ * <code>SyncProvider</code>.
932+ */
933+ public void setSyncProvider(String providerStr) throws SQLException {
934+ throw new UnsupportedOperationException();
935+ }
936+
937+
938+ //-----------------
939+ // methods inherited from RowSet
940+ //-----------------
941+
942+
943+
944+
945+
946+
947+ //---------------------------------------------------------------------
948+ // Reading and writing data
949+ //---------------------------------------------------------------------
950+
951+ /**
952+ * Populates this <code>CachedRowSetImpl</code> object with data.
953+ * This form of the method uses the rowset's user, password, and url or
954+ * data source name properties to create a database
955+ * connection. If properties that are needed
956+ * have not been set, this method will throw an exception.
957+ * <P>
958+ * Another form of this method uses an existing JDBC <code>Connection</code>
959+ * object instead of creating a new one; therefore, it ignores the
960+ * properties used for establishing a new connection.
961+ * <P>
962+ * The query specified by the command property is executed to create a
963+ * <code>ResultSet</code> object from which to retrieve data.
964+ * The current contents of the rowset are discarded, and the
965+ * rowset's metadata is also (re)set. If there are outstanding updates,
966+ * they are also ignored.
967+ * <P>
968+ * The method <code>execute</code> closes any database connections that it
969+ * creates.
970+ *
971+ * @throws SQLException if an error occurs or the
972+ * necessary properties have not been set
973+ */
974+ public void execute() throws SQLException {
975+ throw new UnsupportedOperationException();
976+ }
977+
978+
979+
980+ //-----------------------------------
981+ // Methods inherited from ResultSet
982+ //-----------------------------------
983+
984+ /**
985+ * Moves the cursor down one row from its current position and
986+ * returns <code>true</code> if the new cursor position is a
987+ * valid row.
988+ * The cursor for a new <code>ResultSet</code> object is initially
989+ * positioned before the first row. The first call to the method
990+ * <code>next</code> moves the cursor to the first row, making it
991+ * the current row; the second call makes the second row the
992+ * current row, and so on.
993+ *
994+ * <P>If an input stream from the previous row is open, it is
995+ * implicitly closed. The <code>ResultSet</code> object's warning
996+ * chain is cleared when a new row is read.
997+ *
998+ * @return <code>true</code> if the new current row is valid;
999+ * <code>false</code> if there are no more rows
1000+ * @throws SQLException if an error occurs or
1001+ * the cursor is not positioned in the rowset, before
1002+ * the first row, or after the last row
1003+ */
1004+ public boolean next() throws SQLException {
1005+ throw new UnsupportedOperationException();
1006+ }
1007+
1008+ /**
1009+ * Moves this <code>CachedRowSetImpl</code> object's cursor to the next
1010+ * row and returns <code>true</code> if the cursor is still in the rowset;
1011+ * returns <code>false</code> if the cursor has moved to the position after
1012+ * the last row.
1013+ * <P>
1014+ * This method handles the cases where the cursor moves to a row that
1015+ * has been deleted.
1016+ * If this rowset shows deleted rows and the cursor moves to a row
1017+ * that has been deleted, this method moves the cursor to the next
1018+ * row until the cursor is on a row that has not been deleted.
1019+ * <P>
1020+ * The method <code>internalNext</code> is called by methods such as
1021+ * <code>next</code>, <code>absolute</code>, and <code>relative</code>,
1022+ * and, as its name implies, is only called internally.
1023+ * <p>
1024+ * This is a implementation only method and is not required as a standard
1025+ * implementation of the <code>CachedRowSet</code> interface.
1026+ *
1027+ * @return <code>true</code> if the cursor is on a valid row in this
1028+ * rowset; <code>false</code> if it is after the last row
1029+ * @throws SQLException if an error occurs
1030+ */
1031+ protected boolean internalNext() throws SQLException {
1032+ throw new UnsupportedOperationException();
1033+ }
1034+
1035+ /**
1036+ * Closes this <code>CachedRowSetImpl</code> objecy and releases any resources
1037+ * it was using.
1038+ *
1039+ * @throws SQLException if an error occurs when releasing any resources in use
1040+ * by this <code>CachedRowSetImpl</code> object
1041+ */
1042+ public void close() throws SQLException {
1043+ throw new UnsupportedOperationException();
1044+ }
1045+
1046+ /**
1047+ * Reports whether the last column read was SQL <code>NULL</code>.
1048+ * Note that you must first call the method <code>getXXX</code>
1049+ * on a column to try to read its value and then call the method
1050+ * <code>wasNull</code> to determine whether the value was
1051+ * SQL <code>NULL</code>.
1052+ *
1053+ * @return <code>true</code> if the value in the last column read
1054+ * was SQL <code>NULL</code>; <code>false</code> otherwise
1055+ * @throws SQLException if an error occurs
1056+ */
1057+ public boolean wasNull() throws SQLException {
1058+ throw new UnsupportedOperationException();
1059+ }
1060+
1061+ /**
1062+ * Returns the insert row or the current row of this
1063+ * <code>CachedRowSetImpl</code>object.
1064+ *
1065+ * @return the <code>Row</code> object on which this <code>CachedRowSetImpl</code>
1066+ * objects's cursor is positioned
1067+ */
1068+ protected BaseRow getCurrentRow() {
1069+ throw new UnsupportedOperationException();
1070+ }
1071+
1072+ /**
1073+ * Removes the row on which the cursor is positioned.
1074+ * <p>
1075+ * This is a implementation only method and is not required as a standard
1076+ * implementation of the <code>CachedRowSet</code> interface.
1077+ *
1078+ * @throws SQLException if the cursor is positioned on the insert
1079+ * row
1080+ */
1081+ protected void removeCurrentRow() {
1082+ throw new UnsupportedOperationException();
1083+ }
1084+
1085+
1086+ /**
1087+ * Retrieves the value of the designated column in the current row
1088+ * of this <code>CachedRowSetImpl</code> object as a
1089+ * <code>String</code> object.
1090+ *
1091+ * @param columnIndex the first column is <code>1</code>, the second
1092+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1093+ * and equal to or less than the number of columns in the rowset
1094+ * @return the column value; if the value is SQL <code>NULL</code>, the
1095+ * result is <code>null</code>
1096+ * @throws SQLException if (1) the given column index is out of bounds,
1097+ * (2) the cursor is not on one of this rowset's rows or its
1098+ * insert row, or (3) the designated column does not store an
1099+ * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, REAL,
1100+ * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, <b>CHAR</b>, <b>VARCHAR</b></code>
1101+ * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1102+ * recommended return type.
1103+ */
1104+ public String getString(int columnIndex) throws SQLException {
1105+ throw new UnsupportedOperationException();
1106+ }
1107+
1108+ /**
1109+ * Retrieves the value of the designated column in the current row
1110+ * of this <code>CachedRowSetImpl</code> object as a
1111+ * <code>boolean</code> value.
1112+ *
1113+ * @param columnIndex the first column is <code>1</code>, the second
1114+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1115+ * and equal to or less than the number of columns in the rowset
1116+ * @return the column value as a <code>boolean</code> in the Java progamming language;
1117+ * if the value is SQL <code>NULL</code>, the result is <code>false</code>
1118+ * @throws SQLException if (1) the given column index is out of bounds,
1119+ * (2) the cursor is not on one of this rowset's rows or its
1120+ * insert row, or (3) the designated column does not store an
1121+ * SQL <code>BOOLEAN</code> value
1122+ * @see #getBoolean(String)
1123+ */
1124+ public boolean getBoolean(int columnIndex) throws SQLException {
1125+ throw new UnsupportedOperationException();
1126+ }
1127+
1128+ /**
1129+ * Retrieves the value of the designated column in the current row
1130+ * of this <code>CachedRowSetImpl</code> object as a
1131+ * <code>byte</code> value.
1132+ *
1133+ * @param columnIndex the first column is <code>1</code>, the second
1134+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1135+ * and equal to or less than the number of columns in the rowset
1136+ * @return the column value as a <code>byte</code> in the Java programming
1137+ * language; if the value is SQL <code>NULL</code>, the result is <code>0</code>
1138+ * @throws SQLException if (1) the given column index is out of bounds,
1139+ * (2) the cursor is not on one of this rowset's rows or its
1140+ * insert row, or (3) the designated column does not store an
1141+ * SQL <code><b>TINYINT</b>, SMALLINT, INTEGER, BIGINT, REAL,
1142+ * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1143+ * or <code>LONGVARCHAR</code> value. The bold SQL type
1144+ * designates the recommended return type.
1145+ * @see #getByte(String)
1146+ */
1147+ public byte getByte(int columnIndex) throws SQLException {
1148+ throw new UnsupportedOperationException();
1149+ }
1150+
1151+ /**
1152+ * Retrieves the value of the designated column in the current row
1153+ * of this <code>CachedRowSetImpl</code> object as a
1154+ * <code>short</code> value.
1155+ *
1156+ * @param columnIndex the first column is <code>1</code>, the second
1157+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1158+ * and equal to or less than the number of columns in the rowset
1159+ * @return the column value; if the value is SQL <code>NULL</code>, the
1160+ * result is <code>0</code>
1161+ * @throws SQLException if (1) the given column index is out of bounds,
1162+ * (2) the cursor is not on one of this rowset's rows or its
1163+ * insert row, or (3) the designated column does not store an
1164+ * SQL <code>TINYINT, <b>SMALLINT</b>, INTEGER, BIGINT, REAL
1165+ * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1166+ * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1167+ * recommended return type.
1168+ * @see #getShort(String)
1169+ */
1170+ public short getShort(int columnIndex) throws SQLException {
1171+ throw new UnsupportedOperationException();
1172+ }
1173+
1174+ /**
1175+ * Retrieves the value of the designated column in the current row
1176+ * of this <code>CachedRowSetImpl</code> object as an
1177+ * <code>int</code> value.
1178+ *
1179+ * @param columnIndex the first column is <code>1</code>, the second
1180+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1181+ * and equal to or less than the number of columns in the rowset
1182+ * @return the column value; if the value is SQL <code>NULL</code>, the
1183+ * result is <code>0</code>
1184+ * @throws SQLException if (1) the given column index is out of bounds,
1185+ * (2) the cursor is not on one of this rowset's rows or its
1186+ * insert row, or (3) the designated column does not store an
1187+ * SQL <code>TINYINT, SMALLINT, <b>INTEGER</b>, BIGINT, REAL
1188+ * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1189+ * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1190+ * recommended return type.
1191+ */
1192+ public int getInt(int columnIndex) throws SQLException {
1193+ throw new UnsupportedOperationException();
1194+ }
1195+
1196+ /**
1197+ * Retrieves the value of the designated column in the current row
1198+ * of this <code>CachedRowSetImpl</code> object as a
1199+ * <code>long</code> value.
1200+ *
1201+ * @param columnIndex the first column is <code>1</code>, the second
1202+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1203+ * and equal to or less than the number of columns in the rowset
1204+ * @return the column value; if the value is SQL <code>NULL</code>, the
1205+ * result is <code>0</code>
1206+ * @throws SQLException if (1) the given column index is out of bounds,
1207+ * (2) the cursor is not on one of this rowset's rows or its
1208+ * insert row, or (3) the designated column does not store an
1209+ * SQL <code>TINYINT, SMALLINT, INTEGER, <b>BIGINT</b>, REAL
1210+ * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1211+ * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1212+ * recommended return type.
1213+ * @see #getLong(String)
1214+ */
1215+ public long getLong(int columnIndex) throws SQLException {
1216+ throw new UnsupportedOperationException();
1217+ }
1218+
1219+ /**
1220+ * Retrieves the value of the designated column in the current row
1221+ * of this <code>CachedRowSetImpl</code> object as a
1222+ * <code>float</code> value.
1223+ *
1224+ * @param columnIndex the first column is <code>1</code>, the second
1225+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1226+ * and equal to or less than the number of columns in the rowset
1227+ * @return the column value; if the value is SQL <code>NULL</code>, the
1228+ * result is <code>0</code>
1229+ * @throws SQLException if (1) the given column index is out of bounds,
1230+ * (2) the cursor is not on one of this rowset's rows or its
1231+ * insert row, or (3) the designated column does not store an
1232+ * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, <b>REAL</b>,
1233+ * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1234+ * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1235+ * recommended return type.
1236+ * @see #getFloat(String)
1237+ */
1238+ public float getFloat(int columnIndex) throws SQLException {
1239+ throw new UnsupportedOperationException();
1240+ }
1241+
1242+ /**
1243+ * Retrieves the value of the designated column in the current row
1244+ * of this <code>CachedRowSetImpl</code> object as a
1245+ * <code>double</code> value.
1246+ *
1247+ * @param columnIndex the first column is <code>1</code>, the second
1248+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1249+ * and equal to or less than the number of columns in the rowset
1250+ * @return the column value; if the value is SQL <code>NULL</code>, the
1251+ * result is <code>0</code>
1252+ * @throws SQLException if (1) the given column index is out of bounds,
1253+ * (2) the cursor is not on one of this rowset's rows or its
1254+ * insert row, or (3) the designated column does not store an
1255+ * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, REAL,
1256+ * <b>FLOAT</b>, <b>DOUBLE</b>, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1257+ * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1258+ * recommended return type.
1259+ * @see #getDouble(String)
1260+ *
1261+ */
1262+ public double getDouble(int columnIndex) throws SQLException {
1263+ throw new UnsupportedOperationException();
1264+ }
1265+
1266+ /**
1267+ * Retrieves the value of the designated column in the current row
1268+ * of this <code>CachedRowSetImpl</code> object as a
1269+ * <code>java.math.BigDecimal</code> object.
1270+ * <P>
1271+ * This method is deprecated; use the version of <code>getBigDecimal</code>
1272+ * that does not take a scale parameter and returns a value with full
1273+ * precision.
1274+ *
1275+ * @param columnIndex the first column is <code>1</code>, the second
1276+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1277+ * and equal to or less than the number of columns in the rowset
1278+ * @param scale the number of digits to the right of the decimal point in the
1279+ * value returned
1280+ * @return the column value with the specified number of digits to the right
1281+ * of the decimal point; if the value is SQL <code>NULL</code>, the
1282+ * result is <code>null</code>
1283+ * @throws SQLException if the given column index is out of bounds,
1284+ * the cursor is not on a valid row, or this method fails
1285+ * @deprecated
1286+ */
1287+ public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
1288+ throw new UnsupportedOperationException();
1289+ }
1290+
1291+ /**
1292+ * Retrieves the value of the designated column in the current row
1293+ * of this <code>CachedRowSetImpl</code> object as a
1294+ * <code>byte</code> array value.
1295+ *
1296+ * @param columnIndex the first column is <code>1</code>, the second
1297+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1298+ * and equal to or less than the number of columns in the rowset
1299+ * @return the column value as a <code>byte</code> array in the Java programming
1300+ * language; if the value is SQL <code>NULL</code>, the
1301+ * result is <code>null</code>
1302+ *
1303+ * @throws SQLException if (1) the given column index is out of bounds,
1304+ * (2) the cursor is not on one of this rowset's rows or its
1305+ * insert row, or (3) the designated column does not store an
1306+ * SQL <code><b>BINARY</b>, <b>VARBINARY</b> or
1307+ * LONGVARBINARY</code> value.
1308+ * The bold SQL type designates the recommended return type.
1309+ * @see #getBytes(String)
1310+ */
1311+ public byte[] getBytes(int columnIndex) throws SQLException {
1312+ throw new UnsupportedOperationException();
1313+ }
1314+
1315+ /**
1316+ * Retrieves the value of the designated column in the current row
1317+ * of this <code>CachedRowSetImpl</code> object as a
1318+ * <code>java.sql.Date</code> object.
1319+ *
1320+ * @param columnIndex the first column is <code>1</code>, the second
1321+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1322+ * and equal to or less than the number of columns in the rowset
1323+ * @return the column value as a <code>java.sql.Data</code> object; if
1324+ * the value is SQL <code>NULL</code>, the
1325+ * result is <code>null</code>
1326+ * @throws SQLException if the given column index is out of bounds,
1327+ * the cursor is not on a valid row, or this method fails
1328+ */
1329+ public java.sql.Date getDate(int columnIndex) throws SQLException {
1330+ throw new UnsupportedOperationException();
1331+ }
1332+
1333+ /**
1334+ * Retrieves the value of the designated column in the current row
1335+ * of this <code>CachedRowSetImpl</code> object as a
1336+ * <code>java.sql.Time</code> object.
1337+ *
1338+ * @param columnIndex the first column is <code>1</code>, the second
1339+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1340+ * and equal to or less than the number of columns in the rowset
1341+ * @return the column value; if the value is SQL <code>NULL</code>, the
1342+ * result is <code>null</code>
1343+ * @throws SQLException if the given column index is out of bounds,
1344+ * the cursor is not on a valid row, or this method fails
1345+ */
1346+ public java.sql.Time getTime(int columnIndex) throws SQLException {
1347+ throw new UnsupportedOperationException();
1348+ }
1349+
1350+ /**
1351+ * Retrieves the value of the designated column in the current row
1352+ * of this <code>CachedRowSetImpl</code> object as a
1353+ * <code>java.sql.Timestamp</code> object.
1354+ *
1355+ * @param columnIndex the first column is <code>1</code>, the second
1356+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1357+ * and equal to or less than the number of columns in the rowset
1358+ * @return the column value; if the value is SQL <code>NULL</code>, the
1359+ * result is <code>null</code>
1360+ * @throws SQLException if the given column index is out of bounds,
1361+ * the cursor is not on a valid row, or this method fails
1362+ */
1363+ public java.sql.Timestamp getTimestamp(int columnIndex) throws SQLException {
1364+ throw new UnsupportedOperationException();
1365+ }
1366+
1367+ /**
1368+ * Retrieves the value of the designated column in the current row of this
1369+ * <code>CachedRowSetImpl</code> object as a <code>java.io.InputStream</code>
1370+ * object.
1371+ *
1372+ * A column value can be retrieved as a stream of ASCII characters
1373+ * and then read in chunks from the stream. This method is particularly
1374+ * suitable for retrieving large <code>LONGVARCHAR</code> values. The JDBC
1375+ * driver will do any necessary conversion from the database format into ASCII.
1376+ *
1377+ * <P><B>Note:</B> All the data in the returned stream must be
1378+ * read prior to getting the value of any other column. The next
1379+ * call to a get method implicitly closes the stream. . Also, a
1380+ * stream may return <code>0</code> for <code>CachedRowSetImpl.available()</code>
1381+ * whether there is data available or not.
1382+ *
1383+ * @param columnIndex the first column is <code>1</code>, the second
1384+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1385+ * and equal to or less than the number of columns in this rowset
1386+ * @return a Java input stream that delivers the database column value
1387+ * as a stream of one-byte ASCII characters. If the value is SQL
1388+ * <code>NULL</code>, the result is <code>null</code>.
1389+ * @throws SQLException if (1) the given column index is out of bounds,
1390+ * (2) the cursor is not on one of this rowset's rows or its
1391+ * insert row, or (3) the designated column does not store an
1392+ * SQL <code>CHAR, VARCHAR</code>, <code><b>LONGVARCHAR</b></code>
1393+ * <code>BINARY, VARBINARY</code> or <code>LONGVARBINARY</code> value. The
1394+ * bold SQL type designates the recommended return types that this method is
1395+ * used to retrieve.
1396+ * @see #getAsciiStream(String)
1397+ */
1398+ public java.io.InputStream getAsciiStream(int columnIndex) throws SQLException {
1399+ throw new UnsupportedOperationException();
1400+ }
1401+
1402+ /**
1403+ * A column value can be retrieved as a stream of Unicode characters
1404+ * and then read in chunks from the stream. This method is particularly
1405+ * suitable for retrieving large LONGVARCHAR values. The JDBC driver will
1406+ * do any necessary conversion from the database format into Unicode.
1407+ *
1408+ * <P><B>Note:</B> All the data in the returned stream must be
1409+ * read prior to getting the value of any other column. The next
1410+ * call to a get method implicitly closes the stream. . Also, a
1411+ * stream may return 0 for available() whether there is data
1412+ * available or not.
1413+ *
1414+ * @param columnIndex the first column is <code>1</code>, the second
1415+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1416+ * and equal to or less than the number of columns in this rowset
1417+ * @return a Java input stream that delivers the database column value
1418+ * as a stream of two byte Unicode characters. If the value is SQL NULL
1419+ * then the result is null.
1420+ * @throws SQLException if an error occurs
1421+ * @deprecated
1422+ */
1423+ public java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException {
1424+ throw new UnsupportedOperationException();
1425+ }
1426+
1427+ /**
1428+ * Retrieves the value of the designated column in the current row of this
1429+ * <code>CachedRowSetImpl</code> object as a <code>java.io.InputStream</code>
1430+ * object.
1431+ * <P>
1432+ * A column value can be retrieved as a stream of uninterpreted bytes
1433+ * and then read in chunks from the stream. This method is particularly
1434+ * suitable for retrieving large <code>LONGVARBINARY</code> values.
1435+ *
1436+ * <P><B>Note:</B> All the data in the returned stream must be
1437+ * read prior to getting the value of any other column. The next
1438+ * call to a get method implicitly closes the stream. Also, a
1439+ * stream may return <code>0</code> for
1440+ * <code>CachedRowSetImpl.available()</code> whether there is data
1441+ * available or not.
1442+ *
1443+ * @param columnIndex the first column is <code>1</code>, the second
1444+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1445+ * and equal to or less than the number of columns in the rowset
1446+ * @return a Java input stream that delivers the database column value
1447+ * as a stream of uninterpreted bytes. If the value is SQL <code>NULL</code>
1448+ * then the result is <code>null</code>.
1449+ * @throws SQLException if (1) the given column index is out of bounds,
1450+ * (2) the cursor is not on one of this rowset's rows or its
1451+ * insert row, or (3) the designated column does not store an
1452+ * SQL <code>BINARY, VARBINARY</code> or <code><b>LONGVARBINARY</b></code>
1453+ * The bold type indicates the SQL type that this method is recommened
1454+ * to retrieve.
1455+ * @see #getBinaryStream(String)
1456+ */
1457+ public java.io.InputStream getBinaryStream(int columnIndex) throws SQLException {
1458+ throw new UnsupportedOperationException();
1459+
1460+ }
1461+
1462+
1463+ //======================================================================
1464+ // Methods for accessing results by column name
1465+ //======================================================================
1466+
1467+ /**
1468+ * Retrieves the value stored in the designated column
1469+ * of the current row as a <code>String</code> object.
1470+ *
1471+ * @param columnName a <code>String</code> object giving the SQL name of
1472+ * a column in this <code>CachedRowSetImpl</code> object
1473+ * @return the column value; if the value is SQL <code>NULL</code>,
1474+ * the result is <code>null</code>
1475+ * @throws SQLException if (1) the given column name is not the name of
1476+ * a column in this rowset, (2) the cursor is not on one of
1477+ * this rowset's rows or its insert row, or (3) the designated
1478+ * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
1479+ * BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, <b>CHAR</b>,
1480+ * <b>VARCHAR</b></code> or <code>LONGVARCHAR<</code> value. The bold SQL type
1481+ * designates the recommended return type.
1482+ */
1483+ public String getString(String columnName) throws SQLException {
1484+ throw new UnsupportedOperationException();
1485+ }
1486+
1487+ /**
1488+ * Retrieves the value stored in the designated column
1489+ * of the current row as a <code>boolean</code> value.
1490+ *
1491+ * @param columnName a <code>String</code> object giving the SQL name of
1492+ * a column in this <code>CachedRowSetImpl</code> object
1493+ * @return the column value as a <code>boolean</code> in the Java programming
1494+ * language; if the value is SQL <code>NULL</code>,
1495+ * the result is <code>false</code>
1496+ * @throws SQLException if (1) the given column name is not the name of
1497+ * a column in this rowset, (2) the cursor is not on one of
1498+ * this rowset's rows or its insert row, or (3) the designated
1499+ * column does not store an SQL <code>BOOLEAN</code> value
1500+ * @see #getBoolean(int)
1501+ */
1502+ public boolean getBoolean(String columnName) throws SQLException {
1503+ throw new UnsupportedOperationException();
1504+ }
1505+
1506+ /**
1507+ * Retrieves the value stored in the designated column
1508+ * of the current row as a <code>byte</code> value.
1509+ *
1510+ * @param columnName a <code>String</code> object giving the SQL name of
1511+ * a column in this <code>CachedRowSetImpl</code> object
1512+ * @return the column value as a <code>byte</code> in the Java programming
1513+ * language; if the value is SQL <code>NULL</code>, the result is <code>0</code>
1514+ * @throws SQLException if (1) the given column name is not the name of
1515+ * a column in this rowset, (2) the cursor is not on one of
1516+ * this rowset's rows or its insert row, or (3) the designated
1517+ * column does not store an SQL <code><B>TINYINT</B>, SMALLINT, INTEGER,
1518+ * BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
1519+ * VARCHAR</code> or <code>LONGVARCHAR</code> value. The
1520+ * bold type designates the recommended return type
1521+ */
1522+ public byte getByte(String columnName) throws SQLException {
1523+ throw new UnsupportedOperationException();
1524+ }
1525+
1526+ /**
1527+ * Retrieves the value stored in the designated column
1528+ * of the current row as a <code>short</code> value.
1529+ *
1530+ * @param columnName a <code>String</code> object giving the SQL name of
1531+ * a column in this <code>CachedRowSetImpl</code> object
1532+ * @return the column value; if the value is SQL <code>NULL</code>,
1533+ * the result is <code>0</code>
1534+ * @throws SQLException if (1) the given column name is not the name of
1535+ * a column in this rowset, (2) the cursor is not on one of
1536+ * this rowset's rows or its insert row, or (3) the designated
1537+ * column does not store an SQL <code>TINYINT, <b>SMALLINT</b>, INTEGER
1538+ * BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
1539+ * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
1540+ * designates the recommended return type.
1541+ * @see #getShort(int)
1542+ */
1543+ public short getShort(String columnName) throws SQLException {
1544+ throw new UnsupportedOperationException();
1545+ }
1546+
1547+ /**
1548+ * Retrieves the value stored in the designated column
1549+ * of the current row as an <code>int</code> value.
1550+ *
1551+ * @param columnName a <code>String</code> object giving the SQL name of
1552+ * a column in this <code>CachedRowSetImpl</code> object
1553+ * @return the column value; if the value is SQL <code>NULL</code>,
1554+ * the result is <code>0</code>
1555+ * @throws SQLException if (1) the given column name is not the name
1556+ * of a column in this rowset,
1557+ * (2) the cursor is not on one of this rowset's rows or its
1558+ * insert row, or (3) the designated column does not store an
1559+ * SQL <code>TINYINT, SMALLINT, <b>INTEGER</b>, BIGINT, REAL
1560+ * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1561+ * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1562+ * recommended return type.
1563+ */
1564+ public int getInt(String columnName) throws SQLException {
1565+ throw new UnsupportedOperationException();
1566+ }
1567+
1568+ /**
1569+ * Retrieves the value stored in the designated column
1570+ * of the current row as a <code>long</code> value.
1571+ *
1572+ * @param columnName a <code>String</code> object giving the SQL name of
1573+ * a column in this <code>CachedRowSetImpl</code> object
1574+ * @return the column value; if the value is SQL <code>NULL</code>,
1575+ * the result is <code>0</code>
1576+ * @throws SQLException if (1) the given column name is not the name of
1577+ * a column in this rowset, (2) the cursor is not on one of
1578+ * this rowset's rows or its insert row, or (3) the designated
1579+ * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
1580+ * <b>BIGINT</b>, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
1581+ * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
1582+ * designates the recommended return type.
1583+ * @see #getLong(int)
1584+ */
1585+ public long getLong(String columnName) throws SQLException {
1586+ throw new UnsupportedOperationException();
1587+ }
1588+
1589+ /**
1590+ * Retrieves the value stored in the designated column
1591+ * of the current row as a <code>float</code> value.
1592+ *
1593+ * @param columnName a <code>String</code> object giving the SQL name of
1594+ * a column in this <code>CachedRowSetImpl</code> object
1595+ * @return the column value; if the value is SQL <code>NULL</code>,
1596+ * the result is <code>0</code>
1597+ * @throws SQLException if (1) the given column name is not the name of
1598+ * a column in this rowset, (2) the cursor is not on one of
1599+ * this rowset's rows or its insert row, or (3) the designated
1600+ * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
1601+ * BIGINT, <b>REAL</b>, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
1602+ * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
1603+ * designates the recommended return type.
1604+ * @see #getFloat(String)
1605+ */
1606+ public float getFloat(String columnName) throws SQLException {
1607+ throw new UnsupportedOperationException();
1608+ }
1609+
1610+ /**
1611+ * Retrieves the value stored in the designated column
1612+ * of the current row of this <code>CachedRowSetImpl</code> object
1613+ * as a <code>double</code> value.
1614+ *
1615+ * @param columnName a <code>String</code> object giving the SQL name of
1616+ * a column in this <code>CachedRowSetImpl</code> object
1617+ * @return the column value; if the value is SQL <code>NULL</code>,
1618+ * the result is <code>0</code>
1619+ * @throws SQLException if (1) the given column name is not the name of
1620+ * a column in this rowset, (2) the cursor is not on one of
1621+ * this rowset's rows or its insert row, or (3) the designated
1622+ * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
1623+ * BIGINT, REAL, <b>FLOAT</b>, <b>DOUBLE</b>, DECIMAL, NUMERIC, BIT, CHAR,
1624+ * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
1625+ * designates the recommended return types.
1626+ * @see #getDouble(int)
1627+ */
1628+ public double getDouble(String columnName) throws SQLException {
1629+ throw new UnsupportedOperationException();
1630+ }
1631+
1632+ /**
1633+ * Retrieves the value stored in the designated column
1634+ * of the current row as a <code>java.math.BigDecimal</code> object.
1635+ *
1636+ * @param columnName a <code>String</code> object giving the SQL name of
1637+ * a column in this <code>CachedRowSetImpl</code> object
1638+ * @param scale the number of digits to the right of the decimal point
1639+ * @return a java.math.BugDecimal object with <code><i>scale</i></code>
1640+ * number of digits to the right of the decimal point.
1641+ * @throws SQLException if (1) the given column name is not the name of
1642+ * a column in this rowset, (2) the cursor is not on one of
1643+ * this rowset's rows or its insert row, or (3) the designated
1644+ * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
1645+ * BIGINT, REAL, FLOAT, DOUBLE, <b>DECIMAL</b>, <b>NUMERIC</b>, BIT CHAR,
1646+ * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
1647+ * designates the recommended return type that this method is used to
1648+ * retrieve.
1649+ * @deprecated Use the <code>getBigDecimal(String columnName)</code>
1650+ * method instead
1651+ */
1652+ public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
1653+ throw new UnsupportedOperationException();
1654+ }
1655+
1656+ /**
1657+ * Retrieves the value stored in the designated column
1658+ * of the current row as a <code>byte</code> array.
1659+ * The bytes represent the raw values returned by the driver.
1660+ *
1661+ * @param columnName a <code>String</code> object giving the SQL name of
1662+ * a column in this <code>CachedRowSetImpl</code> object
1663+ * @return the column value as a <code>byte</code> array in the Java programming
1664+ * language; if the value is SQL <code>NULL</code>, the result is <code>null</code>
1665+ * @throws SQLException if (1) the given column name is not the name of
1666+ * a column in this rowset, (2) the cursor is not on one of
1667+ * this rowset's rows or its insert row, or (3) the designated
1668+ * column does not store an SQL <code><b>BINARY</b>, <b>VARBINARY</b>
1669+ * </code> or <code>LONGVARBINARY</code> values
1670+ * The bold SQL type designates the recommended return type.
1671+ * @see #getBytes(int)
1672+ */
1673+ public byte[] getBytes(String columnName) throws SQLException {
1674+ throw new UnsupportedOperationException();
1675+ }
1676+
1677+ /**
1678+ * Retrieves the value stored in the designated column
1679+ * of the current row as a <code>java.sql.Date</code> object.
1680+ *
1681+ * @param columnName a <code>String</code> object giving the SQL name of
1682+ * a column in this <code>CachedRowSetImpl</code> object
1683+ * @return the column value; if the value is SQL <code>NULL</code>,
1684+ * the result is <code>null</code>
1685+ * @throws SQLException if (1) the given column name is not the name of
1686+ * a column in this rowset, (2) the cursor is not on one of
1687+ * this rowset's rows or its insert row, or (3) the designated
1688+ * column does not store an SQL <code>DATE</code> or
1689+ * <code>TIMESTAMP</code> value
1690+ */
1691+ public java.sql.Date getDate(String columnName) throws SQLException {
1692+ throw new UnsupportedOperationException();
1693+ }
1694+
1695+ /**
1696+ * Retrieves the value stored in the designated column
1697+ * of the current row as a <code>java.sql.Time</code> object.
1698+ *
1699+ * @param columnName a <code>String</code> object giving the SQL name of
1700+ * a column in this <code>CachedRowSetImpl</code> object
1701+ * @return the column value; if the value is SQL <code>NULL</code>,
1702+ * the result is <code>null</code>
1703+ * @throws SQLException if the given column name does not match one of
1704+ * this rowset's column names or the cursor is not on one of
1705+ * this rowset's rows or its insert row
1706+ */
1707+ public java.sql.Time getTime(String columnName) throws SQLException {
1708+ throw new UnsupportedOperationException();
1709+ }
1710+
1711+ /**
1712+ * Retrieves the value stored in the designated column
1713+ * of the current row as a <code>java.sql.Timestamp</code> object.
1714+ *
1715+ * @param columnName a <code>String</code> object giving the SQL name of
1716+ * a column in this <code>CachedRowSetImpl</code> object
1717+ * @return the column value; if the value is SQL <code>NULL</code>,
1718+ * the result is <code>null</code>
1719+ * @throws SQLException if the given column name does not match one of
1720+ * this rowset's column names or the cursor is not on one of
1721+ * this rowset's rows or its insert row
1722+ */
1723+ public java.sql.Timestamp getTimestamp(String columnName) throws SQLException {
1724+ throw new UnsupportedOperationException();
1725+ }
1726+
1727+ /**
1728+ * Retrieves the value of the designated column in the current row of this
1729+ * <code>CachedRowSetImpl</code> object as a <code>java.io.InputStream</code>
1730+ * object.
1731+ *
1732+ * A column value can be retrieved as a stream of ASCII characters
1733+ * and then read in chunks from the stream. This method is particularly
1734+ * suitable for retrieving large <code>LONGVARCHAR</code> values. The
1735+ * <code>SyncProvider</code> will rely on the JDBC driver to do any necessary
1736+ * conversion from the database format into ASCII format.
1737+ *
1738+ * <P><B>Note:</B> All the data in the returned stream must
1739+ * be read prior to getting the value of any other column. The
1740+ * next call to a <code>getXXX</code> method implicitly closes the stream.
1741+ *
1742+ * @param columnName a <code>String</code> object giving the SQL name of
1743+ * a column in this <code>CachedRowSetImpl</code> object
1744+ * @return a Java input stream that delivers the database column value
1745+ * as a stream of one-byte ASCII characters. If the value is SQL
1746+ * <code>NULL</code>, the result is <code>null</code>.
1747+ * @throws SQLException if (1) the given column name is not the name of
1748+ * a column in this rowset
1749+ * (2) the cursor is not on one of this rowset's rows or its
1750+ * insert row, or (3) the designated column does not store an
1751+ * SQL <code>CHAR, VARCHAR</code>, <code><b>LONGVARCHAR</b></code>
1752+ * <code>BINARY, VARBINARY</code> or <code>LONGVARBINARY</code> value. The
1753+ * bold SQL type designates the recommended return types that this method is
1754+ * used to retrieve.
1755+ * @see #getAsciiStream(int)
1756+ */
1757+ public java.io.InputStream getAsciiStream(String columnName) throws SQLException {
1758+ throw new UnsupportedOperationException();
1759+
1760+ }
1761+
1762+ /**
1763+ * A column value can be retrieved as a stream of Unicode characters
1764+ * and then read in chunks from the stream. This method is particularly
1765+ * suitable for retrieving large <code>LONGVARCHAR</code> values.
1766+ * The JDBC driver will do any necessary conversion from the database
1767+ * format into Unicode.
1768+ *
1769+ * <P><B>Note:</B> All the data in the returned stream must
1770+ * be read prior to getting the value of any other column. The
1771+ * next call to a <code>getXXX</code> method implicitly closes the stream.
1772+ *
1773+ * @param columnName a <code>String</code> object giving the SQL name of
1774+ * a column in this <code>CachedRowSetImpl</code> object
1775+ * @return a Java input stream that delivers the database column value
1776+ * as a stream of two-byte Unicode characters. If the value is
1777+ * SQL <code>NULL</code>, the result is <code>null</code>.
1778+ * @throws SQLException if the given column name does not match one of
1779+ * this rowset's column names or the cursor is not on one of
1780+ * this rowset's rows or its insert row
1781+ * @deprecated use the method <code>getCharacterStream</code> instead
1782+ */
1783+ public java.io.InputStream getUnicodeStream(String columnName) throws SQLException {
1784+ throw new UnsupportedOperationException();
1785+ }
1786+
1787+ /**
1788+ * Retrieves the value of the designated column in the current row of this
1789+ * <code>CachedRowSetImpl</code> object as a <code>java.io.InputStream</code>
1790+ * object.
1791+ * <P>
1792+ * A column value can be retrieved as a stream of uninterpreted bytes
1793+ * and then read in chunks from the stream. This method is particularly
1794+ * suitable for retrieving large <code>LONGVARBINARY</code> values.
1795+ *
1796+ * <P><B>Note:</B> All the data in the returned stream must be
1797+ * read prior to getting the value of any other column. The next
1798+ * call to a get method implicitly closes the stream. Also, a
1799+ * stream may return <code>0</code> for <code>CachedRowSetImpl.available()</code>
1800+ * whether there is data available or not.
1801+ *
1802+ * @param columnName a <code>String</code> object giving the SQL name of
1803+ * a column in this <code>CachedRowSetImpl</code> object
1804+ * @return a Java input stream that delivers the database column value
1805+ * as a stream of uninterpreted bytes. If the value is SQL
1806+ * <code>NULL</code>, the result is <code>null</code>.
1807+ * @throws SQLException if (1) the given column name is unknown,
1808+ * (2) the cursor is not on one of this rowset's rows or its
1809+ * insert row, or (3) the designated column does not store an
1810+ * SQL <code>BINARY, VARBINARY</code> or <code><b>LONGVARBINARY</b></code>
1811+ * The bold type indicates the SQL type that this method is recommened
1812+ * to retrieve.
1813+ * @see #getBinaryStream(int)
1814+ *
1815+ */
1816+ public java.io.InputStream getBinaryStream(String columnName) throws SQLException {
1817+ throw new UnsupportedOperationException();
1818+ }
1819+
1820+
1821+ //=====================================================================
1822+ // Advanced features:
1823+ //=====================================================================
1824+
1825+ /**
1826+ * The first warning reported by calls on this <code>CachedRowSetImpl</code>
1827+ * object is returned. Subsequent <code>CachedRowSetImpl</code> warnings will
1828+ * be chained to this <code>SQLWarning</code>.
1829+ *
1830+ * <P>The warning chain is automatically cleared each time a new
1831+ * row is read.
1832+ *
1833+ * <P><B>Note:</B> This warning chain only covers warnings caused
1834+ * by <code>ResultSet</code> methods. Any warning caused by statement
1835+ * methods (such as reading OUT parameters) will be chained on the
1836+ * <code>Statement</code> object.
1837+ *
1838+ * @return the first SQLWarning or null
1839+ */
1840+ public SQLWarning getWarnings() {
1841+ throw new UnsupportedOperationException();
1842+ }
1843+
1844+ /**
1845+ * Clears all the warnings reporeted for the <code>CachedRowSetImpl</code>
1846+ * object. After a call to this method, the <code>getWarnings</code> method
1847+ * returns <code>null</code> until a new warning is reported for this
1848+ * <code>CachedRowSetImpl</code> object.
1849+ */
1850+ public void clearWarnings() {
1851+ throw new UnsupportedOperationException();
1852+ }
1853+
1854+ /**
1855+ * Retrieves the name of the SQL cursor used by this
1856+ * <code>CachedRowSetImpl</code> object.
1857+ *
1858+ * <P>In SQL, a result table is retrieved through a cursor that is
1859+ * named. The current row of a <code>ResultSet</code> can be updated or deleted
1860+ * using a positioned update/delete statement that references the
1861+ * cursor name. To ensure that the cursor has the proper isolation
1862+ * level to support an update operation, the cursor's <code>SELECT</code>
1863+ * statement should be of the form <code>select for update</code>.
1864+ * If the <code>for update</code> clause
1865+ * is omitted, positioned updates may fail.
1866+ *
1867+ * <P>JDBC supports this SQL feature by providing the name of the
1868+ * SQL cursor used by a <code>ResultSet</code> object. The current row
1869+ * of a result set is also the current row of this SQL cursor.
1870+ *
1871+ * <P><B>Note:</B> If positioned updates are not supported, an
1872+ * <code>SQLException</code> is thrown.
1873+ *
1874+ * @return the SQL cursor name for this <code>CachedRowSetImpl</code> object's
1875+ * cursor
1876+ * @throws SQLException if an error occurs
1877+ */
1878+ public String getCursorName() throws SQLException {
1879+ throw new UnsupportedOperationException();
1880+ }
1881+
1882+ /**
1883+ * Retrieves a <code>ResultSetMetaData</code> object instance that
1884+ * contains information about the <code>CachedRowSet</code> object.
1885+ * However, applications should cast the returned object to a
1886+ * <code>RowSetMetaData</code> interface implementation. In the
1887+ * reference implementation, this cast can be done on the
1888+ * <code>RowSetMetaDataImpl</code> class.
1889+ * <P>
1890+ * For example:
1891+ * <pre>
1892+ * CachedRowSet crs = new CachedRowSetImpl();
1893+ * RowSetMetaDataImpl metaData =
1894+ * (RowSetMetaDataImpl)crs.getMetaData();
1895+ * // Set the number of columns in the RowSet object for
1896+ * // which this RowSetMetaDataImpl object was created to the
1897+ * // given number.
1898+ * metaData.setColumnCount(3);
1899+ * crs.setMetaData(metaData);
1900+ * </pre>
1901+ *
1902+ * @return the <code>ResultSetMetaData</code> object that describes this
1903+ * <code>CachedRowSetImpl</code> object's columns
1904+ * @throws SQLException if an error occurs in generating the RowSet
1905+ * meta data; or if the <code>CachedRowSetImpl</code> is empty.
1906+ * @see javax.sql.RowSetMetaData
1907+ */
1908+ public ResultSetMetaData getMetaData() throws SQLException {
1909+ throw new UnsupportedOperationException();
1910+ }
1911+
1912+
1913+ /**
1914+ * Retrieves the value of the designated column in the current row
1915+ * of this <code>CachedRowSetImpl</code> object as an
1916+ * <code>Object</code> value.
1917+ * <P>
1918+ * The type of the <code>Object</code> will be the default
1919+ * Java object type corresponding to the column's SQL type,
1920+ * following the mapping for built-in types specified in the JDBC 3.0
1921+ * specification.
1922+ * <P>
1923+ * This method may also be used to read datatabase-specific
1924+ * abstract data types.
1925+ * <P>
1926+ * This implementation of the method <code>getObject</code> extends its
1927+ * behavior so that it gets the attributes of an SQL structured type
1928+ * as an array of <code>Object</code> values. This method also custom
1929+ * maps SQL user-defined types to classes in the Java programming language.
1930+ * When the specified column contains
1931+ * a structured or distinct value, the behavior of this method is as
1932+ * if it were a call to the method <code>getObject(columnIndex,
1933+ * this.getStatement().getConnection().getTypeMap())</code>.
1934+ *
1935+ * @param columnIndex the first column is <code>1</code>, the second
1936+ * is <code>2</code>, and so on; must be <code>1</code> or larger
1937+ * and equal to or less than the number of columns in the rowset
1938+ * @return a <code>java.lang.Object</code> holding the column value;
1939+ * if the value is SQL <code>NULL</code>, the result is <code>null</code>
1940+ * @throws SQLException if the given column index is out of bounds,
1941+ * the cursor is not on a valid row, or there is a problem getting
1942+ * the <code>Class</code> object for a custom mapping
1943+ * @see #getObject(String)
1944+ */
1945+ public Object getObject(int columnIndex) throws SQLException {
1946+ throw new UnsupportedOperationException();
1947+ }
1948+
1949+ /**
1950+ * Retrieves the value of the designated column in the current row
1951+ * of this <code>CachedRowSetImpl</code> object as an
1952+ * <code>Object</code> value.
1953+ * <P>
1954+ * The type of the <code>Object</code> will be the default
1955+ * Java object type corresponding to the column's SQL type,
1956+ * following the mapping for built-in types specified in the JDBC 3.0
1957+ * specification.
1958+ * <P>
1959+ * This method may also be used to read datatabase-specific
1960+ * abstract data types.
1961+ * <P>
1962+ * This implementation of the method <code>getObject</code> extends its
1963+ * behavior so that it gets the attributes of an SQL structured type
1964+ * as an array of <code>Object</code> values. This method also custom
1965+ * maps SQL user-defined types to classes
1966+ * in the Java programming language. When the specified column contains
1967+ * a structured or distinct value, the behavior of this method is as
1968+ * if it were a call to the method <code>getObject(columnIndex,
1969+ * this.getStatement().getConnection().getTypeMap())</code>.
1970+ *
1971+ * @param columnName a <code>String</code> object that must match the
1972+ * SQL name of a column in this rowset, ignoring case
1973+ * @return a <code>java.lang.Object</code> holding the column value;
1974+ * if the value is SQL <code>NULL</code>, the result is <code>null</code>
1975+ * @throws SQLException if (1) the given column name does not match one of
1976+ * this rowset's column names, (2) the cursor is not
1977+ * on a valid row, or (3) there is a problem getting
1978+ * the <code>Class</code> object for a custom mapping
1979+ * @see #getObject(int)
1980+ */
1981+ public Object getObject(String columnName) throws SQLException {
1982+ throw new UnsupportedOperationException();
1983+ }
1984+
1985+ //----------------------------------------------------------------
1986+
1987+ /**
1988+ * Maps the given column name for one of this <code>CachedRowSetImpl</code>
1989+ * object's columns to its column number.
1990+ *
1991+ * @param columnName a <code>String</code> object that must match the
1992+ * SQL name of a column in this rowset, ignoring case
1993+ * @return the column index of the given column name
1994+ * @throws SQLException if the given column name does not match one
1995+ * of this rowset's column names
1996+ */
1997+ public int findColumn(String columnName) throws SQLException {
1998+ throw new UnsupportedOperationException();
1999+ }
2000+
2001+ //--------------------------JDBC 2.0-----------------------------------
2002+
2003+ //---------------------------------------------------------------------
2004+ // Getter's and Setter's
2005+ //---------------------------------------------------------------------
2006+
2007+ /**
2008+ * Retrieves the value stored in the designated column
2009+ * of the current row as a <code>java.io.Reader</code> object.
2010+ *
2011+ * <P><B>Note:</B> All the data in the returned stream must
2012+ * be read prior to getting the value of any other column. The
2013+ * next call to a <code>getXXX</code> method implicitly closes the stream.
2014+ *
2015+ * @param columnIndex the first column is <code>1</code>, the second
2016+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2017+ * and equal to or less than the number of columns in the rowset
2018+ * @return a Java character stream that delivers the database column value
2019+ * as a stream of two-byte unicode characters in a
2020+ * <code>java.io.Reader</code> object. If the value is
2021+ * SQL <code>NULL</code>, the result is <code>null</code>.
2022+ * @throws SQLException if (1) the given column index is out of bounds,
2023+ * (2) the cursor is not on one of this rowset's rows or its
2024+ * insert row, or (3) the designated column does not store an
2025+ * SQL <code>CHAR, VARCHAR, <b>LONGVARCHAR</b>, BINARY, VARBINARY</code> or
2026+ * <code>LONGVARBINARY</code> value.
2027+ * The bold SQL type designates the recommended return type.
2028+ * @see #getCharacterStream(String)
2029+ */
2030+ public java.io.Reader getCharacterStream(int columnIndex) throws SQLException{
2031+ throw new UnsupportedOperationException();
2032+ }
2033+
2034+ /**
2035+ * Retrieves the value stored in the designated column
2036+ * of the current row as a <code>java.io.Reader</code> object.
2037+ *
2038+ * <P><B>Note:</B> All the data in the returned stream must
2039+ * be read prior to getting the value of any other column. The
2040+ * next call to a <code>getXXX</code> method implicitly closes the stream.
2041+ *
2042+ * @param columnName a <code>String</code> object giving the SQL name of
2043+ * a column in this <code>CachedRowSetImpl</code> object
2044+ * @return a Java input stream that delivers the database column value
2045+ * as a stream of two-byte Unicode characters. If the value is
2046+ * SQL <code>NULL</code>, the result is <code>null</code>.
2047+ * @throws SQLException if (1) the given column name is not the name of
2048+ * a column in this rowset, (2) the cursor is not on one of
2049+ * this rowset's rows or its insert row, or (3) the designated
2050+ * column does not store an SQL <code>CHAR, VARCHAR, <b>LONGVARCHAR</b>,
2051+ * BINARY, VARYBINARY</code> or <code>LONGVARBINARY</code> value.
2052+ * The bold SQL type designates the recommended return type.
2053+ */
2054+ public java.io.Reader getCharacterStream(String columnName) throws SQLException {
2055+ throw new UnsupportedOperationException();
2056+ }
2057+
2058+ /**
2059+ * Retrieves the value of the designated column in the current row
2060+ * of this <code>CachedRowSetImpl</code> object as a
2061+ * <code>java.math.BigDecimal</code> object.
2062+ *
2063+ * @param columnIndex the first column is <code>1</code>, the second
2064+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2065+ * and equal to or less than the number of columns in the rowset
2066+ * @return a <code>java.math.BigDecimal</code> value with full precision;
2067+ * if the value is SQL <code>NULL</code>, the result is <code>null</code>
2068+ * @throws SQLException if (1) the given column index is out of bounds,
2069+ * (2) the cursor is not on one of this rowset's rows or its
2070+ * insert row, or (3) the designated column does not store an
2071+ * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, REAL,
2072+ * FLOAT, DOUBLE, <b>DECIMAL</b>, <b>NUMERIC</b>, BIT, CHAR, VARCHAR</code>
2073+ * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
2074+ * recommended return types that this method is used to retrieve.
2075+ * @see #getBigDecimal(String)
2076+ */
2077+ public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
2078+ throw new UnsupportedOperationException();
2079+ }
2080+
2081+ /**
2082+ * Retrieves the value of the designated column in the current row
2083+ * of this <code>CachedRowSetImpl</code> object as a
2084+ * <code>java.math.BigDecimal</code> object.
2085+ *
2086+ * @param columnName a <code>String</code> object that must match the
2087+ * SQL name of a column in this rowset, ignoring case
2088+ * @return a <code>java.math.BigDecimal</code> value with full precision;
2089+ * if the value is SQL <code>NULL</code>, the result is <code>null</code>
2090+ * @throws SQLException if (1) the given column name is not the name of
2091+ * a column in this rowset, (2) the cursor is not on one of
2092+ * this rowset's rows or its insert row, or (3) the designated
2093+ * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
2094+ * BIGINT, REAL, FLOAT, DOUBLE, <b>DECIMAL</b>, <b>NUMERIC</b>, BIT CHAR,
2095+ * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
2096+ * designates the recommended return type that this method is used to
2097+ * retrieve
2098+ * @see #getBigDecimal(int)
2099+ */
2100+ public BigDecimal getBigDecimal(String columnName) throws SQLException {
2101+ throw new UnsupportedOperationException();
2102+ }
2103+
2104+ //---------------------------------------------------------------------
2105+ // Traversal/Positioning
2106+ //---------------------------------------------------------------------
2107+
2108+ /**
2109+ * Returns the number of rows in this <code>CachedRowSetImpl</code> object.
2110+ *
2111+ * @return number of rows in the rowset
2112+ */
2113+ public int size() {
2114+ throw new UnsupportedOperationException();
2115+ }
2116+
2117+ /**
2118+ * Indicates whether the cursor is before the first row in this
2119+ * <code>CachedRowSetImpl</code> object.
2120+ *
2121+ * @return <code>true</code> if the cursor is before the first row;
2122+ * <code>false</code> otherwise or if the rowset contains no rows
2123+ * @throws SQLException if an error occurs
2124+ */
2125+ public boolean isBeforeFirst() throws SQLException {
2126+ throw new UnsupportedOperationException();
2127+ }
2128+
2129+ /**
2130+ * Indicates whether the cursor is after the last row in this
2131+ * <code>CachedRowSetImpl</code> object.
2132+ *
2133+ * @return <code>true</code> if the cursor is after the last row;
2134+ * <code>false</code> otherwise or if the rowset contains no rows
2135+ * @throws SQLException if an error occurs
2136+ */
2137+ public boolean isAfterLast() throws SQLException {
2138+ throw new UnsupportedOperationException();
2139+ }
2140+
2141+ /**
2142+ * Indicates whether the cursor is on the first row in this
2143+ * <code>CachedRowSetImpl</code> object.
2144+ *
2145+ * @return <code>true</code> if the cursor is on the first row;
2146+ * <code>false</code> otherwise or if the rowset contains no rows
2147+ * @throws SQLException if an error occurs
2148+ */
2149+ public boolean isFirst() throws SQLException {
2150+ throw new UnsupportedOperationException();
2151+ }
2152+
2153+ /**
2154+ * Indicates whether the cursor is on the last row in this
2155+ * <code>CachedRowSetImpl</code> object.
2156+ * <P>
2157+ * Note: Calling the method <code>isLast</code> may be expensive
2158+ * because the JDBC driver might need to fetch ahead one row in order
2159+ * to determine whether the current row is the last row in this rowset.
2160+ *
2161+ * @return <code>true</code> if the cursor is on the last row;
2162+ * <code>false</code> otherwise or if this rowset contains no rows
2163+ * @throws SQLException if an error occurs
2164+ */
2165+ public boolean isLast() throws SQLException {
2166+ throw new UnsupportedOperationException();
2167+ }
2168+
2169+ /**
2170+ * Moves this <code>CachedRowSetImpl</code> object's cursor to the front of
2171+ * the rowset, just before the first row. This method has no effect if
2172+ * this rowset contains no rows.
2173+ *
2174+ * @throws SQLException if an error occurs or the type of this rowset
2175+ * is <code>ResultSet.TYPE_FORWARD_ONLY</code>
2176+ */
2177+ public void beforeFirst() throws SQLException {
2178+ throw new UnsupportedOperationException();
2179+ }
2180+
2181+ /**
2182+ * Moves this <code>CachedRowSetImpl</code> object's cursor to the end of
2183+ * the rowset, just after the last row. This method has no effect if
2184+ * this rowset contains no rows.
2185+ *
2186+ * @throws SQLException if an error occurs
2187+ */
2188+ public void afterLast() throws SQLException {
2189+ throw new UnsupportedOperationException();
2190+ }
2191+
2192+ /**
2193+ * Moves this <code>CachedRowSetImpl</code> object's cursor to the first row
2194+ * and returns <code>true</code> if the operation was successful. This
2195+ * method also notifies registered listeners that the cursor has moved.
2196+ *
2197+ * @return <code>true</code> if the cursor is on a valid row;
2198+ * <code>false</code> otherwise or if there are no rows in this
2199+ * <code>CachedRowSetImpl</code> object
2200+ * @throws SQLException if the type of this rowset
2201+ * is <code>ResultSet.TYPE_FORWARD_ONLY</code>
2202+ */
2203+ public boolean first() throws SQLException {
2204+ throw new UnsupportedOperationException();
2205+ }
2206+
2207+ /**
2208+ * Moves this <code>CachedRowSetImpl</code> object's cursor to the first
2209+ * row and returns <code>true</code> if the operation is successful.
2210+ * <P>
2211+ * This method is called internally by the methods <code>first</code>,
2212+ * <code>isFirst</code>, and <code>absolute</code>.
2213+ * It in turn calls the method <code>internalNext</code> in order to
2214+ * handle the case where the first row is a deleted row that is not visible.
2215+ * <p>
2216+ * This is a implementation only method and is not required as a standard
2217+ * implementation of the <code>CachedRowSet</code> interface.
2218+ *
2219+ * @return <code>true</code> if the cursor moved to the first row;
2220+ * <code>false</code> otherwise
2221+ * @throws SQLException if an error occurs
2222+ */
2223+ protected boolean internalFirst() throws SQLException {
2224+ throw new UnsupportedOperationException();
2225+ }
2226+
2227+ /**
2228+ * Moves this <code>CachedRowSetImpl</code> object's cursor to the last row
2229+ * and returns <code>true</code> if the operation was successful. This
2230+ * method also notifies registered listeners that the cursor has moved.
2231+ *
2232+ * @return <code>true</code> if the cursor is on a valid row;
2233+ * <code>false</code> otherwise or if there are no rows in this
2234+ * <code>CachedRowSetImpl</code> object
2235+ * @throws SQLException if the type of this rowset
2236+ * is <code>ResultSet.TYPE_FORWARD_ONLY</code>
2237+ */
2238+ public boolean last() throws SQLException {
2239+ throw new UnsupportedOperationException();
2240+ }
2241+
2242+ /**
2243+ * Moves this <code>CachedRowSetImpl</code> object's cursor to the last
2244+ * row and returns <code>true</code> if the operation is successful.
2245+ * <P>
2246+ * This method is called internally by the method <code>last</code>
2247+ * when rows have been deleted and the deletions are not visible.
2248+ * The method <code>internalLast</code> handles the case where the
2249+ * last row is a deleted row that is not visible by in turn calling
2250+ * the method <code>internalPrevious</code>.
2251+ * <p>
2252+ * This is a implementation only method and is not required as a standard
2253+ * implementation of the <code>CachedRowSet</code> interface.
2254+ *
2255+ * @return <code>true</code> if the cursor moved to the last row;
2256+ * <code>false</code> otherwise
2257+ * @throws SQLException if an error occurs
2258+ */
2259+ protected boolean internalLast() throws SQLException {
2260+ throw new UnsupportedOperationException();
2261+ }
2262+
2263+ /**
2264+ * Returns the number of the current row in this <code>CachedRowSetImpl</code>
2265+ * object. The first row is number 1, the second number 2, and so on.
2266+ *
2267+ * @return the number of the current row; <code>0</code> if there is no
2268+ * current row
2269+ * @throws SQLException if an error occurs; or if the <code>CacheRowSetImpl</code>
2270+ * is empty
2271+ */
2272+ public int getRow() throws SQLException {
2273+ return crsSync.getRow();
2274+ }
2275+
2276+ /**
2277+ * Moves this <code>CachedRowSetImpl</code> object's cursor to the row number
2278+ * specified.
2279+ *
2280+ * <p>If the number is positive, the cursor moves to an absolute row with
2281+ * respect to the beginning of the rowset. The first row is row 1, the second
2282+ * is row 2, and so on. For example, the following command, in which
2283+ * <code>crs</code> is a <code>CachedRowSetImpl</code> object, moves the cursor
2284+ * to the fourth row, starting from the beginning of the rowset.
2285+ * <PRE><code>
2286+ *
2287+ * crs.absolute(4);
2288+ *
2289+ * </code> </PRE>
2290+ * <P>
2291+ * If the number is negative, the cursor moves to an absolute row position
2292+ * with respect to the end of the rowset. For example, calling
2293+ * <code>absolute(-1)</code> positions the cursor on the last row,
2294+ * <code>absolute(-2)</code> moves it on the next-to-last row, and so on.
2295+ * If the <code>CachedRowSetImpl</code> object <code>crs</code> has five rows,
2296+ * the following command moves the cursor to the fourth-to-last row, which
2297+ * in the case of a rowset with five rows, is also the second row, counting
2298+ * from the beginning.
2299+ * <PRE><code>
2300+ *
2301+ * crs.absolute(-4);
2302+ *
2303+ * </code> </PRE>
2304+ *
2305+ * If the number specified is larger than the number of rows, the cursor
2306+ * will move to the position after the last row. If the number specified
2307+ * would move the cursor one or more rows before the first row, the cursor
2308+ * moves to the position before the first row.
2309+ * <P>
2310+ * Note: Calling <code>absolute(1)</code> is the same as calling the
2311+ * method <code>first()</code>. Calling <code>absolute(-1)</code> is the
2312+ * same as calling <code>last()</code>.
2313+ *
2314+ * @param row a positive number to indicate the row, starting row numbering from
2315+ * the first row, which is <code>1</code>; a negative number to indicate
2316+ * the row, starting row numbering from the last row, which is
2317+ * <code>-1</code>; it must not be <code>0</code>
2318+ * @return <code>true</code> if the cursor is on the rowset; <code>false</code>
2319+ * otherwise
2320+ * @throws SQLException if the given cursor position is <code>0</code> or the
2321+ * type of this rowset is <code>ResultSet.TYPE_FORWARD_ONLY</code>
2322+ */
2323+ public boolean absolute( int row ) throws SQLException {
2324+ throw new UnsupportedOperationException();
2325+ }
2326+
2327+ /**
2328+ * Moves the cursor the specified number of rows from the current
2329+ * position, with a positive number moving it forward and a
2330+ * negative number moving it backward.
2331+ * <P>
2332+ * If the number is positive, the cursor moves the specified number of
2333+ * rows toward the end of the rowset, starting at the current row.
2334+ * For example, the following command, in which
2335+ * <code>crs</code> is a <code>CachedRowSetImpl</code> object with 100 rows,
2336+ * moves the cursor forward four rows from the current row. If the
2337+ * current row is 50, the cursor would move to row 54.
2338+ * <PRE><code>
2339+ *
2340+ * crs.relative(4);
2341+ *
2342+ * </code> </PRE>
2343+ * <P>
2344+ * If the number is negative, the cursor moves back toward the beginning
2345+ * the specified number of rows, starting at the current row.
2346+ * For example, calling the method
2347+ * <code>absolute(-1)</code> positions the cursor on the last row,
2348+ * <code>absolute(-2)</code> moves it on the next-to-last row, and so on.
2349+ * If the <code>CachedRowSetImpl</code> object <code>crs</code> has five rows,
2350+ * the following command moves the cursor to the fourth-to-last row, which
2351+ * in the case of a rowset with five rows, is also the second row
2352+ * from the beginning.
2353+ * <PRE><code>
2354+ *
2355+ * crs.absolute(-4);
2356+ *
2357+ * </code> </PRE>
2358+ *
2359+ * If the number specified is larger than the number of rows, the cursor
2360+ * will move to the position after the last row. If the number specified
2361+ * would move the cursor one or more rows before the first row, the cursor
2362+ * moves to the position before the first row. In both cases, this method
2363+ * throws an <code>SQLException</code>.
2364+ * <P>
2365+ * Note: Calling <code>absolute(1)</code> is the same as calling the
2366+ * method <code>first()</code>. Calling <code>absolute(-1)</code> is the
2367+ * same as calling <code>last()</code>. Calling <code>relative(0)</code>
2368+ * is valid, but it does not change the cursor position.
2369+ *
2370+ * @param rows an <code>int</code> indicating the number of rows to move
2371+ * the cursor, starting at the current row; a positive number
2372+ * moves the cursor forward; a negative number moves the cursor
2373+ * backward; must not move the cursor past the valid
2374+ * rows
2375+ * @return <code>true</code> if the cursor is on a row in this
2376+ * <code>CachedRowSetImpl</code> object; <code>false</code>
2377+ * otherwise
2378+ * @throws SQLException if there are no rows in this rowset, the cursor is
2379+ * positioned either before the first row or after the last row, or
2380+ * the rowset is type <code>ResultSet.TYPE_FORWARD_ONLY</code>
2381+ */
2382+ public boolean relative(int rows) throws SQLException {
2383+ throw new UnsupportedOperationException();
2384+ }
2385+
2386+ /**
2387+ * Moves this <code>CachedRowSetImpl</code> object's cursor to the
2388+ * previous row and returns <code>true</code> if the cursor is on
2389+ * a valid row or <code>false</code> if it is not.
2390+ * This method also notifies all listeners registered with this
2391+ * <code>CachedRowSetImpl</code> object that its cursor has moved.
2392+ * <P>
2393+ * Note: calling the method <code>previous()</code> is not the same
2394+ * as calling the method <code>relative(-1)</code>. This is true
2395+ * because it is possible to call <code>previous()</code> from the insert
2396+ * row, from after the last row, or from the current row, whereas
2397+ * <code>relative</code> may only be called from the current row.
2398+ * <P>
2399+ * The method <code>previous</code> may used in a <code>while</code>
2400+ * loop to iterate through a rowset starting after the last row
2401+ * and moving toward the beginning. The loop ends when <code>previous</code>
2402+ * returns <code>false</code>, meaning that there are no more rows.
2403+ * For example, the following code fragment retrieves all the data in
2404+ * the <code>CachedRowSetImpl</code> object <code>crs</code>, which has
2405+ * three columns. Note that the cursor must initially be positioned
2406+ * after the last row so that the first call to the method
2407+ * <code>previous</code> places the cursor on the last line.
2408+ * <PRE> <code>
2409+ *
2410+ * crs.afterLast();
2411+ * while (previous()) {
2412+ * String name = crs.getString(1);
2413+ * int age = crs.getInt(2);
2414+ * short ssn = crs.getShort(3);
2415+ * System.out.println(name + " " + age + " " + ssn);
2416+ * }
2417+ *
2418+ * </code> </PRE>
2419+ * This method throws an <code>SQLException</code> if the cursor is not
2420+ * on a row in the rowset, before the first row, or after the last row.
2421+ *
2422+ * @return <code>true</code> if the cursor is on a valid row;
2423+ * <code>false</code> if it is before the first row or after the
2424+ * last row
2425+ * @throws SQLException if the cursor is not on a valid position or the
2426+ * type of this rowset is <code>ResultSet.TYPE_FORWARD_ONLY</code>
2427+ */
2428+ public boolean previous() throws SQLException {
2429+ throw new UnsupportedOperationException();
2430+ }
2431+
2432+ /**
2433+ * Moves the cursor to the previous row in this <code>CachedRowSetImpl</code>
2434+ * object, skipping past deleted rows that are not visible; returns
2435+ * <code>true</code> if the cursor is on a row in this rowset and
2436+ * <code>false</code> when the cursor goes before the first row.
2437+ * <P>
2438+ * This method is called internally by the method <code>previous</code>.
2439+ * <P>
2440+ * This is a implementation only method and is not required as a standard
2441+ * implementation of the <code>CachedRowSet</code> interface.
2442+ *
2443+ * @return <code>true</code> if the cursor is on a row in this rowset;
2444+ * <code>false</code> when the cursor reaches the position before
2445+ * the first row
2446+ * @throws SQLException if an error occurs
2447+ */
2448+ protected boolean internalPrevious() throws SQLException {
2449+ throw new UnsupportedOperationException();
2450+ }
2451+
2452+
2453+ //---------------------------------------------------------------------
2454+ // Updates
2455+ //---------------------------------------------------------------------
2456+
2457+ /**
2458+ * Indicates whether the current row of this <code>CachedRowSetImpl</code>
2459+ * object has been updated. The value returned
2460+ * depends on whether this rowset can detect updates: <code>false</code>
2461+ * will always be returned if it does not detect updates.
2462+ *
2463+ * @return <code>true</code> if the row has been visibly updated
2464+ * by the owner or another and updates are detected;
2465+ * <code>false</code> otherwise
2466+ * @throws SQLException if the cursor is on the insert row or not
2467+ * not on a valid row
2468+ *
2469+ * @see DatabaseMetaData#updatesAreDetected
2470+ */
2471+ public boolean rowUpdated() throws SQLException {
2472+ throw new UnsupportedOperationException();
2473+ }
2474+
2475+ /**
2476+ * Indicates whether the designated column of the current row of
2477+ * this <code>CachedRowSetImpl</code> object has been updated. The
2478+ * value returned depends on whether this rowset can detcted updates:
2479+ * <code>false</code> will always be returned if it does not detect updates.
2480+ *
2481+ * @param idx the index identifier of the column that may be have been updated.
2482+ * @return <code>true</code> is the designated column has been updated
2483+ * and the rowset detects updates; <code>false</code> if the rowset has not
2484+ * been updated or the rowset does not detect updates
2485+ * @throws SQLException if the cursor is on the insert row or not
2486+ * on a valid row
2487+ * @see DatabaseMetaData#updatesAreDetected
2488+ */
2489+ public boolean columnUpdated(int idx) throws SQLException {
2490+ throw new UnsupportedOperationException();
2491+ }
2492+
2493+ /**
2494+ * Indicates whether the designated column of the current row of
2495+ * this <code>CachedRowSetImpl</code> object has been updated. The
2496+ * value returned depends on whether this rowset can detcted updates:
2497+ * <code>false</code> will always be returned if it does not detect updates.
2498+ *
2499+ * @param columnName the <code>String</code> column name column that may be have
2500+ * been updated.
2501+ * @return <code>true</code> is the designated column has been updated
2502+ * and the rowset detects updates; <code>false</code> if the rowset has not
2503+ * been updated or the rowset does not detect updates
2504+ * @throws SQLException if the cursor is on the insert row or not
2505+ * on a valid row
2506+ * @see DatabaseMetaData#updatesAreDetected
2507+ */
2508+ public boolean columnUpdated(String columnName) throws SQLException {
2509+ throw new UnsupportedOperationException();
2510+ }
2511+
2512+ /**
2513+ * Indicates whether the current row has been inserted. The value returned
2514+ * depends on whether or not the rowset can detect visible inserts.
2515+ *
2516+ * @return <code>true</code> if a row has been inserted and inserts are detected;
2517+ * <code>false</code> otherwise
2518+ * @throws SQLException if the cursor is on the insert row or not
2519+ * not on a valid row
2520+ *
2521+ * @see DatabaseMetaData#insertsAreDetected
2522+ */
2523+ public boolean rowInserted() throws SQLException {
2524+ throw new UnsupportedOperationException();
2525+ }
2526+
2527+ /**
2528+ * Indicates whether the current row has been deleted. A deleted row
2529+ * may leave a visible "hole" in a rowset. This method can be used to
2530+ * detect such holes if the rowset can detect deletions. This method
2531+ * will always return <code>false</code> if this rowset cannot detect
2532+ * deletions.
2533+ *
2534+ * @return <code>true</code> if (1)the current row is blank, indicating that
2535+ * the row has been deleted, and (2)deletions are detected;
2536+ * <code>false</code> otherwise
2537+ * @throws SQLException if the cursor is on a valid row in this rowset
2538+ * @see DatabaseMetaData#deletesAreDetected
2539+ */
2540+ public boolean rowDeleted() throws SQLException {
2541+ throw new UnsupportedOperationException();
2542+ }
2543+
2544+ /**
2545+ * Sets the designated nullable column in the current row or the
2546+ * insert row of this <code>CachedRowSetImpl</code> object with
2547+ * <code>null</code> value.
2548+ * <P>
2549+ * This method updates a column value in the current row or the insert
2550+ * row of this rowset; however, another method must be called to complete
2551+ * the update process. If the cursor is on a row in the rowset, the
2552+ * method {@link #updateRow} must be called to mark the row as updated
2553+ * and to notify listeners that the row has changed.
2554+ * If the cursor is on the insert row, the method {@link #insertRow}
2555+ * must be called to insert the new row into this rowset and to notify
2556+ * listeners that a row has changed.
2557+ * <P>
2558+ * In order to propagate updates in this rowset to the underlying
2559+ * data source, an application must call the method {@link #acceptChanges}
2560+ * after it calls either <code>updateRow</code> or <code>insertRow</code>.
2561+ *
2562+ * @param columnIndex the first column is <code>1</code>, the second
2563+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2564+ * and equal to or less than the number of columns in this rowset
2565+ * @throws SQLException if (1) the given column index is out of bounds,
2566+ * (2) the cursor is not on one of this rowset's rows or its
2567+ * insert row, or (3) this rowset is
2568+ * <code>ResultSet.CONCUR_READ_ONLY</code>
2569+ */
2570+ public void updateNull(int columnIndex) throws SQLException {
2571+ throw new UnsupportedOperationException();
2572+ }
2573+
2574+ /**
2575+ * Sets the designated column in either the current row or the insert
2576+ * row of this <code>CachedRowSetImpl</code> object with the given
2577+ * <code>boolean</code> value.
2578+ * <P>
2579+ * This method updates a column value in the current row or the insert
2580+ * row of this rowset, but it does not update the database.
2581+ * If the cursor is on a row in the rowset, the
2582+ * method {@link #updateRow} must be called to update the database.
2583+ * If the cursor is on the insert row, the method {@link #insertRow}
2584+ * must be called, which will insert the new row into both this rowset
2585+ * and the database. Both of these methods must be called before the
2586+ * cursor moves to another row.
2587+ *
2588+ * @param columnIndex the first column is <code>1</code>, the second
2589+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2590+ * and equal to or less than the number of columns in this rowset
2591+ * @param x the new column value
2592+ * @throws SQLException if (1) the given column index is out of bounds,
2593+ * (2) the cursor is not on one of this rowset's rows or its
2594+ * insert row, or (3) this rowset is
2595+ * <code>ResultSet.CONCUR_READ_ONLY</code>
2596+ */
2597+ public void updateBoolean(int columnIndex, boolean x) throws SQLException {
2598+ throw new UnsupportedOperationException();
2599+ }
2600+
2601+ /**
2602+ * Sets the designated column in either the current row or the insert
2603+ * row of this <code>CachedRowSetImpl</code> object with the given
2604+ * <code>byte</code> value.
2605+ * <P>
2606+ * This method updates a column value in the current row or the insert
2607+ * row of this rowset, but it does not update the database.
2608+ * If the cursor is on a row in the rowset, the
2609+ * method {@link #updateRow} must be called to update the database.
2610+ * If the cursor is on the insert row, the method {@link #insertRow}
2611+ * must be called, which will insert the new row into both this rowset
2612+ * and the database. Both of these methods must be called before the
2613+ * cursor moves to another row.
2614+ *
2615+ * @param columnIndex the first column is <code>1</code>, the second
2616+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2617+ * and equal to or less than the number of columns in this rowset
2618+ * @param x the new column value
2619+ * @throws SQLException if (1) the given column index is out of bounds,
2620+ * (2) the cursor is not on one of this rowset's rows or its
2621+ * insert row, or (3) this rowset is
2622+ * <code>ResultSet.CONCUR_READ_ONLY</code>
2623+ */
2624+ public void updateByte(int columnIndex, byte x) throws SQLException {
2625+ throw new UnsupportedOperationException();
2626+ }
2627+
2628+ /**
2629+ * Sets the designated column in either the current row or the insert
2630+ * row of this <code>CachedRowSetImpl</code> object with the given
2631+ * <code>short</code> value.
2632+ * <P>
2633+ * This method updates a column value in the current row or the insert
2634+ * row of this rowset, but it does not update the database.
2635+ * If the cursor is on a row in the rowset, the
2636+ * method {@link #updateRow} must be called to update the database.
2637+ * If the cursor is on the insert row, the method {@link #insertRow}
2638+ * must be called, which will insert the new row into both this rowset
2639+ * and the database. Both of these methods must be called before the
2640+ * cursor moves to another row.
2641+ *
2642+ * @param columnIndex the first column is <code>1</code>, the second
2643+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2644+ * and equal to or less than the number of columns in this rowset
2645+ * @param x the new column value
2646+ * @throws SQLException if (1) the given column index is out of bounds,
2647+ * (2) the cursor is not on one of this rowset's rows or its
2648+ * insert row, or (3) this rowset is
2649+ * <code>ResultSet.CONCUR_READ_ONLY</code>
2650+ */
2651+ public void updateShort(int columnIndex, short x) throws SQLException {
2652+ throw new UnsupportedOperationException();
2653+ }
2654+
2655+ /**
2656+ * Sets the designated column in either the current row or the insert
2657+ * row of this <code>CachedRowSetImpl</code> object with the given
2658+ * <code>int</code> value.
2659+ * <P>
2660+ * This method updates a column value in the current row or the insert
2661+ * row of this rowset, but it does not update the database.
2662+ * If the cursor is on a row in the rowset, the
2663+ * method {@link #updateRow} must be called to update the database.
2664+ * If the cursor is on the insert row, the method {@link #insertRow}
2665+ * must be called, which will insert the new row into both this rowset
2666+ * and the database. Both of these methods must be called before the
2667+ * cursor moves to another row.
2668+ *
2669+ * @param columnIndex the first column is <code>1</code>, the second
2670+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2671+ * and equal to or less than the number of columns in this rowset
2672+ * @param x the new column value
2673+ * @throws SQLException if (1) the given column index is out of bounds,
2674+ * (2) the cursor is not on one of this rowset's rows or its
2675+ * insert row, or (3) this rowset is
2676+ * <code>ResultSet.CONCUR_READ_ONLY</code>
2677+ */
2678+ public void updateInt(int columnIndex, int x) throws SQLException {
2679+ throw new UnsupportedOperationException();
2680+ }
2681+
2682+ /**
2683+ * Sets the designated column in either the current row or the insert
2684+ * row of this <code>CachedRowSetImpl</code> object with the given
2685+ * <code>long</code> value.
2686+ * <P>
2687+ * This method updates a column value in the current row or the insert
2688+ * row of this rowset, but it does not update the database.
2689+ * If the cursor is on a row in the rowset, the
2690+ * method {@link #updateRow} must be called to update the database.
2691+ * If the cursor is on the insert row, the method {@link #insertRow}
2692+ * must be called, which will insert the new row into both this rowset
2693+ * and the database. Both of these methods must be called before the
2694+ * cursor moves to another row.
2695+ *
2696+ * @param columnIndex the first column is <code>1</code>, the second
2697+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2698+ * and equal to or less than the number of columns in this rowset
2699+ * @param x the new column value
2700+ * @throws SQLException if (1) the given column index is out of bounds,
2701+ * (2) the cursor is not on one of this rowset's rows or its
2702+ * insert row, or (3) this rowset is
2703+ * <code>ResultSet.CONCUR_READ_ONLY</code>
2704+ */
2705+ public void updateLong(int columnIndex, long x) throws SQLException {
2706+ throw new UnsupportedOperationException();
2707+
2708+ }
2709+
2710+ /**
2711+ * Sets the designated column in either the current row or the insert
2712+ * row of this <code>CachedRowSetImpl</code> object with the given
2713+ * <code>float</code> value.
2714+ * <P>
2715+ * This method updates a column value in the current row or the insert
2716+ * row of this rowset, but it does not update the database.
2717+ * If the cursor is on a row in the rowset, the
2718+ * method {@link #updateRow} must be called to update the database.
2719+ * If the cursor is on the insert row, the method {@link #insertRow}
2720+ * must be called, which will insert the new row into both this rowset
2721+ * and the database. Both of these methods must be called before the
2722+ * cursor moves to another row.
2723+ *
2724+ * @param columnIndex the first column is <code>1</code>, the second
2725+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2726+ * and equal to or less than the number of columns in this rowset
2727+ * @param x the new column value
2728+ * @throws SQLException if (1) the given column index is out of bounds,
2729+ * (2) the cursor is not on one of this rowset's rows or its
2730+ * insert row, or (3) this rowset is
2731+ * <code>ResultSet.CONCUR_READ_ONLY</code>
2732+ */
2733+ public void updateFloat(int columnIndex, float x) throws SQLException {
2734+ throw new UnsupportedOperationException();
2735+ }
2736+
2737+ /**
2738+ * Sets the designated column in either the current row or the insert
2739+ * row of this <code>CachedRowSetImpl</code> object with the given
2740+ * <code>double</code> value.
2741+ *
2742+ * This method updates a column value in either the current row or
2743+ * the insert row of this rowset, but it does not update the
2744+ * database. If the cursor is on a row in the rowset, the
2745+ * method {@link #updateRow} must be called to update the database.
2746+ * If the cursor is on the insert row, the method {@link #insertRow}
2747+ * must be called, which will insert the new row into both this rowset
2748+ * and the database. Both of these methods must be called before the
2749+ * cursor moves to another row.
2750+ *
2751+ * @param columnIndex the first column is <code>1</code>, the second
2752+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2753+ * and equal to or less than the number of columns in this rowset
2754+ * @param x the new column value
2755+ * @throws SQLException if (1) the given column index is out of bounds,
2756+ * (2) the cursor is not on one of this rowset's rows or its
2757+ * insert row, or (3) this rowset is
2758+ * <code>ResultSet.CONCUR_READ_ONLY</code>
2759+ */
2760+ public void updateDouble(int columnIndex, double x) throws SQLException {
2761+ throw new UnsupportedOperationException();
2762+ }
2763+
2764+ /**
2765+ * Sets the designated column in either the current row or the insert
2766+ * row of this <code>CachedRowSetImpl</code> object with the given
2767+ * <code>java.math.BigDecimal</code> object.
2768+ * <P>
2769+ * This method updates a column value in the current row or the insert
2770+ * row of this rowset, but it does not update the database.
2771+ * If the cursor is on a row in the rowset, the
2772+ * method {@link #updateRow} must be called to update the database.
2773+ * If the cursor is on the insert row, the method {@link #insertRow}
2774+ * must be called, which will insert the new row into both this rowset
2775+ * and the database. Both of these methods must be called before the
2776+ * cursor moves to another row.
2777+ *
2778+ * @param columnIndex the first column is <code>1</code>, the second
2779+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2780+ * and equal to or less than the number of columns in this rowset
2781+ * @param x the new column value
2782+ * @throws SQLException if (1) the given column index is out of bounds,
2783+ * (2) the cursor is not on one of this rowset's rows or its
2784+ * insert row, or (3) this rowset is
2785+ * <code>ResultSet.CONCUR_READ_ONLY</code>
2786+ */
2787+ public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
2788+ throw new UnsupportedOperationException();
2789+ }
2790+
2791+ /**
2792+ * Sets the designated column in either the current row or the insert
2793+ * row of this <code>CachedRowSetImpl</code> object with the given
2794+ * <code>String</code> object.
2795+ * <P>
2796+ * This method updates a column value in either the current row or
2797+ * the insert row of this rowset, but it does not update the
2798+ * database. If the cursor is on a row in the rowset, the
2799+ * method {@link #updateRow} must be called to mark the row as updated.
2800+ * If the cursor is on the insert row, the method {@link #insertRow}
2801+ * must be called to insert the new row into this rowset and mark it
2802+ * as inserted. Both of these methods must be called before the
2803+ * cursor moves to another row.
2804+ * <P>
2805+ * The method <code>acceptChanges</code> must be called if the
2806+ * updated values are to be written back to the underlying database.
2807+ *
2808+ * @param columnIndex the first column is <code>1</code>, the second
2809+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2810+ * and equal to or less than the number of columns in this rowset
2811+ * @param x the new column value
2812+ * @throws SQLException if (1) the given column index is out of bounds,
2813+ * (2) the cursor is not on one of this rowset's rows or its
2814+ * insert row, or (3) this rowset is
2815+ * <code>ResultSet.CONCUR_READ_ONLY</code>
2816+ */
2817+ public void updateString(int columnIndex, String x) throws SQLException {
2818+ throw new UnsupportedOperationException();
2819+ }
2820+
2821+ /**
2822+ * Sets the designated column in either the current row or the insert
2823+ * row of this <code>CachedRowSetImpl</code> object with the given
2824+ * <code>byte</code> array.
2825+ *
2826+ * This method updates a column value in either the current row or
2827+ * the insert row of this rowset, but it does not update the
2828+ * database. If the cursor is on a row in the rowset, the
2829+ * method {@link #updateRow} must be called to update the database.
2830+ * If the cursor is on the insert row, the method {@link #insertRow}
2831+ * must be called, which will insert the new row into both this rowset
2832+ * and the database. Both of these methods must be called before the
2833+ * cursor moves to another row.
2834+ *
2835+ * @param columnIndex the first column is <code>1</code>, the second
2836+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2837+ * and equal to or less than the number of columns in this rowset
2838+ * @param x the new column value
2839+ * @throws SQLException if (1) the given column index is out of bounds,
2840+ * (2) the cursor is not on one of this rowset's rows or its
2841+ * insert row, or (3) this rowset is
2842+ * <code>ResultSet.CONCUR_READ_ONLY</code>
2843+ */
2844+ public void updateBytes(int columnIndex, byte x[]) throws SQLException {
2845+ throw new UnsupportedOperationException();
2846+ }
2847+
2848+ /**
2849+ * Sets the designated column in either the current row or the insert
2850+ * row of this <code>CachedRowSetImpl</code> object with the given
2851+ * <code>Date</code> object.
2852+ *
2853+ * This method updates a column value in either the current row or
2854+ * the insert row of this rowset, but it does not update the
2855+ * database. If the cursor is on a row in the rowset, the
2856+ * method {@link #updateRow} must be called to update the database.
2857+ * If the cursor is on the insert row, the method {@link #insertRow}
2858+ * must be called, which will insert the new row into both this rowset
2859+ * and the database. Both of these methods must be called before the
2860+ * cursor moves to another row.
2861+ *
2862+ * @param columnIndex the first column is <code>1</code>, the second
2863+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2864+ * and equal to or less than the number of columns in this rowset
2865+ * @param x the new column value
2866+ * @throws SQLException if (1) the given column index is out of bounds,
2867+ * (2) the cursor is not on one of this rowset's rows or its
2868+ * insert row, (3) the type of the designated column is not
2869+ * an SQL <code>DATE</code> or <code>TIMESTAMP</code>, or
2870+ * (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
2871+ */
2872+ public void updateDate(int columnIndex, java.sql.Date x) throws SQLException {
2873+ throw new UnsupportedOperationException();
2874+ }
2875+
2876+ /**
2877+ * Sets the designated column in either the current row or the insert
2878+ * row of this <code>CachedRowSetImpl</code> object with the given
2879+ * <code>Time</code> object.
2880+ *
2881+ * This method updates a column value in either the current row or
2882+ * the insert row of this rowset, but it does not update the
2883+ * database. If the cursor is on a row in the rowset, the
2884+ * method {@link #updateRow} must be called to update the database.
2885+ * If the cursor is on the insert row, the method {@link #insertRow}
2886+ * must be called, which will insert the new row into both this rowset
2887+ * and the database. Both of these methods must be called before the
2888+ * cursor moves to another row.
2889+ *
2890+ * @param columnIndex the first column is <code>1</code>, the second
2891+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2892+ * and equal to or less than the number of columns in this rowset
2893+ * @param x the new column value
2894+ * @throws SQLException if (1) the given column index is out of bounds,
2895+ * (2) the cursor is not on one of this rowset's rows or its
2896+ * insert row, (3) the type of the designated column is not
2897+ * an SQL <code>TIME</code> or <code>TIMESTAMP</code>, or
2898+ * (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
2899+ */
2900+ public void updateTime(int columnIndex, java.sql.Time x) throws SQLException {
2901+ throw new UnsupportedOperationException();
2902+ }
2903+
2904+ /**
2905+ * Sets the designated column in either the current row or the insert
2906+ * row of this <code>CachedRowSetImpl</code> object with the given
2907+ * <code>Timestamp</code> object.
2908+ *
2909+ * This method updates a column value in either the current row or
2910+ * the insert row of this rowset, but it does not update the
2911+ * database. If the cursor is on a row in the rowset, the
2912+ * method {@link #updateRow} must be called to update the database.
2913+ * If the cursor is on the insert row, the method {@link #insertRow}
2914+ * must be called, which will insert the new row into both this rowset
2915+ * and the database. Both of these methods must be called before the
2916+ * cursor moves to another row.
2917+ *
2918+ * @param columnIndex the first column is <code>1</code>, the second
2919+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2920+ * and equal to or less than the number of columns in this rowset
2921+ * @param x the new column value
2922+ * @throws SQLException if (1) the given column index is out of bounds,
2923+ * (2) the cursor is not on one of this rowset's rows or its
2924+ * insert row, (3) the type of the designated column is not
2925+ * an SQL <code>DATE</code>, <code>TIME</code>, or
2926+ * <code>TIMESTAMP</code>, or (4) this rowset is
2927+ * <code>ResultSet.CONCUR_READ_ONLY</code>
2928+ */
2929+ public void updateTimestamp(int columnIndex, java.sql.Timestamp x) throws SQLException {
2930+ throw new UnsupportedOperationException();
2931+ }
2932+
2933+ /**
2934+ * Sets the designated column in either the current row or the insert
2935+ * row of this <code>CachedRowSetImpl</code> object with the given
2936+ * ASCII stream value.
2937+ * <P>
2938+ * This method updates a column value in either the current row or
2939+ * the insert row of this rowset, but it does not update the
2940+ * database. If the cursor is on a row in the rowset, the
2941+ * method {@link #updateRow} must be called to update the database.
2942+ * If the cursor is on the insert row, the method {@link #insertRow}
2943+ * must be called, which will insert the new row into both this rowset
2944+ * and the database. Both of these methods must be called before the
2945+ * cursor moves to another row.
2946+ *
2947+ * @param columnIndex the first column is <code>1</code>, the second
2948+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2949+ * and equal to or less than the number of columns in this rowset
2950+ * @param x the new column value
2951+ * @param length the number of one-byte ASCII characters in the stream
2952+ * @throws SQLException if this method is invoked
2953+ */
2954+ public void updateAsciiStream(int columnIndex, java.io.InputStream x, int length) throws SQLException {
2955+ throw new UnsupportedOperationException();
2956+ }
2957+
2958+ /**
2959+ * Sets the designated column in either the current row or the insert
2960+ * row of this <code>CachedRowSetImpl</code> object with the given
2961+ * <code>java.io.InputStream</code> object.
2962+ * <P>
2963+ * This method updates a column value in either the current row or
2964+ * the insert row of this rowset, but it does not update the
2965+ * database. If the cursor is on a row in the rowset, the
2966+ * method {@link #updateRow} must be called to update the database.
2967+ * If the cursor is on the insert row, the method {@link #insertRow}
2968+ * must be called, which will insert the new row into both this rowset
2969+ * and the database. Both of these methods must be called before the
2970+ * cursor moves to another row.
2971+ *
2972+ * @param columnIndex the first column is <code>1</code>, the second
2973+ * is <code>2</code>, and so on; must be <code>1</code> or larger
2974+ * and equal to or less than the number of columns in this rowset
2975+ * @param x the new column value; must be a <code>java.io.InputStream</code>
2976+ * containing <code>BINARY</code>, <code>VARBINARY</code>, or
2977+ * <code>LONGVARBINARY</code> data
2978+ * @param length the length of the stream in bytes
2979+ * @throws SQLException if (1) the given column index is out of bounds,
2980+ * (2) the cursor is not on one of this rowset's rows or its
2981+ * insert row, (3) the data in the stream is not binary, or
2982+ * (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
2983+ */
2984+ public void updateBinaryStream(int columnIndex, java.io.InputStream x,int length) throws SQLException {
2985+ throw new UnsupportedOperationException();
2986+ }
2987+
2988+ /**
2989+ * Sets the designated column in either the current row or the insert
2990+ * row of this <code>CachedRowSetImpl</code> object with the given
2991+ * <code>java.io.Reader</code> object.
2992+ * <P>
2993+ * This method updates a column value in either the current row or
2994+ * the insert row of this rowset, but it does not update the
2995+ * database. If the cursor is on a row in the rowset, the
2996+ * method {@link #updateRow} must be called to update the database.
2997+ * If the cursor is on the insert row, the method {@link #insertRow}
2998+ * must be called, which will insert the new row into both this rowset
2999+ * and the database. Both of these methods must be called before the
3000+ * cursor moves to another row.
3001+ *
3002+ * @param columnIndex the first column is <code>1</code>, the second
3003+ * is <code>2</code>, and so on; must be <code>1</code> or larger
3004+ * and equal to or less than the number of columns in this rowset
3005+ * @param x the new column value; must be a <code>java.io.Reader</code>
3006+ * containing <code>BINARY</code>, <code>VARBINARY</code>,
3007+ * <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>,
3008+ * or <code>LONGVARCHAR</code> data
3009+ * @param length the length of the stream in characters
3010+ * @throws SQLException if (1) the given column index is out of bounds,
3011+ * (2) the cursor is not on one of this rowset's rows or its
3012+ * insert row, (3) the data in the stream is not a binary or
3013+ * character type, or (4) this rowset is
3014+ * <code>ResultSet.CONCUR_READ_ONLY</code>
3015+ */
3016+ public void updateCharacterStream(int columnIndex, java.io.Reader x, int length) throws SQLException {
3017+ throw new UnsupportedOperationException();
3018+ }
3019+
3020+ /**
3021+ * Sets the designated column in either the current row or the insert
3022+ * row of this <code>CachedRowSetImpl</code> object with the given
3023+ * <code>Object</code> value. The <code>scale</code> parameter indicates
3024+ * the number of digits to the right of the decimal point and is ignored
3025+ * if the new column value is not a type that will be mapped to an SQL
3026+ * <code>DECIMAL</code> or <code>NUMERIC</code> value.
3027+ * <P>
3028+ * This method updates a column value in either the current row or
3029+ * the insert row of this rowset, but it does not update the
3030+ * database. If the cursor is on a row in the rowset, the
3031+ * method {@link #updateRow} must be called to update the database.
3032+ * If the cursor is on the insert row, the method {@link #insertRow}
3033+ * must be called, which will insert the new row into both this rowset
3034+ * and the database. Both of these methods must be called before the
3035+ * cursor moves to another row.
3036+ *
3037+ * @param columnIndex the first column is <code>1</code>, the second
3038+ * is <code>2</code>, and so on; must be <code>1</code> or larger
3039+ * and equal to or less than the number of columns in this rowset
3040+ * @param x the new column value
3041+ * @param scale the number of digits to the right of the decimal point (for
3042+ * <code>DECIMAL</code> and <code>NUMERIC</code> types only)
3043+ * @throws SQLException if (1) the given column index is out of bounds,
3044+ * (2) the cursor is not on one of this rowset's rows or its
3045+ * insert row, or (3) this rowset is
3046+ * <code>ResultSet.CONCUR_READ_ONLY</code>
3047+ */
3048+ public void updateObject(int columnIndex, Object x, int scale) throws SQLException {
3049+ throw new UnsupportedOperationException();
3050+ }
3051+
3052+ /**
3053+ * Sets the designated column in either the current row or the insert
3054+ * row of this <code>CachedRowSetImpl</code> object with the given
3055+ * <code>Object</code> value.
3056+ * <P>
3057+ * This method updates a column value in either the current row or
3058+ * the insert row of this rowset, but it does not update the
3059+ * database. If the cursor is on a row in the rowset, the
3060+ * method {@link #updateRow} must be called to update the database.
3061+ * If the cursor is on the insert row, the method {@link #insertRow}
3062+ * must be called, which will insert the new row into both this rowset
3063+ * and the database. Both of these methods must be called before the
3064+ * cursor moves to another row.
3065+ *
3066+ * @param columnIndex the first column is <code>1</code>, the second
3067+ * is <code>2</code>, and so on; must be <code>1</code> or larger
3068+ * and equal to or less than the number of columns in this rowset
3069+ * @param x the new column value
3070+ * @throws SQLException if (1) the given column index is out of bounds,
3071+ * (2) the cursor is not on one of this rowset's rows or its
3072+ * insert row, or (3) this rowset is
3073+ * <code>ResultSet.CONCUR_READ_ONLY</code>
3074+ */
3075+ public void updateObject(int columnIndex, Object x) throws SQLException {
3076+ throw new UnsupportedOperationException();
3077+ }
3078+
3079+
3080+ /**
3081+ * Sets the designated nullable column in the current row or the
3082+ * insert row of this <code>CachedRowSetImpl</code> object with
3083+ * <code>null</code> value.
3084+ * <P>
3085+ * This method updates a column value in the current row or the insert
3086+ * row of this rowset, but it does not update the database.
3087+ * If the cursor is on a row in the rowset, the
3088+ * method {@link #updateRow} must be called to update the database.
3089+ * If the cursor is on the insert row, the method {@link #insertRow}
3090+ * must be called, which will insert the new row into both this rowset
3091+ * and the database.
3092+ *
3093+ * @param columnName a <code>String</code> object that must match the
3094+ * SQL name of a column in this rowset, ignoring case
3095+ * @throws SQLException if (1) the given column name does not match the
3096+ * name of a column in this rowset, (2) the cursor is not on
3097+ * one of this rowset's rows or its insert row, or (3) this
3098+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3099+ */
3100+ public void updateNull(String columnName) throws SQLException {
3101+ throw new UnsupportedOperationException();
3102+ }
3103+
3104+ /**
3105+ * Sets the designated column in either the current row or the insert
3106+ * row of this <code>CachedRowSetImpl</code> object with the given
3107+ * <code>boolean</code> value.
3108+ * <P>
3109+ * This method updates a column value in the current row or the insert
3110+ * row of this rowset, but it does not update the database.
3111+ * If the cursor is on a row in the rowset, the
3112+ * method {@link #updateRow} must be called to update the database.
3113+ * If the cursor is on the insert row, the method {@link #insertRow}
3114+ * must be called, which will insert the new row into both this rowset
3115+ * and the database. Both of these methods must be called before the
3116+ * cursor moves to another row.
3117+ *
3118+ * @param columnName a <code>String</code> object that must match the
3119+ * SQL name of a column in this rowset, ignoring case
3120+ * @param x the new column value
3121+ * @throws SQLException if (1) the given column name does not match the
3122+ * name of a column in this rowset, (2) the cursor is not on
3123+ * one of this rowset's rows or its insert row, or (3) this
3124+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3125+ */
3126+ public void updateBoolean(String columnName, boolean x) throws SQLException {
3127+ throw new UnsupportedOperationException();
3128+ }
3129+
3130+ /**
3131+ * Sets the designated column in either the current row or the insert
3132+ * row of this <code>CachedRowSetImpl</code> object with the given
3133+ * <code>byte</code> value.
3134+ * <P>
3135+ * This method updates a column value in the current row or the insert
3136+ * row of this rowset, but it does not update the database.
3137+ * If the cursor is on a row in the rowset, the
3138+ * method {@link #updateRow} must be called to update the database.
3139+ * If the cursor is on the insert row, the method {@link #insertRow}
3140+ * must be called, which will insert the new row into both this rowset
3141+ * and the database. Both of these methods must be called before the
3142+ * cursor moves to another row.
3143+ *
3144+ * @param columnName a <code>String</code> object that must match the
3145+ * SQL name of a column in this rowset, ignoring case
3146+ * @param x the new column value
3147+ * @throws SQLException if (1) the given column name does not match the
3148+ * name of a column in this rowset, (2) the cursor is not on
3149+ * one of this rowset's rows or its insert row, or (3) this
3150+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3151+ */
3152+ public void updateByte(String columnName, byte x) throws SQLException {
3153+ throw new UnsupportedOperationException();
3154+ }
3155+
3156+ /**
3157+ * Sets the designated column in either the current row or the insert
3158+ * row of this <code>CachedRowSetImpl</code> object with the given
3159+ * <code>short</code> value.
3160+ * <P>
3161+ * This method updates a column value in the current row or the insert
3162+ * row of this rowset, but it does not update the database.
3163+ * If the cursor is on a row in the rowset, the
3164+ * method {@link #updateRow} must be called to update the database.
3165+ * If the cursor is on the insert row, the method {@link #insertRow}
3166+ * must be called, which will insert the new row into both this rowset
3167+ * and the database. Both of these methods must be called before the
3168+ * cursor moves to another row.
3169+ *
3170+ * @param columnName a <code>String</code> object that must match the
3171+ * SQL name of a column in this rowset, ignoring case
3172+ * @param x the new column value
3173+ * @throws SQLException if (1) the given column name does not match the
3174+ * name of a column in this rowset, (2) the cursor is not on
3175+ * one of this rowset's rows or its insert row, or (3) this
3176+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3177+ */
3178+ public void updateShort(String columnName, short x) throws SQLException {
3179+ throw new UnsupportedOperationException();
3180+ }
3181+
3182+ /**
3183+ * Sets the designated column in either the current row or the insert
3184+ * row of this <code>CachedRowSetImpl</code> object with the given
3185+ * <code>int</code> value.
3186+ * <P>
3187+ * This method updates a column value in the current row or the insert
3188+ * row of this rowset, but it does not update the database.
3189+ * If the cursor is on a row in the rowset, the
3190+ * method {@link #updateRow} must be called to update the database.
3191+ * If the cursor is on the insert row, the method {@link #insertRow}
3192+ * must be called, which will insert the new row into both this rowset
3193+ * and the database. Both of these methods must be called before the
3194+ * cursor moves to another row.
3195+ *
3196+ * @param columnName a <code>String</code> object that must match the
3197+ * SQL name of a column in this rowset, ignoring case
3198+ * @param x the new column value
3199+ * @throws SQLException if (1) the given column name does not match the
3200+ * name of a column in this rowset, (2) the cursor is not on
3201+ * one of this rowset's rows or its insert row, or (3) this
3202+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3203+ */
3204+ public void updateInt(String columnName, int x) throws SQLException {
3205+ throw new UnsupportedOperationException();
3206+ }
3207+
3208+ /**
3209+ * Sets the designated column in either the current row or the insert
3210+ * row of this <code>CachedRowSetImpl</code> object with the given
3211+ * <code>long</code> value.
3212+ * <P>
3213+ * This method updates a column value in the current row or the insert
3214+ * row of this rowset, but it does not update the database.
3215+ * If the cursor is on a row in the rowset, the
3216+ * method {@link #updateRow} must be called to update the database.
3217+ * If the cursor is on the insert row, the method {@link #insertRow}
3218+ * must be called, which will insert the new row into both this rowset
3219+ * and the database. Both of these methods must be called before the
3220+ * cursor moves to another row.
3221+ *
3222+ * @param columnName a <code>String</code> object that must match the
3223+ * SQL name of a column in this rowset, ignoring case
3224+ * @param x the new column value
3225+ * @throws SQLException if (1) the given column name does not match the
3226+ * name of a column in this rowset, (2) the cursor is not on
3227+ * one of this rowset's rows or its insert row, or (3) this
3228+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3229+ */
3230+ public void updateLong(String columnName, long x) throws SQLException {
3231+ throw new UnsupportedOperationException();
3232+ }
3233+
3234+ /**
3235+ * Sets the designated column in either the current row or the insert
3236+ * row of this <code>CachedRowSetImpl</code> object with the given
3237+ * <code>float</code> value.
3238+ * <P>
3239+ * This method updates a column value in the current row or the insert
3240+ * row of this rowset, but it does not update the database.
3241+ * If the cursor is on a row in the rowset, the
3242+ * method {@link #updateRow} must be called to update the database.
3243+ * If the cursor is on the insert row, the method {@link #insertRow}
3244+ * must be called, which will insert the new row into both this rowset
3245+ * and the database. Both of these methods must be called before the
3246+ * cursor moves to another row.
3247+ *
3248+ * @param columnName a <code>String</code> object that must match the
3249+ * SQL name of a column in this rowset, ignoring case
3250+ * @param x the new column value
3251+ * @throws SQLException if (1) the given column name does not match the
3252+ * name of a column in this rowset, (2) the cursor is not on
3253+ * one of this rowset's rows or its insert row, or (3) this
3254+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3255+ */
3256+ public void updateFloat(String columnName, float x) throws SQLException {
3257+ throw new UnsupportedOperationException();
3258+ }
3259+
3260+ /**
3261+ * Sets the designated column in either the current row or the insert
3262+ * row of this <code>CachedRowSetImpl</code> object with the given
3263+ * <code>double</code> value.
3264+ *
3265+ * This method updates a column value in either the current row or
3266+ * the insert row of this rowset, but it does not update the
3267+ * database. If the cursor is on a row in the rowset, the
3268+ * method {@link #updateRow} must be called to update the database.
3269+ * If the cursor is on the insert row, the method {@link #insertRow}
3270+ * must be called, which will insert the new row into both this rowset
3271+ * and the database. Both of these methods must be called before the
3272+ * cursor moves to another row.
3273+ *
3274+ * @param columnName a <code>String</code> object that must match the
3275+ * SQL name of a column in this rowset, ignoring case
3276+ * @param x the new column value
3277+ * @throws SQLException if (1) the given column name does not match the
3278+ * name of a column in this rowset, (2) the cursor is not on
3279+ * one of this rowset's rows or its insert row, or (3) this
3280+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3281+ */
3282+ public void updateDouble(String columnName, double x) throws SQLException {
3283+ throw new UnsupportedOperationException();
3284+ }
3285+
3286+ /**
3287+ * Sets the designated column in either the current row or the insert
3288+ * row of this <code>CachedRowSetImpl</code> object with the given
3289+ * <code>java.math.BigDecimal</code> object.
3290+ * <P>
3291+ * This method updates a column value in the current row or the insert
3292+ * row of this rowset, but it does not update the database.
3293+ * If the cursor is on a row in the rowset, the
3294+ * method {@link #updateRow} must be called to update the database.
3295+ * If the cursor is on the insert row, the method {@link #insertRow}
3296+ * must be called, which will insert the new row into both this rowset
3297+ * and the database. Both of these methods must be called before the
3298+ * cursor moves to another row.
3299+ *
3300+ * @param columnName a <code>String</code> object that must match the
3301+ * SQL name of a column in this rowset, ignoring case
3302+ * @param x the new column value
3303+ * @throws SQLException if (1) the given column name does not match the
3304+ * name of a column in this rowset, (2) the cursor is not on
3305+ * one of this rowset's rows or its insert row, or (3) this
3306+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3307+ */
3308+ public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException {
3309+ throw new UnsupportedOperationException();
3310+ }
3311+
3312+ /**
3313+ * Sets the designated column in either the current row or the insert
3314+ * row of this <code>CachedRowSetImpl</code> object with the given
3315+ * <code>String</code> object.
3316+ *
3317+ * This method updates a column value in either the current row or
3318+ * the insert row of this rowset, but it does not update the
3319+ * database. If the cursor is on a row in the rowset, the
3320+ * method {@link #updateRow} must be called to update the database.
3321+ * If the cursor is on the insert row, the method {@link #insertRow}
3322+ * must be called, which will insert the new row into both this rowset
3323+ * and the database. Both of these methods must be called before the
3324+ * cursor moves to another row.
3325+ *
3326+ * @param columnName a <code>String</code> object that must match the
3327+ * SQL name of a column in this rowset, ignoring case
3328+ * @param x the new column value
3329+ * @throws SQLException if (1) the given column name does not match the
3330+ * name of a column in this rowset, (2) the cursor is not on
3331+ * one of this rowset's rows or its insert row, or (3) this
3332+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3333+ */
3334+ public void updateString(String columnName, String x) throws SQLException {
3335+ throw new UnsupportedOperationException();
3336+ }
3337+
3338+ /**
3339+ * Sets the designated column in either the current row or the insert
3340+ * row of this <code>CachedRowSetImpl</code> object with the given
3341+ * <code>byte</code> array.
3342+ *
3343+ * This method updates a column value in either the current row or
3344+ * the insert row of this rowset, but it does not update the
3345+ * database. If the cursor is on a row in the rowset, the
3346+ * method {@link #updateRow} must be called to update the database.
3347+ * If the cursor is on the insert row, the method {@link #insertRow}
3348+ * must be called, which will insert the new row into both this rowset
3349+ * and the database. Both of these methods must be called before the
3350+ * cursor moves to another row.
3351+ *
3352+ * @param columnName a <code>String</code> object that must match the
3353+ * SQL name of a column in this rowset, ignoring case
3354+ * @param x the new column value
3355+ * @throws SQLException if (1) the given column name does not match the
3356+ * name of a column in this rowset, (2) the cursor is not on
3357+ * one of this rowset's rows or its insert row, or (3) this
3358+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3359+ */
3360+ public void updateBytes(String columnName, byte x[]) throws SQLException {
3361+ throw new UnsupportedOperationException();
3362+ }
3363+
3364+ /**
3365+ * Sets the designated column in either the current row or the insert
3366+ * row of this <code>CachedRowSetImpl</code> object with the given
3367+ * <code>Date</code> object.
3368+ *
3369+ * This method updates a column value in either the current row or
3370+ * the insert row of this rowset, but it does not update the
3371+ * database. If the cursor is on a row in the rowset, the
3372+ * method {@link #updateRow} must be called to update the database.
3373+ * If the cursor is on the insert row, the method {@link #insertRow}
3374+ * must be called, which will insert the new row into both this rowset
3375+ * and the database. Both of these methods must be called before the
3376+ * cursor moves to another row.
3377+ *
3378+ * @param columnName a <code>String</code> object that must match the
3379+ * SQL name of a column in this rowset, ignoring case
3380+ * @param x the new column value
3381+ * @throws SQLException if (1) the given column name does not match the
3382+ * name of a column in this rowset, (2) the cursor is not on
3383+ * one of this rowset's rows or its insert row, (3) the type
3384+ * of the designated column is not an SQL <code>DATE</code> or
3385+ * <code>TIMESTAMP</code>, or (4) this rowset is
3386+ * <code>ResultSet.CONCUR_READ_ONLY</code>
3387+ */
3388+ public void updateDate(String columnName, java.sql.Date x) throws SQLException {
3389+ throw new UnsupportedOperationException();
3390+ }
3391+
3392+ /**
3393+ * Sets the designated column in either the current row or the insert
3394+ * row of this <code>CachedRowSetImpl</code> object with the given
3395+ * <code>Time</code> object.
3396+ *
3397+ * This method updates a column value in either the current row or
3398+ * the insert row of this rowset, but it does not update the
3399+ * database. If the cursor is on a row in the rowset, the
3400+ * method {@link #updateRow} must be called to update the database.
3401+ * If the cursor is on the insert row, the method {@link #insertRow}
3402+ * must be called, which will insert the new row into both this rowset
3403+ * and the database. Both of these methods must be called before the
3404+ * cursor moves to another row.
3405+ *
3406+ * @param columnName a <code>String</code> object that must match the
3407+ * SQL name of a column in this rowset, ignoring case
3408+ * @param x the new column value
3409+ * @throws SQLException if (1) the given column name does not match the
3410+ * name of a column in this rowset, (2) the cursor is not on
3411+ * one of this rowset's rows or its insert row, (3) the type
3412+ * of the designated column is not an SQL <code>TIME</code> or
3413+ * <code>TIMESTAMP</code>, or (4) this rowset is
3414+ * <code>ResultSet.CONCUR_READ_ONLY</code>
3415+ */
3416+ public void updateTime(String columnName, java.sql.Time x) throws SQLException {
3417+ throw new UnsupportedOperationException();
3418+ }
3419+
3420+ /**
3421+ * Sets the designated column in either the current row or the insert
3422+ * row of this <code>CachedRowSetImpl</code> object with the given
3423+ * <code>Timestamp</code> object.
3424+ *
3425+ * This method updates a column value in either the current row or
3426+ * the insert row of this rowset, but it does not update the
3427+ * database. If the cursor is on a row in the rowset, the
3428+ * method {@link #updateRow} must be called to update the database.
3429+ * If the cursor is on the insert row, the method {@link #insertRow}
3430+ * must be called, which will insert the new row into both this rowset
3431+ * and the database. Both of these methods must be called before the
3432+ * cursor moves to another row.
3433+ *
3434+ * @param columnName a <code>String</code> object that must match the
3435+ * SQL name of a column in this rowset, ignoring case
3436+ * @param x the new column value
3437+ * @throws SQLException if the given column index is out of bounds or
3438+ * the cursor is not on one of this rowset's rows or its
3439+ * insert row
3440+ * @throws SQLException if (1) the given column name does not match the
3441+ * name of a column in this rowset, (2) the cursor is not on
3442+ * one of this rowset's rows or its insert row, (3) the type
3443+ * of the designated column is not an SQL <code>DATE</code>,
3444+ * <code>TIME</code>, or <code>TIMESTAMP</code>, or (4) this
3445+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3446+ */
3447+ public void updateTimestamp(String columnName, java.sql.Timestamp x) throws SQLException {
3448+ throw new UnsupportedOperationException();
3449+ }
3450+
3451+ /**
3452+ * Sets the designated column in either the current row or the insert
3453+ * row of this <code>CachedRowSetImpl</code> object with the given
3454+ * ASCII stream value.
3455+ * <P>
3456+ * This method updates a column value in either the current row or
3457+ * the insert row of this rowset, but it does not update the
3458+ * database. If the cursor is on a row in the rowset, the
3459+ * method {@link #updateRow} must be called to update the database.
3460+ * If the cursor is on the insert row, the method {@link #insertRow}
3461+ * must be called, which will insert the new row into both this rowset
3462+ * and the database. Both of these methods must be called before the
3463+ * cursor moves to another row.
3464+ *
3465+ * @param columnName a <code>String</code> object that must match the
3466+ * SQL name of a column in this rowset, ignoring case
3467+ * @param x the new column value
3468+ * @param length the number of one-byte ASCII characters in the stream
3469+ */
3470+ public void updateAsciiStream(String columnName,
3471+ java.io.InputStream x,
3472+ int length) throws SQLException {
3473+ throw new UnsupportedOperationException();
3474+ }
3475+
3476+ /**
3477+ * Sets the designated column in either the current row or the insert
3478+ * row of this <code>CachedRowSetImpl</code> object with the given
3479+ * <code>java.io.InputStream</code> object.
3480+ * <P>
3481+ * This method updates a column value in either the current row or
3482+ * the insert row of this rowset, but it does not update the
3483+ * database. If the cursor is on a row in the rowset, the
3484+ * method {@link #updateRow} must be called to update the database.
3485+ * If the cursor is on the insert row, the method {@link #insertRow}
3486+ * must be called, which will insert the new row into both this rowset
3487+ * and the database. Both of these methods must be called before the
3488+ * cursor moves to another row.
3489+ *
3490+ * @param columnName a <code>String</code> object that must match the
3491+ * SQL name of a column in this rowset, ignoring case
3492+ * @param x the new column value; must be a <code>java.io.InputStream</code>
3493+ * containing <code>BINARY</code>, <code>VARBINARY</code>, or
3494+ * <code>LONGVARBINARY</code> data
3495+ * @param length the length of the stream in bytes
3496+ * @throws SQLException if (1) the given column name does not match the
3497+ * name of a column in this rowset, (2) the cursor is not on
3498+ * one of this rowset's rows or its insert row, (3) the data
3499+ * in the stream is not binary, or (4) this rowset is
3500+ * <code>ResultSet.CONCUR_READ_ONLY</code>
3501+ */
3502+ public void updateBinaryStream(String columnName, java.io.InputStream x, int length) throws SQLException {
3503+ throw new UnsupportedOperationException();
3504+ }
3505+
3506+ /**
3507+ * Sets the designated column in either the current row or the insert
3508+ * row of this <code>CachedRowSetImpl</code> object with the given
3509+ * <code>java.io.Reader</code> object.
3510+ * <P>
3511+ * This method updates a column value in either the current row or
3512+ * the insert row of this rowset, but it does not update the
3513+ * database. If the cursor is on a row in the rowset, the
3514+ * method {@link #updateRow} must be called to update the database.
3515+ * If the cursor is on the insert row, the method {@link #insertRow}
3516+ * must be called, which will insert the new row into both this rowset
3517+ * and the database. Both of these methods must be called before the
3518+ * cursor moves to another row.
3519+ *
3520+ * @param columnName a <code>String</code> object that must match the
3521+ * SQL name of a column in this rowset, ignoring case
3522+ * @param reader the new column value; must be a
3523+ * <code>java.io.Reader</code> containing <code>BINARY</code>,
3524+ * <code>VARBINARY</code>, <code>LONGVARBINARY</code>, <code>CHAR</code>,
3525+ * <code>VARCHAR</code>, or <code>LONGVARCHAR</code> data
3526+ * @param length the length of the stream in characters
3527+ * @throws SQLException if (1) the given column name does not match the
3528+ * name of a column in this rowset, (2) the cursor is not on
3529+ * one of this rowset's rows or its insert row, (3) the data
3530+ * in the stream is not a binary or character type, or (4) this
3531+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3532+ */
3533+ public void updateCharacterStream(String columnName,
3534+ java.io.Reader reader,
3535+ int length) throws SQLException {
3536+ throw new UnsupportedOperationException();
3537+ }
3538+
3539+ /**
3540+ * Sets the designated column in either the current row or the insert
3541+ * row of this <code>CachedRowSetImpl</code> object with the given
3542+ * <code>Object</code> value. The <code>scale</code> parameter
3543+ * indicates the number of digits to the right of the decimal point
3544+ * and is ignored if the new column value is not a type that will be
3545+ * mapped to an SQL <code>DECIMAL</code> or <code>NUMERIC</code> value.
3546+ * <P>
3547+ * This method updates a column value in either the current row or
3548+ * the insert row of this rowset, but it does not update the
3549+ * database. If the cursor is on a row in the rowset, the
3550+ * method {@link #updateRow} must be called to update the database.
3551+ * If the cursor is on the insert row, the method {@link #insertRow}
3552+ * must be called, which will insert the new row into both this rowset
3553+ * and the database. Both of these methods must be called before the
3554+ * cursor moves to another row.
3555+ *
3556+ * @param columnName a <code>String</code> object that must match the
3557+ * SQL name of a column in this rowset, ignoring case
3558+ * @param x the new column value
3559+ * @param scale the number of digits to the right of the decimal point (for
3560+ * <code>DECIMAL</code> and <code>NUMERIC</code> types only)
3561+ * @throws SQLException if (1) the given column name does not match the
3562+ * name of a column in this rowset, (2) the cursor is not on
3563+ * one of this rowset's rows or its insert row, or (3) this
3564+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3565+ */
3566+ public void updateObject(String columnName, Object x, int scale) throws SQLException {
3567+ throw new UnsupportedOperationException();
3568+ }
3569+
3570+ /**
3571+ * Sets the designated column in either the current row or the insert
3572+ * row of this <code>CachedRowSetImpl</code> object with the given
3573+ * <code>Object</code> value.
3574+ * <P>
3575+ * This method updates a column value in either the current row or
3576+ * the insert row of this rowset, but it does not update the
3577+ * database. If the cursor is on a row in the rowset, the
3578+ * method {@link #updateRow} must be called to update the database.
3579+ * If the cursor is on the insert row, the method {@link #insertRow}
3580+ * must be called, which will insert the new row into both this rowset
3581+ * and the database. Both of these methods must be called before the
3582+ * cursor moves to another row.
3583+ *
3584+ * @param columnName a <code>String</code> object that must match the
3585+ * SQL name of a column in this rowset, ignoring case
3586+ * @param x the new column value
3587+ * @throws SQLException if (1) the given column name does not match the
3588+ * name of a column in this rowset, (2) the cursor is not on
3589+ * one of this rowset's rows or its insert row, or (3) this
3590+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3591+ */
3592+ public void updateObject(String columnName, Object x) throws SQLException {
3593+ throw new UnsupportedOperationException();
3594+ }
3595+
3596+ /**
3597+ * Inserts the contents of this <code>CachedRowSetImpl</code> object's insert
3598+ * row into this rowset immediately following the current row.
3599+ * If the current row is the
3600+ * position after the last row or before the first row, the new row will
3601+ * be inserted at the end of the rowset. This method also notifies
3602+ * listeners registered with this rowset that the row has changed.
3603+ * <P>
3604+ * The cursor must be on the insert row when this method is called.
3605+ *
3606+ * @throws SQLException if (1) the cursor is not on the insert row,
3607+ * (2) one or more of the non-nullable columns in the insert
3608+ * row has not been given a value, or (3) this rowset is
3609+ * <code>ResultSet.CONCUR_READ_ONLY</code>
3610+ */
3611+ public void insertRow() throws SQLException {
3612+ throw new UnsupportedOperationException();
3613+ }
3614+
3615+ /**
3616+ * Marks the current row of this <code>CachedRowSetImpl</code> object as
3617+ * updated and notifies listeners registered with this rowset that the
3618+ * row has changed.
3619+ * <P>
3620+ * This method cannot be called when the cursor is on the insert row, and
3621+ * it should be called before the cursor moves to another row. If it is
3622+ * called after the cursor moves to another row, this method has no effect,
3623+ * and the updates made before the cursor moved will be lost.
3624+ *
3625+ * @throws SQLException if the cursor is on the insert row or this
3626+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3627+ */
3628+ public void updateRow() throws SQLException {
3629+ throw new UnsupportedOperationException();
3630+ }
3631+
3632+ /**
3633+ * Deletes the current row from this <code>CachedRowSetImpl</code> object and
3634+ * notifies listeners registered with this rowset that a row has changed.
3635+ * This method cannot be called when the cursor is on the insert row.
3636+ * <P>
3637+ * This method marks the current row as deleted, but it does not delete
3638+ * the row from the underlying data source. The method
3639+ * <code>acceptChanges</code> must be called to delete the row in
3640+ * the data source.
3641+ *
3642+ * @throws SQLException if (1) this method is called when the cursor
3643+ * is on the insert row, before the first row, or after the
3644+ * last row or (2) this rowset is
3645+ * <code>ResultSet.CONCUR_READ_ONLY</code>
3646+ */
3647+ public void deleteRow() throws SQLException {
3648+ throw new UnsupportedOperationException();
3649+ }
3650+
3651+ /**
3652+ * Sets the current row with its original value and marks the row as
3653+ * not updated, thus undoing any changes made to the row since the
3654+ * last call to the methods <code>updateRow</code> or <code>deleteRow</code>.
3655+ * This method should be called only when the cursor is on a row in
3656+ * this rowset.
3657+ *
3658+ * @throws SQLException if the cursor is on the insert row, before the
3659+ * first row, or after the last row
3660+ */
3661+ public void refreshRow() throws SQLException {
3662+ throw new UnsupportedOperationException();
3663+ }
3664+
3665+ /**
3666+ * Rolls back any updates made to the current row of this
3667+ * <code>CachedRowSetImpl</code> object and notifies listeners that
3668+ * a row has changed. To have an effect, this method
3669+ * must be called after an <code>updateXXX</code> method has been
3670+ * called and before the method <code>updateRow</code> has been called.
3671+ * If no updates have been made or the method <code>updateRow</code>
3672+ * has already been called, this method has no effect.
3673+ *
3674+ * @throws SQLException if the cursor is on the insert row, before the
3675+ * first row, or after the last row
3676+ */
3677+ public void cancelRowUpdates() throws SQLException {
3678+ throw new UnsupportedOperationException();
3679+ }
3680+
3681+ /**
3682+ * Moves the cursor for this <code>CachedRowSetImpl</code> object
3683+ * to the insert row. The current row in the rowset is remembered
3684+ * while the cursor is on the insert row.
3685+ * <P>
3686+ * The insert row is a special row associated with an updatable
3687+ * rowset. It is essentially a buffer where a new row may
3688+ * be constructed by calling the appropriate <code>updateXXX</code>
3689+ * methods to assign a value to each column in the row. A complete
3690+ * row must be constructed; that is, every column that is not nullable
3691+ * must be assigned a value. In order for the new row to become part
3692+ * of this rowset, the method <code>insertRow</code> must be called
3693+ * before the cursor is moved back to the rowset.
3694+ * <P>
3695+ * Only certain methods may be invoked while the cursor is on the insert
3696+ * row; many methods throw an exception if they are called while the
3697+ * cursor is there. In addition to the <code>updateXXX</code>
3698+ * and <code>insertRow</code> methods, only the <code>getXXX</code> methods
3699+ * may be called when the cursor is on the insert row. A <code>getXXX</code>
3700+ * method should be called on a column only after an <code>updateXXX</code>
3701+ * method has been called on that column; otherwise, the value returned is
3702+ * undetermined.
3703+ *
3704+ * @throws SQLException if this <code>CachedRowSetImpl</code> object is
3705+ * <code>ResultSet.CONCUR_READ_ONLY</code>
3706+ */
3707+ public void moveToInsertRow() throws SQLException {
3708+ throw new UnsupportedOperationException();
3709+ }
3710+
3711+ /**
3712+ * Moves the cursor for this <code>CachedRowSetImpl</code> object to
3713+ * the current row. The current row is the row the cursor was on
3714+ * when the method <code>moveToInsertRow</code> was called.
3715+ * <P>
3716+ * Calling this method has no effect unless it is called while the
3717+ * cursor is on the insert row.
3718+ *
3719+ * @throws SQLException if an error occurs
3720+ */
3721+ public void moveToCurrentRow() throws SQLException {
3722+ throw new UnsupportedOperationException();
3723+ }
3724+
3725+ /**
3726+ * Returns <code>null</code>.
3727+ *
3728+ * @return <code>null</code>
3729+ * @throws SQLException if an error occurs
3730+ */
3731+ public Statement getStatement() throws SQLException {
3732+ throw new UnsupportedOperationException();
3733+ }
3734+
3735+ /**
3736+ * Retrieves the value of the designated column in this
3737+ * <code>CachedRowSetImpl</code> object as an <code>Object</code> in
3738+ * the Java programming language, using the given
3739+ * <code>java.util.Map</code> object to custom map the value if
3740+ * appropriate.
3741+ *
3742+ * @param columnIndex the first column is <code>1</code>, the second
3743+ * is <code>2</code>, and so on; must be <code>1</code> or larger
3744+ * and equal to or less than the number of columns in this rowset
3745+ * @param map a <code>java.util.Map</code> object showing the mapping
3746+ * from SQL type names to classes in the Java programming
3747+ * language
3748+ * @return an <code>Object</code> representing the SQL value
3749+ * @throws SQLException if the given column index is out of bounds or
3750+ * the cursor is not on one of this rowset's rows or its
3751+ * insert row
3752+ */
3753+ public Object getObject(int columnIndex,
3754+ java.util.Map<String,Class<?>> map)
3755+ throws SQLException
3756+ {
3757+ throw new UnsupportedOperationException();
3758+ }
3759+
3760+ /**
3761+ * Retrieves the value of the designated column in this
3762+ * <code>CachedRowSetImpl</code> object as a <code>Ref</code> object
3763+ * in the Java programming language.
3764+ *
3765+ * @param columnIndex the first column is <code>1</code>, the second
3766+ * is <code>2</code>, and so on; must be <code>1</code> or larger
3767+ * and equal to or less than the number of columns in this rowset
3768+ * @return a <code>Ref</code> object representing an SQL<code> REF</code> value
3769+ * @throws SQLException if (1) the given column index is out of bounds,
3770+ * (2) the cursor is not on one of this rowset's rows or its
3771+ * insert row, or (3) the designated column does not store an
3772+ * SQL <code>REF</code> value
3773+ * @see #getRef(String)
3774+ */
3775+ public Ref getRef(int columnIndex) throws SQLException {
3776+ throw new UnsupportedOperationException();
3777+ }
3778+
3779+ /**
3780+ * Retrieves the value of the designated column in this
3781+ * <code>CachedRowSetImpl</code> object as a <code>Blob</code> object
3782+ * in the Java programming language.
3783+ *
3784+ * @param columnIndex the first column is <code>1</code>, the second
3785+ * is <code>2</code>, and so on; must be <code>1</code> or larger
3786+ * and equal to or less than the number of columns in this rowset
3787+ * @return a <code>Blob</code> object representing an SQL <code>BLOB</code> value
3788+ * @throws SQLException if (1) the given column index is out of bounds,
3789+ * (2) the cursor is not on one of this rowset's rows or its
3790+ * insert row, or (3) the designated column does not store an
3791+ * SQL <code>BLOB</code> value
3792+ * @see #getBlob(String)
3793+ */
3794+ public Blob getBlob(int columnIndex) throws SQLException {
3795+ throw new UnsupportedOperationException();
3796+ }
3797+
3798+ /**
3799+ * Retrieves the value of the designated column in this
3800+ * <code>CachedRowSetImpl</code> object as a <code>Clob</code> object
3801+ * in the Java programming language.
3802+ *
3803+ * @param columnIndex the first column is <code>1</code>, the second
3804+ * is <code>2</code>, and so on; must be <code>1</code> or larger
3805+ * and equal to or less than the number of columns in this rowset
3806+ * @return a <code>Clob</code> object representing an SQL <code>CLOB</code> value
3807+ * @throws SQLException if (1) the given column index is out of bounds,
3808+ * (2) the cursor is not on one of this rowset's rows or its
3809+ * insert row, or (3) the designated column does not store an
3810+ * SQL <code>CLOB</code> value
3811+ * @see #getClob(String)
3812+ */
3813+ public Clob getClob(int columnIndex) throws SQLException {
3814+ throw new UnsupportedOperationException();
3815+ }
3816+
3817+ /**
3818+ * Retrieves the value of the designated column in this
3819+ * <code>CachedRowSetImpl</code> object as an <code>Array</code> object
3820+ * in the Java programming language.
3821+ *
3822+ * @param columnIndex the first column is <code>1</code>, the second
3823+ * is <code>2</code>, and so on; must be <code>1</code> or larger
3824+ * and equal to or less than the number of columns in this rowset
3825+ * @return an <code>Array</code> object representing an SQL
3826+ * <code>ARRAY</code> value
3827+ * @throws SQLException if (1) the given column index is out of bounds,
3828+ * (2) the cursor is not on one of this rowset's rows or its
3829+ * insert row, or (3) the designated column does not store an
3830+ * SQL <code>ARRAY</code> value
3831+ * @see #getArray(String)
3832+ */
3833+ public Array getArray(int columnIndex) throws SQLException {
3834+ throw new UnsupportedOperationException();
3835+ }
3836+
3837+ /**
3838+ * Retrieves the value of the designated column in this
3839+ * <code>CachedRowSetImpl</code> object as an <code>Object</code> in
3840+ * the Java programming language, using the given
3841+ * <code>java.util.Map</code> object to custom map the value if
3842+ * appropriate.
3843+ *
3844+ * @param columnName a <code>String</code> object that must match the
3845+ * SQL name of a column in this rowset, ignoring case
3846+ * @param map a <code>java.util.Map</code> object showing the mapping
3847+ * from SQL type names to classes in the Java programming
3848+ * language
3849+ * @return an <code>Object</code> representing the SQL value
3850+ * @throws SQLException if the given column name is not the name of
3851+ * a column in this rowset or the cursor is not on one of
3852+ * this rowset's rows or its insert row
3853+ */
3854+ public Object getObject(String columnName,
3855+ java.util.Map<String,Class<?>> map)
3856+ throws SQLException {
3857+ throw new UnsupportedOperationException();
3858+ }
3859+
3860+ /**
3861+ * Retrieves the value of the designated column in this
3862+ * <code>CachedRowSetImpl</code> object as a <code>Ref</code> object
3863+ * in the Java programming language.
3864+ *
3865+ * @param colName a <code>String</code> object that must match the
3866+ * SQL name of a column in this rowset, ignoring case
3867+ * @return a <code>Ref</code> object representing an SQL<code> REF</code> value
3868+ * @throws SQLException if (1) the given column name is not the name of
3869+ * a column in this rowset, (2) the cursor is not on one of
3870+ * this rowset's rows or its insert row, or (3) the column value
3871+ * is not an SQL <code>REF</code> value
3872+ * @see #getRef(int)
3873+ */
3874+ public Ref getRef(String colName) throws SQLException {
3875+ throw new UnsupportedOperationException();
3876+ }
3877+
3878+ /**
3879+ * Retrieves the value of the designated column in this
3880+ * <code>CachedRowSetImpl</code> object as a <code>Blob</code> object
3881+ * in the Java programming language.
3882+ *
3883+ * @param colName a <code>String</code> object that must match the
3884+ * SQL name of a column in this rowset, ignoring case
3885+ * @return a <code>Blob</code> object representing an SQL <code>BLOB</code> value
3886+ * @throws SQLException if (1) the given column name is not the name of
3887+ * a column in this rowset, (2) the cursor is not on one of
3888+ * this rowset's rows or its insert row, or (3) the designated
3889+ * column does not store an SQL <code>BLOB</code> value
3890+ * @see #getBlob(int)
3891+ */
3892+ public Blob getBlob(String colName) throws SQLException {
3893+ throw new UnsupportedOperationException();
3894+ }
3895+
3896+ /**
3897+ * Retrieves the value of the designated column in this
3898+ * <code>CachedRowSetImpl</code> object as a <code>Clob</code> object
3899+ * in the Java programming language.
3900+ *
3901+ * @param colName a <code>String</code> object that must match the
3902+ * SQL name of a column in this rowset, ignoring case
3903+ * @return a <code>Clob</code> object representing an SQL
3904+ * <code>CLOB</code> value
3905+ * @throws SQLException if (1) the given column name is not the name of
3906+ * a column in this rowset, (2) the cursor is not on one of
3907+ * this rowset's rows or its insert row, or (3) the designated
3908+ * column does not store an SQL <code>CLOB</code> value
3909+ * @see #getClob(int)
3910+ */
3911+ public Clob getClob(String colName) throws SQLException {
3912+ throw new UnsupportedOperationException();
3913+ }
3914+
3915+ /**
3916+ * Retrieves the value of the designated column in this
3917+ * <code>CachedRowSetImpl</code> object as an <code>Array</code> object
3918+ * in the Java programming langugage.
3919+ *
3920+ * @param colName a <code>String</code> object that must match the
3921+ * SQL name of a column in this rowset, ignoring case
3922+ * @return an <code>Array</code> object representing an SQL
3923+ * <code>ARRAY</code> value
3924+ * @throws SQLException if (1) the given column name is not the name of
3925+ * a column in this rowset, (2) the cursor is not on one of
3926+ * this rowset's rows or its insert row, or (3) the designated
3927+ * column does not store an SQL <code>ARRAY</code> value
3928+ * @see #getArray(int)
3929+ */
3930+ public Array getArray(String colName) throws SQLException {
3931+ throw new UnsupportedOperationException();
3932+ }
3933+
3934+ /**
3935+ * Retrieves the value of the designated column in the current row
3936+ * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Date</code>
3937+ * object, using the given <code>Calendar</code> object to construct an
3938+ * appropriate millisecond value for the date.
3939+ *
3940+ * @param columnIndex the first column is <code>1</code>, the second
3941+ * is <code>2</code>, and so on; must be <code>1</code> or larger
3942+ * and equal to or less than the number of columns in the rowset
3943+ * @param cal the <code>java.util.Calendar</code> object to use in
3944+ * constructing the date
3945+ * @return the column value; if the value is SQL <code>NULL</code>,
3946+ * the result is <code>null</code>
3947+ * @throws SQLException if (1) the given column name is not the name of
3948+ * a column in this rowset, (2) the cursor is not on one of
3949+ * this rowset's rows or its insert row, or (3) the designated
3950+ * column does not store an SQL <code>DATE</code> or
3951+ * <code>TIMESTAMP</code> value
3952+ */
3953+ public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLException {
3954+ throw new UnsupportedOperationException();
3955+ }
3956+
3957+ /**
3958+ * Retrieves the value of the designated column in the current row
3959+ * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Date</code>
3960+ * object, using the given <code>Calendar</code> object to construct an
3961+ * appropriate millisecond value for the date.
3962+ *
3963+ * @param columnName a <code>String</code> object that must match the
3964+ * SQL name of a column in this rowset, ignoring case
3965+ * @param cal the <code>java.util.Calendar</code> object to use in
3966+ * constructing the date
3967+ * @return the column value; if the value is SQL <code>NULL</code>,
3968+ * the result is <code>null</code>
3969+ * @throws SQLException if (1) the given column name is not the name of
3970+ * a column in this rowset, (2) the cursor is not on one of
3971+ * this rowset's rows or its insert row, or (3) the designated
3972+ * column does not store an SQL <code>DATE</code> or
3973+ * <code>TIMESTAMP</code> value
3974+ */
3975+ public java.sql.Date getDate(String columnName, Calendar cal) throws SQLException {
3976+ throw new UnsupportedOperationException();
3977+ }
3978+
3979+ /**
3980+ * Retrieves the value of the designated column in the current row
3981+ * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Time</code>
3982+ * object, using the given <code>Calendar</code> object to construct an
3983+ * appropriate millisecond value for the date.
3984+ *
3985+ * @param columnIndex the first column is <code>1</code>, the second
3986+ * is <code>2</code>, and so on; must be <code>1</code> or larger
3987+ * and equal to or less than the number of columns in the rowset
3988+ * @param cal the <code>java.util.Calendar</code> object to use in
3989+ * constructing the date
3990+ * @return the column value; if the value is SQL <code>NULL</code>,
3991+ * the result is <code>null</code>
3992+ * @throws SQLException if (1) the given column name is not the name of
3993+ * a column in this rowset, (2) the cursor is not on one of
3994+ * this rowset's rows or its insert row, or (3) the designated
3995+ * column does not store an SQL <code>TIME</code> or
3996+ * <code>TIMESTAMP</code> value
3997+ */
3998+ public java.sql.Time getTime(int columnIndex, Calendar cal) throws SQLException {
3999+ throw new UnsupportedOperationException();
4000+ }
4001+
4002+ /**
4003+ * Retrieves the value of the designated column in the current row
4004+ * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Time</code>
4005+ * object, using the given <code>Calendar</code> object to construct an
4006+ * appropriate millisecond value for the date.
4007+ *
4008+ * @param columnName a <code>String</code> object that must match the
4009+ * SQL name of a column in this rowset, ignoring case
4010+ * @param cal the <code>java.util.Calendar</code> object to use in
4011+ * constructing the date
4012+ * @return the column value; if the value is SQL <code>NULL</code>,
4013+ * the result is <code>null</code>
4014+ * @throws SQLException if (1) the given column name is not the name of
4015+ * a column in this rowset, (2) the cursor is not on one of
4016+ * this rowset's rows or its insert row, or (3) the designated
4017+ * column does not store an SQL <code>TIME</code> or
4018+ * <code>TIMESTAMP</code> value
4019+ */
4020+ public java.sql.Time getTime(String columnName, Calendar cal) throws SQLException {
4021+ throw new UnsupportedOperationException();
4022+ }
4023+
4024+ /**
4025+ * Retrieves the value of the designated column in the current row
4026+ * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Timestamp</code>
4027+ * object, using the given <code>Calendar</code> object to construct an
4028+ * appropriate millisecond value for the date.
4029+ *
4030+ * @param columnIndex the first column is <code>1</code>, the second
4031+ * is <code>2</code>, and so on; must be <code>1</code> or larger
4032+ * and equal to or less than the number of columns in the rowset
4033+ * @param cal the <code>java.util.Calendar</code> object to use in
4034+ * constructing the date
4035+ * @return the column value; if the value is SQL <code>NULL</code>,
4036+ * the result is <code>null</code>
4037+ * @throws SQLException if (1) the given column name is not the name of
4038+ * a column in this rowset, (2) the cursor is not on one of
4039+ * this rowset's rows or its insert row, or (3) the designated
4040+ * column does not store an SQL <code>TIME</code> or
4041+ * <code>TIMESTAMP</code> value
4042+ */
4043+ public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
4044+ throw new UnsupportedOperationException();
4045+ }
4046+
4047+ /**
4048+ * Retrieves the value of the designated column in the current row
4049+ * of this <code>CachedRowSetImpl</code> object as a
4050+ * <code>java.sql.Timestamp</code> object, using the given
4051+ * <code>Calendar</code> object to construct an appropriate
4052+ * millisecond value for the date.
4053+ *
4054+ * @param columnName a <code>String</code> object that must match the
4055+ * SQL name of a column in this rowset, ignoring case
4056+ * @param cal the <code>java.util.Calendar</code> object to use in
4057+ * constructing the date
4058+ * @return the column value; if the value is SQL <code>NULL</code>,
4059+ * the result is <code>null</code>
4060+ * @throws SQLException if (1) the given column name is not the name of
4061+ * a column in this rowset, (2) the cursor is not on one of
4062+ * this rowset's rows or its insert row, or (3) the designated
4063+ * column does not store an SQL <code>DATE</code>,
4064+ * <code>TIME</code>, or <code>TIMESTAMP</code> value
4065+ */
4066+ public java.sql.Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException {
4067+ throw new UnsupportedOperationException();
4068+ }
4069+
4070+ /*
4071+ * RowSetInternal Interface
4072+ */
4073+
4074+ /**
4075+ * Retrieves the <code>Connection</code> object passed to this
4076+ * <code>CachedRowSetImpl</code> object. This connection may be
4077+ * used to populate this rowset with data or to write data back
4078+ * to its underlying data source.
4079+ *
4080+ * @return the <code>Connection</code> object passed to this rowset;
4081+ * may be <code>null</code> if there is no connection
4082+ * @throws SQLException if an error occurs
4083+ */
4084+ public Connection getConnection() throws SQLException{
4085+ throw new UnsupportedOperationException();
4086+ }
4087+
4088+ /**
4089+ * Sets the metadata for this <code>CachedRowSetImpl</code> object
4090+ * with the given <code>RowSetMetaData</code> object.
4091+ *
4092+ * @param md a <code>RowSetMetaData</code> object instance containing
4093+ * metadata about the columsn in the rowset
4094+ * @throws SQLException if invalid meta data is supplied to the
4095+ * rowset
4096+ */
4097+ public void setMetaData(RowSetMetaData md) throws SQLException {
4098+ throw new UnsupportedOperationException();
4099+ }
4100+
4101+ /**
4102+ * Returns a result set containing the original value of the rowset. The
4103+ * original value is the state of the <code>CachedRowSetImpl</code> after the
4104+ * last population or synchronization (whichever occured most recently) with
4105+ * the data source.
4106+ * <p>
4107+ * The cursor is positioned before the first row in the result set.
4108+ * Only rows contained in the result set returned by <code>getOriginal()</code>
4109+ * are said to have an original value.
4110+ *
4111+ * @return the original result set of the rowset
4112+ * @throws SQLException if an error occurs produce the
4113+ * <code>ResultSet</code> object
4114+ */
4115+ public ResultSet getOriginal() throws SQLException {
4116+ throw new UnsupportedOperationException();
4117+ }
4118+
4119+ /**
4120+ * Returns a result set containing the original value of the current
4121+ * row only.
4122+ * The original value is the state of the <code>CachedRowSetImpl</code> after
4123+ * the last population or synchronization (whichever occured most recently)
4124+ * with the data source.
4125+ *
4126+ * @return the original result set of the row
4127+ * @throws SQLException if there is no current row
4128+ * @see #setOriginalRow
4129+ */
4130+ public ResultSet getOriginalRow() throws SQLException {
4131+ throw new UnsupportedOperationException();
4132+
4133+ }
4134+
4135+ /**
4136+ * Marks the current row in this rowset as being an original row.
4137+ *
4138+ * @throws SQLException if there is no current row
4139+ * @see #getOriginalRow
4140+ */
4141+ public void setOriginalRow() throws SQLException {
4142+ throw new UnsupportedOperationException();
4143+ }
4144+
4145+ /**
4146+ * Marks all rows in this rowset as being original rows. Any updates
4147+ * made to the rows become the original values for the rowset.
4148+ * Calls to the method <code>setOriginal</code> connot be reversed.
4149+ *
4150+ * @throws SQLException if an error occurs
4151+ */
4152+ public void setOriginal() throws SQLException {
4153+ throw new UnsupportedOperationException();
4154+ }
4155+
4156+ /**
4157+ * Returns an identifier for the object (table) that was used to create this
4158+ * rowset.
4159+ *
4160+ * @return a <code>String</code> object that identifies the table from
4161+ * which this <code>CachedRowSetImpl</code> object was derived
4162+ * @throws SQLException if an error occurs
4163+ */
4164+ public String getTableName() throws SQLException {
4165+ throw new UnsupportedOperationException();
4166+ }
4167+
4168+ /**
4169+ * Sets the identifier for the table from which this rowset was derived
4170+ * to the given table name.
4171+ *
4172+ * @param tabName a <code>String</code> object that identifies the
4173+ * table from which this <code>CachedRowSetImpl</code> object
4174+ * was derived
4175+ * @throws SQLException if an error occurs
4176+ */
4177+ public void setTableName(String tabName) throws SQLException {
4178+ throw new UnsupportedOperationException();
4179+ }
4180+
4181+ /**
4182+ * Returns the columns that make a key to uniquely identify a
4183+ * row in this <code>CachedRowSetImpl</code> object.
4184+ *
4185+ * @return an array of column numbers that constitutes a primary
4186+ * key for this rowset. This array should be empty
4187+ * if no column is representitive of a primary key
4188+ * @throws SQLException if the rowset is empty or no columns
4189+ * are designated as primary keys
4190+ * @see #setKeyColumns
4191+ */
4192+ public int[] getKeyColumns() throws SQLException {
4193+ throw new UnsupportedOperationException();
4194+ }
4195+
4196+
4197+ /**
4198+ * Sets this <code>CachedRowSetImpl</code> object's
4199+ * <code>keyCols</code> field with the given array of column
4200+ * numbers, which forms a key for uniquely identifying a row
4201+ * in this rowset.
4202+ *
4203+ * @param keys an array of <code>int</code> indicating the
4204+ * columns that form a primary key for this
4205+ * <code>CachedRowSetImpl</code> object; every
4206+ * element in the array must be greater than
4207+ * <code>0</code> and less than or equal to the number
4208+ * of columns in this rowset
4209+ * @throws SQLException if any of the numbers in the
4210+ * given array is not valid for this rowset
4211+ * @see #getKeyColumns
4212+ */
4213+ public void setKeyColumns(int [] keys) throws SQLException {
4214+ throw new UnsupportedOperationException();
4215+ }
4216+
4217+ /**
4218+ * Sets the designated column in either the current row or the insert
4219+ * row of this <code>CachedRowSetImpl</code> object with the given
4220+ * <code>double</code> value.
4221+ *
4222+ * This method updates a column value in either the current row or
4223+ * the insert row of this rowset, but it does not update the
4224+ * database. If the cursor is on a row in the rowset, the
4225+ * method {@link #updateRow} must be called to update the database.
4226+ * If the cursor is on the insert row, the method {@link #insertRow}
4227+ * must be called, which will insert the new row into both this rowset
4228+ * and the database. Both of these methods must be called before the
4229+ * cursor moves to another row.
4230+ *
4231+ * @param columnIndex the first column is <code>1</code>, the second
4232+ * is <code>2</code>, and so on; must be <code>1</code> or larger
4233+ * and equal to or less than the number of columns in this rowset
4234+ * @param ref the new column <code>java.sql.Ref</code> value
4235+ * @throws SQLException if (1) the given column index is out of bounds,
4236+ * (2) the cursor is not on one of this rowset's rows or its
4237+ * insert row, or (3) this rowset is
4238+ * <code>ResultSet.CONCUR_READ_ONLY</code>
4239+ */
4240+ public void updateRef(int columnIndex, java.sql.Ref ref) throws SQLException {
4241+ throw new UnsupportedOperationException();
4242+ }
4243+
4244+ /**
4245+ * Sets the designated column in either the current row or the insert
4246+ * row of this <code>CachedRowSetImpl</code> object with the given
4247+ * <code>double</code> value.
4248+ *
4249+ * This method updates a column value in either the current row or
4250+ * the insert row of this rowset, but it does not update the
4251+ * database. If the cursor is on a row in the rowset, the
4252+ * method {@link #updateRow} must be called to update the database.
4253+ * If the cursor is on the insert row, the method {@link #insertRow}
4254+ * must be called, which will insert the new row into both this rowset
4255+ * and the database. Both of these methods must be called before the
4256+ * cursor moves to another row.
4257+ *
4258+ * @param columnName a <code>String</code> object that must match the
4259+ * SQL name of a column in this rowset, ignoring case
4260+ * @param ref the new column <code>java.sql.Ref</code> value
4261+ * @throws SQLException if (1) the given column name does not match the
4262+ * name of a column in this rowset, (2) the cursor is not on
4263+ * one of this rowset's rows or its insert row, or (3) this
4264+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4265+ */
4266+ public void updateRef(String columnName, java.sql.Ref ref) throws SQLException {
4267+ throw new UnsupportedOperationException();
4268+ }
4269+
4270+ /**
4271+ * Sets the designated column in either the current row or the insert
4272+ * row of this <code>CachedRowSetImpl</code> object with the given
4273+ * <code>double</code> value.
4274+ *
4275+ * This method updates a column value in either the current row or
4276+ * the insert row of this rowset, but it does not update the
4277+ * database. If the cursor is on a row in the rowset, the
4278+ * method {@link #updateRow} must be called to update the database.
4279+ * If the cursor is on the insert row, the method {@link #insertRow}
4280+ * must be called, which will insert the new row into both this rowset
4281+ * and the database. Both of these methods must be called before the
4282+ * cursor moves to another row.
4283+ *
4284+ * @param columnIndex the first column is <code>1</code>, the second
4285+ * is <code>2</code>, and so on; must be <code>1</code> or larger
4286+ * and equal to or less than the number of columns in this rowset
4287+ * @param c the new column <code>Clob value
4288+ * @throws SQLException if (1) the given column index is out of bounds,
4289+ * (2) the cursor is not on one of this rowset's rows or its
4290+ * insert row, or (3) this rowset is
4291+ * <code>ResultSet.CONCUR_READ_ONLY</code>
4292+ */
4293+ public void updateClob(int columnIndex, Clob c) throws SQLException {
4294+ throw new UnsupportedOperationException();
4295+ }
4296+
4297+ /**
4298+ * Sets the designated column in either the current row or the insert
4299+ * row of this <code>CachedRowSetImpl</code> object with the given
4300+ * <code>double</code> value.
4301+ *
4302+ * This method updates a column value in either the current row or
4303+ * the insert row of this rowset, but it does not update the
4304+ * database. If the cursor is on a row in the rowset, the
4305+ * method {@link #updateRow} must be called to update the database.
4306+ * If the cursor is on the insert row, the method {@link #insertRow}
4307+ * must be called, which will insert the new row into both this rowset
4308+ * and the database. Both of these methods must be called before the
4309+ * cursor moves to another row.
4310+ *
4311+ * @param columnName a <code>String</code> object that must match the
4312+ * SQL name of a column in this rowset, ignoring case
4313+ * @param c the new column <code>Clob</code>value
4314+ * @throws SQLException if (1) the given column name does not match the
4315+ * name of a column in this rowset, (2) the cursor is not on
4316+ * one of this rowset's rows or its insert row, or (3) this
4317+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4318+ */
4319+ public void updateClob(String columnName, Clob c) throws SQLException {
4320+ throw new UnsupportedOperationException();
4321+ }
4322+
4323+ /**
4324+ * Sets the designated column in either the current row or the insert
4325+ * row of this <code>CachedRowSetImpl</code> object with the given
4326+ * <code>java.sql.Blob</code> value.
4327+ *
4328+ * This method updates a column value in either the current row or
4329+ * the insert row of this rowset, but it does not update the
4330+ * database. If the cursor is on a row in the rowset, the
4331+ * method {@link #updateRow} must be called to update the database.
4332+ * If the cursor is on the insert row, the method {@link #insertRow}
4333+ * must be called, which will insert the new row into both this rowset
4334+ * and the database. Both of these methods must be called before the
4335+ * cursor moves to another row.
4336+ *
4337+ * @param columnIndex the first column is <code>1</code>, the second
4338+ * is <code>2</code>, and so on; must be <code>1</code> or larger
4339+ * and equal to or less than the number of columns in this rowset
4340+ * @param b the new column <code>Blob</code> value
4341+ * @throws SQLException if (1) the given column index is out of bounds,
4342+ * (2) the cursor is not on one of this rowset's rows or its
4343+ * insert row, or (3) this rowset is
4344+ * <code>ResultSet.CONCUR_READ_ONLY</code>
4345+ */
4346+ public void updateBlob(int columnIndex, Blob b) throws SQLException {
4347+ throw new UnsupportedOperationException();
4348+ }
4349+
4350+ /**
4351+ * Sets the designated column in either the current row or the insert
4352+ * row of this <code>CachedRowSetImpl</code> object with the given
4353+ * <code>java.sql.Blob </code> value.
4354+ *
4355+ * This method updates a column value in either the current row or
4356+ * the insert row of this rowset, but it does not update the
4357+ * database. If the cursor is on a row in the rowset, the
4358+ * method {@link #updateRow} must be called to update the database.
4359+ * If the cursor is on the insert row, the method {@link #insertRow}
4360+ * must be called, which will insert the new row into both this rowset
4361+ * and the database. Both of these methods must be called before the
4362+ * cursor moves to another row.
4363+ *
4364+ * @param columnName a <code>String</code> object that must match the
4365+ * SQL name of a column in this rowset, ignoring case
4366+ * @param b the new column <code>Blob</code> value
4367+ * @throws SQLException if (1) the given column name does not match the
4368+ * name of a column in this rowset, (2) the cursor is not on
4369+ * one of this rowset's rows or its insert row, or (3) this
4370+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4371+ */
4372+ public void updateBlob(String columnName, Blob b) throws SQLException {
4373+ throw new UnsupportedOperationException();
4374+ }
4375+
4376+ /**
4377+ * Sets the designated column in either the current row or the insert
4378+ * row of this <code>CachedRowSetImpl</code> object with the given
4379+ * <code>java.sql.Array</code> values.
4380+ *
4381+ * This method updates a column value in either the current row or
4382+ * the insert row of this rowset, but it does not update the
4383+ * database. If the cursor is on a row in the rowset, the
4384+ * method {@link #updateRow} must be called to update the database.
4385+ * If the cursor is on the insert row, the method {@link #insertRow}
4386+ * must be called, which will insert the new row into both this rowset
4387+ * and the database. Both of these methods must be called before the
4388+ * cursor moves to another row.
4389+ *
4390+ * @param columnIndex the first column is <code>1</code>, the second
4391+ * is <code>2</code>, and so on; must be <code>1</code> or larger
4392+ * and equal to or less than the number of columns in this rowset
4393+ * @param a the new column <code>Array</code> value
4394+ * @throws SQLException if (1) the given column index is out of bounds,
4395+ * (2) the cursor is not on one of this rowset's rows or its
4396+ * insert row, or (3) this rowset is
4397+ * <code>ResultSet.CONCUR_READ_ONLY</code>
4398+ */
4399+ public void updateArray(int columnIndex, Array a) throws SQLException {
4400+ throw new UnsupportedOperationException();
4401+ }
4402+
4403+ /**
4404+ * Sets the designated column in either the current row or the insert
4405+ * row of this <code>CachedRowSetImpl</code> object with the given
4406+ * <code>java.sql.Array</code> value.
4407+ *
4408+ * This method updates a column value in either the current row or
4409+ * the insert row of this rowset, but it does not update the
4410+ * database. If the cursor is on a row in the rowset, the
4411+ * method {@link #updateRow} must be called to update the database.
4412+ * If the cursor is on the insert row, the method {@link #insertRow}
4413+ * must be called, which will insert the new row into both this rowset
4414+ * and the database. Both of these methods must be called before the
4415+ * cursor moves to another row.
4416+ *
4417+ * @param columnName a <code>String</code> object that must match the
4418+ * SQL name of a column in this rowset, ignoring case
4419+ * @param a the new column <code>Array</code> value
4420+ * @throws SQLException if (1) the given column name does not match the
4421+ * name of a column in this rowset, (2) the cursor is not on
4422+ * one of this rowset's rows or its insert row, or (3) this
4423+ * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4424+ */
4425+ public void updateArray(String columnName, Array a) throws SQLException {
4426+ throw new UnsupportedOperationException();
4427+ }
4428+
4429+
4430+ /**
4431+ * Retrieves the value of the designated column in this
4432+ * <code>CachedRowSetImpl</code> object as a <code>java.net.URL</code> object
4433+ * in the Java programming language.
4434+ *
4435+ * @return a java.net.URL object containing the resource reference described by
4436+ * the URL
4437+ * @throws SQLException if (1) the given column index is out of bounds,
4438+ * (2) the cursor is not on one of this rowset's rows or its
4439+ * insert row, or (3) the designated column does not store an
4440+ * SQL <code>DATALINK</code> value.
4441+ * @see #getURL(String)
4442+ */
4443+ public java.net.URL getURL(int columnIndex) throws SQLException {
4444+ throw new UnsupportedOperationException();
4445+ }
4446+
4447+ /**
4448+ * Retrieves the value of the designated column in this
4449+ * <code>CachedRowSetImpl</code> object as a <code>java.net.URL</code> object
4450+ * in the Java programming language.
4451+ *
4452+ * @return a java.net.URL object containing the resource reference described by
4453+ * the URL
4454+ * @throws SQLException if (1) the given column name not the name of a column
4455+ * in this rowset, or
4456+ * (2) the cursor is not on one of this rowset's rows or its
4457+ * insert row, or (3) the designated column does not store an
4458+ * SQL <code>DATALINK</code> value.
4459+ * @see #getURL(int)
4460+ */
4461+ public java.net.URL getURL(String columnName) throws SQLException {
4462+ throw new UnsupportedOperationException();
4463+
4464+ }
4465+
4466+ /**
4467+ * The first warning reported by calls on this <code>CachedRowSetImpl</code>
4468+ * object is returned. Subsequent <code>CachedRowSetImpl</code> warnings will
4469+ * be chained to this <code>SQLWarning</code>. All <code>RowSetWarnings</code>
4470+ * warnings are generated in the disconnected environment and remain a
4471+ * seperate warning chain to that provided by the <code>getWarnings</code>
4472+ * method.
4473+ *
4474+ * <P>The warning chain is automatically cleared each time a new
4475+ * row is read.
4476+ *
4477+ * <P><B>Note:</B> This warning chain only covers warnings caused
4478+ * by <code>CachedRowSet</code> (and their child interface)
4479+ * methods. All <code>SQLWarnings</code> can be obtained using the
4480+ * <code>getWarnings</code> method which tracks warnings generated
4481+ * by the underlying JDBC driver.
4482+ * @return the first SQLWarning or null
4483+ *
4484+ */
4485+ public RowSetWarning getRowSetWarnings() {
4486+ throw new UnsupportedOperationException();
4487+ }
4488+
4489+ /**
4490+ * Commits all changes performed by the <code>acceptChanges()</code>
4491+ * methods
4492+ *
4493+ * @see java.sql.Connection#commit
4494+ */
4495+ public void commit() throws SQLException {
4496+ throw new UnsupportedOperationException();
4497+ }
4498+
4499+ /**
4500+ * Rolls back all changes performed by the <code>acceptChanges()</code>
4501+ * methods
4502+ *
4503+ * @see java.sql.Connection#rollback
4504+ */
4505+ public void rollback() throws SQLException {
4506+ throw new UnsupportedOperationException();
4507+ }
4508+
4509+ /**
4510+ * Rolls back all changes performed by the <code>acceptChanges()</code>
4511+ * to the last <code>Savepoint</code> transaction marker.
4512+ *
4513+ * @see java.sql.Connection#rollback(Savepoint)
4514+ */
4515+ public void rollback(Savepoint s) throws SQLException {
4516+ throw new UnsupportedOperationException();
4517+ }
4518+
4519+ /**
4520+ * Unsets the designated parameter to the given int array.
4521+ * This was set using <code>setMatchColumn</code>
4522+ * as the column which will form the basis of the join.
4523+ * <P>
4524+ * The parameter value unset by this method should be same
4525+ * as was set.
4526+ *
4527+ * @param columnIdxes the index into this rowset
4528+ * object's internal representation of parameter values
4529+ * @throws SQLException if an error occurs or the
4530+ * parameter index is out of bounds or if the columnIdx is
4531+ * not the same as set using <code>setMatchColumn(int [])</code>
4532+ */
4533+ public void unsetMatchColumn(int[] columnIdxes) throws SQLException {
4534+ throw new UnsupportedOperationException();
4535+ }
4536+
4537+ /**
4538+ * Unsets the designated parameter to the given String array.
4539+ * This was set using <code>setMatchColumn</code>
4540+ * as the column which will form the basis of the join.
4541+ * <P>
4542+ * The parameter value unset by this method should be same
4543+ * as was set.
4544+ *
4545+ * @param columnIdxes the index into this rowset
4546+ * object's internal representation of parameter values
4547+ * @throws SQLException if an error occurs or the
4548+ * parameter index is out of bounds or if the columnName is
4549+ * not the same as set using <code>setMatchColumn(String [])</code>
4550+ */
4551+ public void unsetMatchColumn(String[] columnIdxes) throws SQLException {
4552+ throw new UnsupportedOperationException();
4553+ }
4554+
4555+ /**
4556+ * Retrieves the column name as <code>String</code> array
4557+ * that was set using <code>setMatchColumn(String [])</code>
4558+ * for this rowset.
4559+ *
4560+ * @return a <code>String</code> array object that contains the column names
4561+ * for the rowset which has this the match columns
4562+ *
4563+ * @throws SQLException if an error occurs or column name is not set
4564+ */
4565+ public String[] getMatchColumnNames() throws SQLException {
4566+ throw new UnsupportedOperationException();
4567+ }
4568+
4569+ /**
4570+ * Retrieves the column id as <code>int</code> array that was set using
4571+ * <code>setMatchColumn(int [])</code> for this rowset.
4572+ *
4573+ * @return a <code>int</code> array object that contains the column ids
4574+ * for the rowset which has this as the match columns.
4575+ *
4576+ * @throws SQLException if an error occurs or column index is not set
4577+ */
4578+ public int[] getMatchColumnIndexes() throws SQLException {
4579+ throw new UnsupportedOperationException();
4580+ }
4581+
4582+ /**
4583+ * Sets the designated parameter to the given int array.
4584+ * This forms the basis of the join for the
4585+ * <code>JoinRowSet</code> as the column which will form the basis of the
4586+ * join.
4587+ * <P>
4588+ * The parameter value set by this method is stored internally and
4589+ * will be supplied as the appropriate parameter in this rowset's
4590+ * command when the method <code>getMatchColumnIndexes</code> is called.
4591+ *
4592+ * @param columnIdxes the indexes into this rowset
4593+ * object's internal representation of parameter values; the
4594+ * first parameter is 0, the second is 1, and so on; must be
4595+ * <code>0</code> or greater
4596+ * @throws SQLException if an error occurs or the
4597+ * parameter index is out of bounds
4598+ */
4599+ public void setMatchColumn(int[] columnIdxes) throws SQLException {
4600+ throw new UnsupportedOperationException();
4601+ }
4602+
4603+ /**
4604+ * Sets the designated parameter to the given String array.
4605+ * This forms the basis of the join for the
4606+ * <code>JoinRowSet</code> as the column which will form the basis of the
4607+ * join.
4608+ * <P>
4609+ * The parameter value set by this method is stored internally and
4610+ * will be supplied as the appropriate parameter in this rowset's
4611+ * command when the method <code>getMatchColumn</code> is called.
4612+ *
4613+ * @param columnNames the name of the column into this rowset
4614+ * object's internal representation of parameter values
4615+ * @throws SQLException if an error occurs or the
4616+ * parameter index is out of bounds
4617+ */
4618+ public void setMatchColumn(String[] columnNames) throws SQLException {
4619+ throw new UnsupportedOperationException();
4620+ }
4621+
4622+
4623+ /**
4624+ * Sets the designated parameter to the given <code>int</code>
4625+ * object. This forms the basis of the join for the
4626+ * <code>JoinRowSet</code> as the column which will form the basis of the
4627+ * join.
4628+ * <P>
4629+ * The parameter value set by this method is stored internally and
4630+ * will be supplied as the appropriate parameter in this rowset's
4631+ * command when the method <code>getMatchColumn</code> is called.
4632+ *
4633+ * @param columnIdx the index into this rowset
4634+ * object's internal representation of parameter values; the
4635+ * first parameter is 0, the second is 1, and so on; must be
4636+ * <code>0</code> or greater
4637+ * @throws SQLException if an error occurs or the
4638+ * parameter index is out of bounds
4639+ */
4640+ public void setMatchColumn(int columnIdx) throws SQLException {
4641+ throw new UnsupportedOperationException();
4642+ }
4643+
4644+ /**
4645+ * Sets the designated parameter to the given <code>String</code>
4646+ * object. This forms the basis of the join for the
4647+ * <code>JoinRowSet</code> as the column which will form the basis of the
4648+ * join.
4649+ * <P>
4650+ * The parameter value set by this method is stored internally and
4651+ * will be supplied as the appropriate parameter in this rowset's
4652+ * command when the method <code>getMatchColumn</code> is called.
4653+ *
4654+ * @param columnName the name of the column into this rowset
4655+ * object's internal representation of parameter values
4656+ * @throws SQLException if an error occurs or the
4657+ * parameter index is out of bounds
4658+ */
4659+ public void setMatchColumn(String columnName) throws SQLException {
4660+ throw new UnsupportedOperationException();
4661+ }
4662+
4663+ /**
4664+ * Unsets the designated parameter to the given <code>int</code>
4665+ * object. This was set using <code>setMatchColumn</code>
4666+ * as the column which will form the basis of the join.
4667+ * <P>
4668+ * The parameter value unset by this method should be same
4669+ * as was set.
4670+ *
4671+ * @param columnIdx the index into this rowset
4672+ * object's internal representation of parameter values
4673+ * @throws SQLException if an error occurs or the
4674+ * parameter index is out of bounds or if the columnIdx is
4675+ * not the same as set using <code>setMatchColumn(int)</code>
4676+ */
4677+ public void unsetMatchColumn(int columnIdx) throws SQLException {
4678+ throw new UnsupportedOperationException();
4679+ }
4680+
4681+ /**
4682+ * Unsets the designated parameter to the given <code>String</code>
4683+ * object. This was set using <code>setMatchColumn</code>
4684+ * as the column which will form the basis of the join.
4685+ * <P>
4686+ * The parameter value unset by this method should be same
4687+ * as was set.
4688+ *
4689+ * @param columnName the index into this rowset
4690+ * object's internal representation of parameter values
4691+ * @throws SQLException if an error occurs or the
4692+ * parameter index is out of bounds or if the columnName is
4693+ * not the same as set using <code>setMatchColumn(String)</code>
4694+ */
4695+ public void unsetMatchColumn(String columnName) throws SQLException {
4696+ throw new UnsupportedOperationException();
4697+ }
4698+
4699+ /**
4700+ * Notifies registered listeners that a RowSet object in the given RowSetEvent
4701+ * object has populated a number of additional rows. The <code>numRows</code> parameter
4702+ * ensures that this event will only be fired every <code>numRow</code>.
4703+ * <p>
4704+ * The source of the event can be retrieved with the method event.getSource.
4705+ *
4706+ * @param event a <code>RowSetEvent</code> object that contains the
4707+ * <code>RowSet</code> object that is the source of the events
4708+ * @param numRows when populating, the number of rows interval on which the
4709+ * <code>CachedRowSet</code> populated should fire; the default value
4710+ * is zero; cannot be less than <code>fetchSize</code> or zero
4711+ */
4712+ public void rowSetPopulated(RowSetEvent event, int numRows) throws SQLException {
4713+ throw new UnsupportedOperationException();
4714+ }
4715+
4716+ /**
4717+ * Populates this <code>CachedRowSet</code> object with data from
4718+ * the given <code>ResultSet</code> object. While related to the <code>populate(ResultSet)</code>
4719+ * method, an additional parameter is provided to allow starting position within
4720+ * the <code>ResultSet</code> from where to populate the CachedRowSet
4721+ * instance.
4722+ *
4723+ * This method is an alternative to the method <code>execute</code>
4724+ * for filling the rowset with data. The method <code>populate</code>
4725+ * does not require that the properties needed by the method
4726+ * <code>execute</code>, such as the <code>command</code> property,
4727+ * be set. This is true because the method <code>populate</code>
4728+ * is given the <code>ResultSet</code> object from
4729+ * which to get data and thus does not need to use the properties
4730+ * required for setting up a connection and executing this
4731+ * <code>CachedRowSetImpl</code> object's command.
4732+ * <P>
4733+ * After populating this rowset with data, the method
4734+ * <code>populate</code> sets the rowset's metadata and
4735+ * then sends a <code>RowSetChangedEvent</code> object
4736+ * to all registered listeners prior to returning.
4737+ *
4738+ * @param data the <code>ResultSet</code> object containing the data
4739+ * to be read into this <code>CachedRowSetImpl</code> object
4740+ * @param start the integer specifing the position in the
4741+ * <code>ResultSet</code> object to popultate the
4742+ * <code>CachedRowSetImpl</code> object.
4743+ * @throws SQLException if an error occurs; or the max row setting is
4744+ * violated while populating the RowSet.Also id the start position
4745+ * is negative.
4746+ * @see #execute
4747+ */
4748+ public void populate(ResultSet data, int start) throws SQLException{
4749+ throw new UnsupportedOperationException();
4750+
4751+ }
4752+
4753+ /**
4754+ * The nextPage gets the next page, that is a <code>CachedRowSetImpl</code> object
4755+ * containing the number of rows specified by page size.
4756+ * @return boolean value true indicating whether there are more pages to come and
4757+ * false indicating that this is the last page.
4758+ * @throws SQLException if an error occurs or this called before calling populate.
4759+ */
4760+ public boolean nextPage() throws SQLException {
4761+ throw new UnsupportedOperationException();
4762+ }
4763+
4764+ /**
4765+ * This is the setter function for setting the size of the page, which specifies
4766+ * how many rows have to be retrived at a time.
4767+ *
4768+ * @param size which is the page size
4769+ * @throws SQLException if size is less than zero or greater than max rows.
4770+ */
4771+ public void setPageSize (int size) throws SQLException {
4772+ throw new UnsupportedOperationException();
4773+ }
4774+
4775+ /**
4776+ * This is the getter function for the size of the page.
4777+ *
4778+ * @return an integer that is the page size.
4779+ */
4780+ public int getPageSize() {
4781+ throw new UnsupportedOperationException();
4782+ }
4783+
4784+
4785+ /**
4786+ * Retrieves the data present in the page prior to the page from where it is
4787+ * called.
4788+ * @return boolean value true if it retrieves the previous page, flase if it
4789+ * is on the first page.
4790+ * @throws SQLException if it is called before populate is called or ResultSet
4791+ * is of type <code>ResultSet.TYPE_FORWARD_ONLY</code> or if an error
4792+ * occurs.
4793+ */
4794+ public boolean previousPage() throws SQLException {
4795+ throw new UnsupportedOperationException();
4796+ }
4797+
4798+ /**
4799+ * Updates the designated column with a character stream value, which will
4800+ * have the specified number of bytes. The driver does the necessary conversion
4801+ * from Java character format to the national character set in the database.
4802+ * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
4803+ * The updater methods are used to update column values in the current row or
4804+ * the insert row. The updater methods do not update the underlying database;
4805+ * instead the updateRow or insertRow methods are called to update the database.
4806+ *
4807+ * @param columnIndex - the first column is 1, the second is 2, ...
4808+ * @param x - the new column value
4809+ * @param length - the length of the stream
4810+ * @exception SQLException if a database access error occurs
4811+ * @since 1.6
4812+ */
4813+ public void updateNCharacterStream(int columnIndex,
4814+ java.io.Reader x,
4815+ int length)
4816+ throws SQLException {
4817+ throw new UnsupportedOperationException("Operation not yet supported");
4818+ }
4819+
4820+ /**
4821+ * Updates the designated column with a character stream value, which will
4822+ * have the specified number of bytes. The driver does the necessary conversion
4823+ * from Java character format to the national character set in the database.
4824+ * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
4825+ * The updater methods are used to update column values in the current row or
4826+ * the insert row. The updater methods do not update the underlying database;
4827+ * instead the updateRow or insertRow methods are called to update the database.
4828+ *
4829+ * @param columnName - name of the Column
4830+ * @param x - the new column value
4831+ * @param length - the length of the stream
4832+ * @exception SQLException if a database access error occurs
4833+ * @since 1.6
4834+ */
4835+ public void updateNCharacterStream(String columnName,
4836+ java.io.Reader x,
4837+ int length)
4838+ throws SQLException {
4839+ throw new UnsupportedOperationException("Operation not yet supported");
4840+ }
4841+
4842+ /**
4843+ * This method re populates the resBundle
4844+ * during the deserialization process
4845+ *
4846+ */
4847+ private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
4848+ // Default state initialization happens here
4849+ ois.defaultReadObject();
4850+ // Initialization of transient Res Bundle happens here .
4851+ try {
4852+ resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
4853+ } catch(IOException ioe) {
4854+ throw new RuntimeException(ioe);
4855+ }
4856+
4857+ }
4858+
4859+ static final long serialVersionUID = -3345004441725080251L;
4860+} //end class