0001: /*
0002: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
0003: *
0004: * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
0005: *
0006: * The contents of this file are subject to the terms of either the GNU
0007: * General Public License Version 2 only ("GPL") or the Common
0008: * Development and Distribution License("CDDL") (collectively, the
0009: * "License"). You may not use this file except in compliance with the
0010: * License. You can obtain a copy of the License at
0011: * http://www.netbeans.org/cddl-gplv2.html
0012: * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
0013: * specific language governing permissions and limitations under the
0014: * License. When distributing the software, include this License Header
0015: * Notice in each file and include the License file at
0016: * nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
0017: * particular file as subject to the "Classpath" exception as provided
0018: * by Sun in the GPL Version 2 section of the License file that
0019: * accompanied this code. If applicable, add the following below the
0020: * License Header, with the fields enclosed by brackets [] replaced by
0021: * your own identifying information:
0022: * "Portions Copyrighted [year] [name of copyright owner]"
0023: *
0024: * Contributor(s):
0025: *
0026: * The Original Software is NetBeans. The Initial Developer of the Original
0027: * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
0028: * Microsystems, Inc. All Rights Reserved.
0029: *
0030: * If you wish your version of this file to be governed by only the CDDL
0031: * or only the GPL Version 2, indicate your decision by adding
0032: * "[Contributor] elects to include this software in this distribution
0033: * under the [CDDL or GPL Version 2] license." If you do not indicate a
0034: * single choice of license, a recipient has the option to distribute
0035: * your version of this file under either the CDDL, the GPL Version 2 or
0036: * to extend the choice of license to its licensees as provided above.
0037: * However, if you add GPL Version 2 code and therefore, elected the GPL
0038: * Version 2 license, then the option applies only if the new code is
0039: * made subject to such option by the copyright holder.
0040: */
0041:
0042: package com.sun.sql.rowset.internal;
0043:
0044: import java.sql.*;
0045: import javax.sql.*;
0046: import java.lang.*;
0047: import java.util.*;
0048: import java.math.BigDecimal;
0049:
0050: import javax.sql.rowset.*;
0051: import javax.sql.rowset.spi.*;
0052:
0053: //import com.sun.rowset.*;
0054: import com.sun.rowset.internal.*;
0055: import java.lang.Comparable;
0056:
0057: import com.sun.sql.rowset.CachedRowSetXImpl;
0058: import com.sun.sql.rowset.RowSetMetaDataXImpl;
0059: import com.sun.sql.rowset.SyncResolverX;
0060:
0061: import java.text.MessageFormat;
0062: import java.util.Locale;
0063: import java.util.ResourceBundle;
0064:
0065: /**
0066: * Implements {@link com.sun.sql.rowset.SyncResolverX}.
0067: *
0068: * Based on the Sun reference implementation SyncResolverImpl.
0069: */
0070: public class SyncResolverXImpl extends CachedRowSetXImpl implements
0071: SyncResolverX {
0072:
0073: private static ResourceBundle rb = ResourceBundle.getBundle(
0074: "com.sun.sql.rowset.internal.Bundle", Locale.getDefault()); // NOI18N
0075:
0076: /**
0077: * This CachedRowSet object will encapsulate a rowset
0078: * which will be sync'ed with the datasource but will
0079: * contain values in rows where there is conflict.
0080: * For rows other than conflict, it will *not* contain
0081: * any data. For rows containing conflict it will
0082: * return either of the three values set by SyncResolver.*_CONFLICT
0083: * from getStatus()
0084: */
0085: private CachedRowSetXImpl crsRes;
0086:
0087: /**
0088: * This is the actual CachedRowSet object
0089: * which is being synchronized back to
0090: * datasource.
0091: */
0092: private CachedRowSetXImpl crsSync;
0093:
0094: /**
0095: * This ArrayList will contain the status of a row
0096: * from the SyncResolver.* values else it will be null.
0097: */
0098: private ArrayList stats;
0099:
0100: /**
0101: * This ArrayList will contain the SQLException of a row
0102: * it will be null if no exception occurred.
0103: */
0104: private ArrayList exceptions;
0105:
0106: /**
0107: * The RowSetWriter associated with the original
0108: * CachedRowSet object which is being synchronized.
0109: */
0110: private CachedRowSetXWriter crw;
0111:
0112: /**
0113: * Row number identifier
0114: */
0115: private int rowStatus;
0116:
0117: /**
0118: * This will contain the size of the <code>CachedRowSet</code> object
0119: */
0120: private int sz;
0121:
0122: /**
0123: * The <code>Connection</code> handle used to synchronize the changes
0124: * back to datasource. This is the same connection handle as was passed
0125: * to the CachedRowSet while fetching the data.
0126: */
0127: private Connection con;
0128:
0129: /**
0130: * The <code>CachedRowSet</code> object which will encapsulate
0131: * a row at any time. This will be built from CachedRowSet and
0132: * SyncResolver values. Synchronization takes place on a row by
0133: * row basis encapsulated as a CahedRowSet.
0134: */
0135: private CachedRowSet row;
0136:
0137: /**
0138: * Public constructor
0139: */
0140: public SyncResolverXImpl() {
0141: crsSync = CachedRowSetXImpl.createInternalUseInstance();
0142: crsRes = CachedRowSetXImpl.createInternalUseInstance();
0143: crw = new CachedRowSetXWriter();
0144: row = CachedRowSetXImpl.createInternalUseInstance();
0145: rowStatus = 1;
0146: }
0147:
0148: /**
0149: * Retrieves the conflict status of the current row of this
0150: * <code>SyncResolver</code>, which indicates the operationthe <code>RowSet</code>
0151: * object was attempting when the conflict occurred.
0152: *
0153: * @return one of the following constants:
0154: * <code>SyncResolver.UPDATE_ROW_CONFLICT</code>,
0155: * <code>SyncResolver.DELETE_ROW_CONFLICT</code>, or
0156: * <code>SyncResolver.INSERT_ROW_CONFLICT</code>
0157: */
0158: public int getStatus() {
0159: return ((Integer) stats.get(rowStatus - 1)).intValue();
0160: }
0161:
0162: /**
0163: * Retrieves the conflict's SQLExceptions of the current row of this
0164: * <code>SyncResolver</code>
0165: */
0166: public SQLException getSQLException() {
0167: return (SQLException) exceptions.get(rowStatus - 1);
0168: }
0169:
0170: /**
0171: * Retrieves the value in the designated column in the current row of this
0172: * <code>SyncResolver</code> object, which is the value that caused a conflict.
0173: *
0174: * @param index an <code>int</code> designating the column in this row of this
0175: * <code>SyncResolver</code> object from which to retrieve the value
0176: * causing a conflict
0177: */
0178: public Object getConflictValue(int index) throws SQLException {
0179: try {
0180: return crsRes.getObject(index);
0181: } catch (SQLException sqle) {
0182: throw new SQLException(sqle.getMessage());
0183: }
0184: }
0185:
0186: /**
0187: * Retrieves the value in the designated column in the current row of this
0188: * <code>SyncResolver</code> object, which is the value that caused a conflict.
0189: *
0190: * @param columnName a <code>String</code> object designating the column in this row of this
0191: * <code>SyncResolver</code> object from which to retrieve the value
0192: * causing a conflict
0193: */
0194: public Object getConflictValue(String columnName)
0195: throws SQLException {
0196: try {
0197: return crsRes.getObject(columnName);
0198: } catch (SQLException sqle) {
0199: throw new SQLException(sqle.getMessage());
0200: }
0201: }
0202:
0203: /**
0204: * Sets <i>obj</i> as the value in column <i>index</i> in the current row of the
0205: * <code>RowSet</code> object. This value is the resolved value that is to be
0206: * persisted in the data source.
0207: *
0208: * @param index an <code>int</code> giving the number of the column into which to
0209: * set the value to be persisted
0210: * @param obj an <code>Object</code> that is the value to be set in the data source
0211: */
0212: public void setResolvedValue(int index, Object obj)
0213: throws SQLException {
0214: // modify method to throw SQLException in spec
0215:
0216: /**
0217: * When a value is resolved properly make it to null
0218: * inside crsRes for that column.
0219: *
0220: * For more than one conflicts in the row,
0221: * check for the last resolved value of the current row
0222: * (Note: it can be resolved randomly for same row)
0223: * then sync back immediately.
0224: **/
0225: try {
0226: // check whether the index is in range
0227: if (index <= 0
0228: || index > crsSync.getMetaData().getColumnCount()) {
0229: throw new SQLException(MessageFormat.format(rb
0230: .getString("INDEX_VALUE_OUT_OF_RANGE"), //NOI18N
0231: new Object[] { new Integer(index) }));
0232: }
0233: // check whether index col is in conflict
0234: if (crsRes.getObject(index) == null) {
0235: throw new SQLException(MessageFormat.format(rb
0236: .getString("COLUMN_NOT_IN_CONFLICT"), //NOI18N
0237: new Object[] { new Integer(index) }));
0238: }
0239: } catch (SQLException sqle) {
0240: // modify method to throw for SQLException
0241: throw new SQLException(sqle.getMessage());
0242: }
0243: try {
0244: boolean bool = true;
0245: /** Check resolved value to be either of conflict
0246: * or in rowset else throw sql exception.
0247: * If we allow a value other than that in CachedRowSet or
0248: * datasource we will end up in looping the loop of exceptions.
0249: **/
0250:
0251: if (((crsSync.getObject(index)).toString()).equals(obj
0252: .toString())
0253: || ((crsRes.getObject(index)).toString())
0254: .equals(obj.toString())) {
0255:
0256: /**
0257: * Check whether this is the only conflict in the row.
0258: * If yes, synchronize this row back
0259: * which has been resolved, else wait
0260: * for all conflicts of current row to be resolved
0261: *
0262: * Step 1: Update crsRes and make the index col as null
0263: * i.e. resolved
0264: * crsRes.updateObject(index, obj);
0265: **/
0266: crsRes.updateNull(index);
0267: crsRes.updateRow();
0268:
0269: /**
0270: * Step 2: Change the value in the CachedRowSetXImpl object
0271: * crsSync.updateObject(index, obj);
0272: * crsSync.updateRow();
0273: **/
0274: if (row.size() != 1) {
0275: row = buildCachedRow();
0276: }
0277:
0278: row.updateObject(index, obj);
0279: row.updateRow();
0280:
0281: for (int j = 1; j < crsRes.getMetaData()
0282: .getColumnCount(); j++) {
0283: if (crsRes.getObject(j) != null) {
0284: bool = false;
0285: break;
0286: // break out of loop and wait for other cols
0287: // in same row to get resolved
0288: } //end if
0289:
0290: } //end for
0291:
0292: if (bool) {
0293: /**
0294: * sync data back using CachedRowSetXWriter
0295: * construct the present row and pass it to the writer
0296: * to write back to db.
0297: **/
0298: try {
0299: /**
0300: * Note : The use of CachedRowSetXWriter to get *same* Connection handle.
0301: * The CachedRowSetXWriter uses the connection handle
0302: * from the reader, Hence will use the same connection handle
0303: * as of original CachedRowSetXImpl
0304: **/
0305:
0306: writeData(row);
0307:
0308: //crw.writeData( (RowSetInternal)crsRow);
0309: //System.out.printlnt.println("12");
0310:
0311: } catch (SyncProviderException spe) {
0312: /**
0313: * This will occur if db is not allowing
0314: * even after resolving the conflicts
0315: * due to some reasons.
0316: * Also will prevent from going into a loop of SPE's
0317: **/
0318: throw new SQLException(rb
0319: .getString("SYNC_NOT_POSSIBLE")); //NOI18N
0320: }
0321: } //end if(bool)
0322:
0323: } else {
0324: throw new SQLException(rb
0325: .getString("VALUE_TO_BE_RESOLVED_CAN_BE")); //NOI18N
0326: } //end if (crs.getObject ...) block
0327:
0328: } catch (SQLException sqle) {
0329: throw new SQLException(sqle.getMessage());
0330: }
0331: }
0332:
0333: /**
0334: * This passes a CachedRowSet as a row the the CachedRowSetXWriter
0335: * after the values have been resolved, back to the datasource.
0336: *
0337: * @param row a <code>CachedRowSet</code> object which will hold the
0338: * values of a particular row after they have been resolved by
0339: * the user to synchronize back to datasource.
0340: * @throws SQLException if synchronization does not happen properly
0341: * maybe beacuse <code>Connection</code> has timed out.
0342: **/
0343: private void writeData(CachedRowSet row) throws SQLException {
0344: crw.updateResolvedConflictToDB(row, crw.getReader().connect(
0345: (RowSetInternal) crsSync));
0346: }
0347:
0348: /**
0349: * This function builds a row as a <code>CachedRowSet</code> object
0350: * which has been resolved and is ready to be synchrinized to the datasource
0351: *
0352: * @throws SQLException if there is problem in building
0353: * the metadata of the row.
0354: **/
0355: private CachedRowSet buildCachedRow() throws SQLException {
0356: int iColCount;
0357: CachedRowSetXImpl crsRow = CachedRowSetXImpl
0358: .createInternalUseInstance();
0359:
0360: RowSetMetaDataXImpl rsmd = new RowSetMetaDataXImpl();
0361: RowSetMetaDataXImpl rsmdWrite = (RowSetMetaDataXImpl) crsSync
0362: .getMetaData();
0363: RowSetMetaDataXImpl rsmdRow = new RowSetMetaDataXImpl();
0364:
0365: iColCount = rsmdWrite.getColumnCount();
0366: rsmdRow.setColumnCount(iColCount);
0367:
0368: for (int i = 1; i <= iColCount; i++) {
0369: rsmdRow.setColumnType(i, rsmdWrite.getColumnType(i));
0370: rsmdRow.setColumnName(i, rsmdWrite.getColumnName(i));
0371: rsmdRow.setNullable(i,
0372: ResultSetMetaData.columnNullableUnknown);
0373:
0374: try {
0375: rsmdRow.setCatalogName(i, rsmdWrite.getCatalogName(i));
0376: rsmdRow.setSchemaName(i, rsmdWrite.getSchemaName(i));
0377: } catch (SQLException e) {
0378: e.printStackTrace();
0379: }
0380: } //end for
0381:
0382: crsRow.setMetaData(rsmdRow);
0383:
0384: crsRow.moveToInsertRow();
0385:
0386: for (int col = 1; col <= crsSync.getMetaData().getColumnCount(); col++) {
0387: crsRow.updateObject(col, crsSync.getObject(col));
0388: }
0389:
0390: crsRow.insertRow();
0391: crsRow.moveToCurrentRow();
0392:
0393: crsRow.absolute(1);
0394: crsRow.setOriginalRow();
0395:
0396: try {
0397: crsRow.setUrl(crsSync.getUrl());
0398: } catch (SQLException sqle) {
0399:
0400: }
0401:
0402: try {
0403: crsRow.setDataSourceName(crsSync.getCommand());
0404: } catch (SQLException sqle) {
0405:
0406: }
0407:
0408: try {
0409: if (crsSync.getTableName() != null) {
0410: crsRow.setTableName(crsSync.getTableName());
0411: }
0412: } catch (SQLException sqle) {
0413:
0414: }
0415:
0416: try {
0417: crsRow.setCommand(crsSync.getCommand());
0418: } catch (SQLException sqle) {
0419:
0420: }
0421:
0422: try {
0423: crsRow.setKeyColumns(crsSync.getKeyColumns());
0424: } catch (SQLException sqle) {
0425:
0426: }
0427: return crsRow;
0428: }
0429:
0430: /**
0431: * Sets <i>obj</i> as the value in column <i>columnName</i> in the current row of the
0432: * <code>RowSet</code> object. This value is the resolved value that is to be
0433: * persisted in the data source.
0434: *
0435: * @param columnName a <code>String</code> object giving the name of the column
0436: * into which to set the value to be persisted
0437: * @param obj an <code>Object</code> that is the value to be set in the data source
0438: */
0439: public void setResolvedValue(String columnName, Object obj)
0440: throws SQLException {
0441: // modify method to throw SQLException in spec
0442: // %%% Missing implementation!
0443: }
0444:
0445: /**
0446: * This function is package private,
0447: * i.e. cannot be accesses outside this package.
0448: * This is used to set the actual CachedRowSet
0449: * which is being synchronized to the database
0450: **/
0451: void setCachedRowSet(CachedRowSet crs) {
0452: crsSync = (CachedRowSetXImpl) crs;
0453: }
0454:
0455: /**
0456: * This function is package private,
0457: * i.e. cannot be accesses outside this package.
0458: * This is used to set the CachedRowSet formed
0459: * with conflict values.
0460: **/
0461: void setCachedRowSetResolver(CachedRowSet crs) {
0462: try {
0463: crsRes = (CachedRowSetXImpl) crs;
0464: crsRes.afterLast();
0465: sz = crsRes.size();
0466: } catch (SQLException sqle) {
0467: // do nothing
0468: }
0469: }
0470:
0471: /**
0472: * This function is package private,
0473: * i.e. cannot be accesses outside this package.
0474: * This is used to set the status of each row
0475: * to either of the values SyncResolver.*_CONFLICT
0476: **/
0477: void setStatus(ArrayList status) {
0478: stats = status;
0479: }
0480:
0481: /**
0482: * This is used to set the SQLException of each row
0483: * an element can be null if no exception occurred
0484: **/
0485: void setExceptions(ArrayList exceptions) {
0486: this .exceptions = exceptions;
0487: }
0488:
0489: /**
0490: * This function is package private,
0491: * i.e. cannot be accesses outside this package.
0492: * This is used to set the handle to the writer object
0493: * which will write the resolved values back to datasource
0494: **/
0495: void setCachedRowSetXWriter(CachedRowSetXWriter CRWriter) {
0496: crw = CRWriter;
0497: }
0498:
0499: /**
0500: * Moves the cursor down one row from its current position. A <code>SyncResolver</code>
0501: * cursor is initially positioned before the first conflict row; the first call to the
0502: * method <code>nextConflict()</code> makes the first conflict row the current row;
0503: * the second call makes the second conflict row the current row, and so on.
0504: * <p>
0505: * If an input stream is open for the current row, a call to the method next will
0506: * implicitly close it. A <code>SyncResolver</code> object's warning chain is cleared
0507: * when a new row
0508: *
0509: * @return true if the new current row is valid; false if there are no more rows
0510: * @throws SQLException if a database access occurs
0511: *
0512: */
0513: public boolean nextConflict() throws SQLException {
0514: /**
0515: * The next() method will hop from
0516: * one conflict to another
0517: *
0518: * Internally do a crs.next() until
0519: * next conflict.
0520: **/
0521: boolean bool = false;
0522:
0523: while (crsSync.next()) {
0524: crsRes.previous();
0525: rowStatus++; //sz--;
0526:
0527: if ((rowStatus - 1) >= stats.size()) {
0528: bool = false;
0529: break;
0530: }
0531:
0532: if (((Integer) stats.get(rowStatus - 1)).intValue() == SyncResolver.NO_ROW_CONFLICT) {
0533: // do nothing
0534: // bool remains as false
0535: ;
0536: } else {
0537: bool = true;
0538: break;
0539: } //end if
0540:
0541: } //end while
0542:
0543: return bool;
0544: } // end next() method
0545:
0546: /**
0547: * Moves the cursor to the previous conflict row in this <code>SyncResolver</code> object.
0548: *
0549: * @return <code>true</code> if the cursor is on a valid row; <code>false</code>
0550: * if it is off the result set
0551: * @throws SQLException if a database access error occurs or the result set type
0552: * is TYPE_FORWARD_ONLY
0553: */
0554: public boolean previousConflict() throws SQLException {
0555: throw new UnsupportedOperationException();
0556: }
0557:
0558: //-----------------------------------------------------------------------
0559: // Properties
0560: //-----------------------------------------------------------------------
0561:
0562: /**
0563: * Sets this <code>CachedRowSetXImpl</code> object's command property
0564: * to the given <code>String</code> object and clears the parameters,
0565: * if any, that were set for the previous command.
0566: * <P>
0567: * The command property may not be needed
0568: * if the rowset is produced by a data source, such as a spreadsheet,
0569: * that does not support commands. Thus, this property is optional
0570: * and may be <code>null</code>.
0571: *
0572: * @param cmd a <code>String</code> object containing an SQL query
0573: * that will be set as the command; may be <code>null</code>
0574: * @throws SQLException if an error occurs
0575: */
0576: public void setCommand(String cmd) throws SQLException {
0577: throw new UnsupportedOperationException();
0578: }
0579:
0580: //---------------------------------------------------------------------
0581: // Reading and writing data
0582: //---------------------------------------------------------------------
0583:
0584: /**
0585: * Populates this <code>CachedRowSetXImpl</code> object with data from
0586: * the given <code>ResultSet</code> object. This
0587: * method is an alternative to the method <code>execute</code>
0588: * for filling the rowset with data. The method <code>populate</code>
0589: * does not require that the properties needed by the method
0590: * <code>execute</code>, such as the <code>command</code> property,
0591: * be set. This is true because the method <code>populate</code>
0592: * is given the <code>ResultSet</code> object from
0593: * which to get data and thus does not need to use the properties
0594: * required for setting up a connection and executing this
0595: * <code>CachedRowSetXImpl</code> object's command.
0596: * <P>
0597: * After populating this rowset with data, the method
0598: * <code>populate</code> sets the rowset's metadata and
0599: * then sends a <code>RowSetChangedEvent</code> object
0600: * to all registered listeners prior to returning.
0601: *
0602: * @param data the <code>ResultSet</code> object containing the data
0603: * to be read into this <code>CachedRowSetXImpl</code> object
0604: * @throws SQLException if an error occurs; or the max row setting is
0605: * violated while populating the RowSet
0606: * @see #execute
0607: */
0608: public void populate(ResultSet data) throws SQLException {
0609: throw new UnsupportedOperationException();
0610: }
0611:
0612: /**
0613: * Populates this <code>CachedRowSetXImpl</code> object with data,
0614: * using the given connection to produce the result set from
0615: * which data will be read. A second form of this method,
0616: * which takes no arguments, uses the values from this rowset's
0617: * user, password, and either url or data source properties to
0618: * create a new database connection. The form of <code>execute</code>
0619: * that is given a connection ignores these properties.
0620: *
0621: * @param conn A standard JDBC <code>Connection</code> object that this
0622: * <code>CachedRowSet</code> object can pass to a synchronization provider
0623: * to establish a connection to the data source
0624: * @throws SQLException if an invalid <code>Connection</code> is supplied
0625: * or an error occurs in establishing the connection to the
0626: * data source
0627: * @see #populate
0628: * @see java.sql.Connection
0629: */
0630: public void execute(Connection conn) throws SQLException {
0631: throw new UnsupportedOperationException();
0632: }
0633:
0634: /**
0635: * Propagates all row update, insert, and delete changes to the
0636: * underlying data source backing this <code>CachedRowSetXImpl</code>
0637: * object.
0638: * <P>
0639: * <b>Note</b>In the reference implementation an optimistic concurrency implementation
0640: * is provided as a sample implementation of a the <code>SyncProvider</code>
0641: * abstract class.
0642: * <P>
0643: * This method fails if any of the updates cannot be propagated back
0644: * to the data source. When it fails, the caller can assume that
0645: * none of the updates are reflected in the data source.
0646: * When an exception is thrown, the current row
0647: * is set to the first "updated" row that resulted in an exception
0648: * unless the row that caused the exception is a "deleted" row.
0649: * In that case, when deleted rows are not shown, which is usually true,
0650: * the current row is not affected.
0651: * <P>
0652: * If no <code>SyncProvider</code> is configured, the reference implementation
0653: * leverages the <code>RIOptimisticProvider</code> available which provides the
0654: * default and reference synchronization capabilities for disconnected
0655: * <code>RowSets</code>.
0656: *
0657: * @throws SQLException if the cursor is on the insert row or the underlying
0658: * reference synchronization provider fails to commit the updates
0659: * to the datasource
0660: * @throws SyncProviderException if an internal error occurs within the
0661: * <code>SyncProvider</code> instance during either during the
0662: * process or at any time when the <code>SyncProvider</code>
0663: * instance touches the data source.
0664: * @see #acceptChanges(java.sql.Connection)
0665: * @see javax.sql.RowSetWriter
0666: * @see javax.sql.rowset.spi.SyncProvider
0667: */
0668: public void acceptChanges() throws SyncProviderException {
0669: throw new UnsupportedOperationException();
0670: }
0671:
0672: /**
0673: * Propagates all row update, insert, and delete changes to the
0674: * data source backing this <code>CachedRowSetXImpl</code> object
0675: * using the given <code>Connection</code> object.
0676: * <P>
0677: * The reference implementation <code>RIOptimisticProvider</code>
0678: * modifies its synchronization to a write back function given
0679: * the updated connection
0680: * The reference implementation modifies its synchronization behaviour
0681: * via the <code>SyncProvider</code> to ensure the synchronization
0682: * occurs according to the updated JDBC <code>Connection</code>
0683: * properties.
0684: *
0685: * @param con a standard JDBC <code>Connection</code> object
0686: * @throws SQLException if the cursor is on the insert row or the underlying
0687: * synchronization provider fails to commit the updates
0688: * back to the data source
0689: * @see #acceptChanges
0690: * @see javax.sql.RowSetWriter
0691: * @see javax.sql.rowset.spi.SyncFactory
0692: * @see javax.sql.rowset.spi.SyncProvider
0693: */
0694: public void acceptChanges(Connection con)
0695: throws SyncProviderException {
0696: throw new UnsupportedOperationException();
0697: }
0698:
0699: /**
0700: * Restores this <code>CachedRowSetXImpl</code> object to its original state,
0701: * that is, its state before the last set of changes.
0702: * <P>
0703: * Before returning, this method moves the cursor before the first row
0704: * and sends a <code>rowSetChanged</code> event to all registered
0705: * listeners.
0706: * @throws SQLException if an error is occurs rolling back the RowSet
0707: * state to the definied original value.
0708: * @see javax.sql.RowSetListener#rowSetChanged
0709: */
0710: public void restoreOriginal() throws SQLException {
0711: throw new UnsupportedOperationException();
0712: }
0713:
0714: /**
0715: * Releases the current contents of this <code>CachedRowSetXImpl</code>
0716: * object and sends a <code>rowSetChanged</code> event object to all
0717: * registered listeners.
0718: *
0719: * @throws SQLException if an error occurs flushing the contents of
0720: * RowSet.
0721: * @see javax.sql.RowSetListener#rowSetChanged
0722: */
0723: public void release() throws SQLException {
0724: throw new UnsupportedOperationException();
0725: }
0726:
0727: /**
0728: * Cancels deletion of the current row and notifies listeners that
0729: * a row has changed.
0730: * <P>
0731: * Note: This method can be ignored if deleted rows are not being shown,
0732: * which is the normal case.
0733: *
0734: * @throws SQLException if the cursor is not on a valid row
0735: */
0736: public void undoDelete() throws SQLException {
0737: throw new UnsupportedOperationException();
0738: }
0739:
0740: /**
0741: * Immediately removes the current row from this
0742: * <code>CachedRowSetXImpl</code> object if the row has been inserted, and
0743: * also notifies listeners the a row has changed. An exception is thrown
0744: * if the row is not a row that has been inserted or the cursor is before
0745: * the first row, after the last row, or on the insert row.
0746: * <P>
0747: * This operation cannot be undone.
0748: *
0749: * @throws SQLException if an error occurs,
0750: * the cursor is not on a valid row,
0751: * or the row has not been inserted
0752: */
0753: public void undoInsert() throws SQLException {
0754: throw new UnsupportedOperationException();
0755: }
0756:
0757: /**
0758: * Immediately reverses the last update operation if the
0759: * row has been modified. This method can be
0760: * called to reverse updates on a all columns until all updates in a row have
0761: * been rolled back to their originating state since the last synchronization
0762: * (<code>acceptChanges</code>) or population. This method may also be called
0763: * while performing updates to the insert row.
0764: * <P>
0765: * <code>undoUpdate</code may be called at any time during the life-time of a
0766: * rowset, however after a synchronization has occurs this method has no
0767: * affect until further modification to the RowSet data occurs.
0768: *
0769: * @throws SQLException if cursor is before the first row, after the last
0770: * row in rowset.
0771: * @see #undoDelete
0772: * @see #undoInsert
0773: * @see java.sql.ResultSet#cancelRowUpdates
0774: */
0775: public void undoUpdate() throws SQLException {
0776: throw new UnsupportedOperationException();
0777:
0778: }
0779:
0780: //--------------------------------------------------------------------
0781: // Views
0782: //--------------------------------------------------------------------
0783:
0784: /**
0785: * Returns a new <code>RowSet</code> object backed by the same data as
0786: * that of this <code>CachedRowSetXImpl</code> object and sharing a set of cursors
0787: * with it. This allows cursors to interate over a shared set of rows, providing
0788: * multiple views of the underlying data.
0789: *
0790: * @return a <code>RowSet</code> object that is a copy of this <code>CachedRowSetXImpl</code>
0791: * object and shares a set of cursors with it
0792: * @throws SQLException if an error occurs or cloning is
0793: * not supported
0794: * @see javax.sql.RowSetEvent
0795: * @see javax.sql.RowSetListener
0796: */
0797: public RowSet createShared() throws SQLException {
0798: throw new UnsupportedOperationException();
0799: }
0800:
0801: /**
0802: * Returns a new <code>RowSet</code> object containing by the same data
0803: * as this <code>CachedRowSetXImpl</code> object. This method
0804: * differs from the method <code>createCopy</code> in that it throws a
0805: * <code>CloneNotSupportedException</code> object instead of an
0806: * <code>SQLException</code> object, as the method <code>createShared</code>
0807: * does. This <code>clone</code>
0808: * method is called internally by the method <code>createShared</code>,
0809: * which catches the <code>CloneNotSupportedException</code> object
0810: * and in turn throws a new <code>SQLException</code> object.
0811: *
0812: * @return a copy of this <code>CachedRowSetXImpl</code> object
0813: * @throws CloneNotSupportedException if an error occurs when
0814: * attempting to clone this <code>CachedRowSetXImpl</code> object
0815: * @see #createShared
0816: */
0817: protected Object clone() throws CloneNotSupportedException {
0818: throw new UnsupportedOperationException();
0819: }
0820:
0821: /**
0822: * Creates a <code>RowSet</code> object that is a deep copy of
0823: * this <code>CachedRowSetXImpl</code> object's data, including
0824: * constraints. Updates made
0825: * on a copy are not visible to the original rowset;
0826: * a copy of a rowset is completely independent from the original.
0827: * <P>
0828: * Making a copy saves the cost of creating an identical rowset
0829: * from first principles, which can be quite expensive.
0830: * For example, it can eliminate the need to query a
0831: * remote database server.
0832: * @return a new <code>CachedRowSet</code> object that is a deep copy
0833: * of this <code>CachedRowSet</code> object and is
0834: * completely independent from this <code>CachedRowSetXImpl</code>
0835: * object.
0836: * @throws SQLException if an error occurs in generating the copy of this
0837: * of the <code>CachedRowSetXImpl</code>
0838: * @see #createShared
0839: * @see javax.sql.RowSetEvent
0840: * @see javax.sql.RowSetListener
0841: */
0842: public CachedRowSet createCopy() throws SQLException {
0843: throw new UnsupportedOperationException();
0844: }
0845:
0846: /**
0847: * Creates a <code>RowSet</code> object that is a copy of
0848: * this <code>CachedRowSetXImpl</code> object's table structure
0849: * and the constraints only.
0850: * There will be no data in the object being returned.
0851: * Updates made on a copy are not visible to the original rowset.
0852: * <P>
0853: * This helps in getting the underlying XML schema which can
0854: * be used as the basis for populating a <code>WebRowSet</code>.
0855: *
0856: * @return a new <code>CachedRowSet</code> object that is a copy
0857: * of this <code>CachedRowSetXImpl</code> object's schema and
0858: * retains all the constraints on the original rowset but contains
0859: * no data
0860: * @throws SQLException if an error occurs in generating the copy
0861: * of the <code>CachedRowSet</code> object
0862: * @see #createShared
0863: * @see #createCopy
0864: * @see #createCopyNoConstraints
0865: * @see javax.sql.RowSetEvent
0866: * @see javax.sql.RowSetListener
0867: */
0868: public CachedRowSet createCopySchema() throws SQLException {
0869: throw new UnsupportedOperationException();
0870: }
0871:
0872: /**
0873: * Creates a <code>CachedRowSet</code> object that is a copy of
0874: * this <code>CachedRowSetXImpl</code> object's data only.
0875: * All constraints set in this object will not be there
0876: * in the returning object. Updates made
0877: * on a copy are not visible to the original rowset.
0878: *
0879: * @return a new <code>CachedRowSet</code> object that is a deep copy
0880: * of this <code>CachedRowSetXImpl</code> object and is
0881: * completely independent from this <code>CachedRowSetXImpl</code> object
0882: * @throws SQLException if an error occurs in generating the copy of the
0883: * of the <code>CachedRowSet</code>
0884: * @see #createShared
0885: * @see #createCopy
0886: * @see #createCopySchema
0887: * @see javax.sql.RowSetEvent
0888: * @see javax.sql.RowSetListener
0889: */
0890: public CachedRowSet createCopyNoConstraints() throws SQLException {
0891: throw new UnsupportedOperationException();
0892: }
0893:
0894: /**
0895: * Converts this <code>CachedRowSetXImpl</code> object to a collection
0896: * of tables. The sample implementation utilitizes the <code>TreeMap</code>
0897: * collection type.
0898: * This class guarantees that the map will be in ascending key order,
0899: * sorted according to the natural order for the key's class.
0900: *
0901: * @return a <code>Collection</code> object consisting of tables,
0902: * each of which is a copy of a row in this
0903: * <code>CachedRowSetXImpl</code> object
0904: * @throws SQLException if an error occurs in generating the collection
0905: * @see #toCollection(int)
0906: * @see #toCollection(String)
0907: * @see java.util.TreeMap
0908: */
0909: public Collection toCollection() throws SQLException {
0910: throw new UnsupportedOperationException();
0911: }
0912:
0913: /**
0914: * Returns the specified column of this <code>CachedRowSetXImpl</code> object
0915: * as a <code>Collection</code> object. This method makes a copy of the
0916: * column's data and utilitizes the <code>Vector</code> to establish the
0917: * collection. The <code>Vector</code> class implements a growable array
0918: * objects allowing the individual components to be accessed using an
0919: * an integer index similar to that of an array.
0920: *
0921: * @return a <code>Collection</code> object that contains the value(s)
0922: * stored in the specified column of this
0923: * <code>CachedRowSetXImpl</code>
0924: * object
0925: * @throws SQLException if an error occurs generated the collection; or
0926: * an invalid column is provided.
0927: * @see #toCollection()
0928: * @see #toCollection(String)
0929: * @see java.util.Vector
0930: */
0931: public Collection toCollection(int column) throws SQLException {
0932: throw new UnsupportedOperationException();
0933: }
0934:
0935: /**
0936: * Returns the specified column of this <code>CachedRowSetXImpl</code> object
0937: * as a <code>Collection</code> object. This method makes a copy of the
0938: * column's data and utilitizes the <code>Vector</code> to establish the
0939: * collection. The <code>Vector</code> class implements a growable array
0940: * objects allowing the individual components to be accessed using an
0941: * an integer index similar to that of an array.
0942: *
0943: * @return a <code>Collection</code> object that contains the value(s)
0944: * stored in the specified column of this
0945: * <code>CachedRowSetXImpl</code>
0946: * object
0947: * @throws SQLException if an error occurs generated the collection; or
0948: * an invalid column is provided.
0949: * @see #toCollection()
0950: * @see #toCollection(int)
0951: * @see java.util.Vector
0952: */
0953: public Collection toCollection(String column) throws SQLException {
0954: throw new UnsupportedOperationException();
0955: }
0956:
0957: //--------------------------------------------------------------------
0958: // Advanced features
0959: //--------------------------------------------------------------------
0960:
0961: /**
0962: * Returns the <code>SyncProvider</code> implementation being used
0963: * with this <code>CachedRowSetXImpl</code> implementation rowset.
0964: *
0965: * @return the SyncProvider used by the rowset. If not provider was
0966: * set when the rowset was instantiated, the reference
0967: * implementation (default) provider is returned.
0968: * @throws SQLException if error occurs while return the
0969: * <code>SyncProvider</code> instance.
0970: */
0971: public SyncProvider getSyncProvider() throws SQLException {
0972: throw new UnsupportedOperationException();
0973: }
0974:
0975: /**
0976: * Sets the active <code>SyncProvider</code> and attempts to load
0977: * load the new provider using the <code>SyncFactory</code> SPI.
0978: *
0979: * @throws SQLException if an error occurs while resetting the
0980: * <code>SyncProvider</code>.
0981: */
0982: public void setSyncProvider(String providerStr) throws SQLException {
0983: throw new UnsupportedOperationException();
0984: }
0985:
0986: //-----------------
0987: // methods inherited from RowSet
0988: //-----------------
0989:
0990: //---------------------------------------------------------------------
0991: // Reading and writing data
0992: //---------------------------------------------------------------------
0993:
0994: /**
0995: * Populates this <code>CachedRowSetXImpl</code> object with data.
0996: * This form of the method uses the rowset's user, password, and url or
0997: * data source name properties to create a database
0998: * connection. If properties that are needed
0999: * have not been set, this method will throw an exception.
1000: * <P>
1001: * Another form of this method uses an existing JDBC <code>Connection</code>
1002: * object instead of creating a new one; therefore, it ignores the
1003: * properties used for establishing a new connection.
1004: * <P>
1005: * The query specified by the command property is executed to create a
1006: * <code>ResultSet</code> object from which to retrieve data.
1007: * The current contents of the rowset are discarded, and the
1008: * rowset's metadata is also (re)set. If there are outstanding updates,
1009: * they are also ignored.
1010: * <P>
1011: * The method <code>execute</code> closes any database connections that it
1012: * creates.
1013: *
1014: * @throws SQLException if an error occurs or the
1015: * necessary properties have not been set
1016: */
1017: public void execute() throws SQLException {
1018: throw new UnsupportedOperationException();
1019: }
1020:
1021: //-----------------------------------
1022: // Methods inherited from ResultSet
1023: //-----------------------------------
1024:
1025: /**
1026: * Moves the cursor down one row from its current position and
1027: * returns <code>true</code> if the new cursor position is a
1028: * valid row.
1029: * The cursor for a new <code>ResultSet</code> object is initially
1030: * positioned before the first row. The first call to the method
1031: * <code>next</code> moves the cursor to the first row, making it
1032: * the current row; the second call makes the second row the
1033: * current row, and so on.
1034: *
1035: * <P>If an input stream from the previous row is open, it is
1036: * implicitly closed. The <code>ResultSet</code> object's warning
1037: * chain is cleared when a new row is read.
1038: *
1039: * @return <code>true</code> if the new current row is valid;
1040: * <code>false</code> if there are no more rows
1041: * @throws SQLException if an error occurs or
1042: * the cursor is not positioned in the rowset, before
1043: * the first row, or after the last row
1044: */
1045: public boolean next() throws SQLException {
1046: throw new UnsupportedOperationException();
1047: }
1048:
1049: /**
1050: * Moves this <code>CachedRowSetXImpl</code> object's cursor to the next
1051: * row and returns <code>true</code> if the cursor is still in the rowset;
1052: * returns <code>false</code> if the cursor has moved to the position after
1053: * the last row.
1054: * <P>
1055: * This method handles the cases where the cursor moves to a row that
1056: * has been deleted.
1057: * If this rowset shows deleted rows and the cursor moves to a row
1058: * that has been deleted, this method moves the cursor to the next
1059: * row until the cursor is on a row that has not been deleted.
1060: * <P>
1061: * The method <code>internalNext</code> is called by methods such as
1062: * <code>next</code>, <code>absolute</code>, and <code>relative</code>,
1063: * and, as its name implies, is only called internally.
1064: * <p>
1065: * This is a implementation only method and is not required as a standard
1066: * implementation of the <code>CachedRowSet</code> interface.
1067: *
1068: * @return <code>true</code> if the cursor is on a valid row in this
1069: * rowset; <code>false</code> if it is after the last row
1070: * @throws SQLException if an error occurs
1071: */
1072: protected boolean internalNext() throws SQLException {
1073: throw new UnsupportedOperationException();
1074: }
1075:
1076: /**
1077: * Closes this <code>CachedRowSetXImpl</code> objecy and releases any resources
1078: * it was using.
1079: *
1080: * @throws SQLException if an error occurs when releasing any resources in use
1081: * by this <code>CachedRowSetXImpl</code> object
1082: */
1083: public void close() {
1084: throw new UnsupportedOperationException();
1085: }
1086:
1087: /**
1088: * Reports whether the last column read was SQL <code>NULL</code>.
1089: * Note that you must first call the method <code>getXXX</code>
1090: * on a column to try to read its value and then call the method
1091: * <code>wasNull</code> to determine whether the value was
1092: * SQL <code>NULL</code>.
1093: *
1094: * @return <code>true</code> if the value in the last column read
1095: * was SQL <code>NULL</code>; <code>false</code> otherwise
1096: * @throws SQLException if an error occurs
1097: */
1098: public boolean wasNull() throws SQLException {
1099: throw new UnsupportedOperationException();
1100: }
1101:
1102: /**
1103: * Returns the insert row or the current row of this
1104: * <code>CachedRowSetXImpl</code>object.
1105: *
1106: * @return the <code>Row</code> object on which this <code>CachedRowSetXImpl</code>
1107: * objects's cursor is positioned
1108: */
1109: protected BaseRow getCurrentRow() {
1110: throw new UnsupportedOperationException();
1111: }
1112:
1113: /**
1114: * Removes the row on which the cursor is positioned.
1115: * <p>
1116: * This is a implementation only method and is not required as a standard
1117: * implementation of the <code>CachedRowSet</code> interface.
1118: *
1119: * @throws SQLException if the cursor is positioned on the insert
1120: * row
1121: */
1122: protected void removeCurrentRow() {
1123: throw new UnsupportedOperationException();
1124: }
1125:
1126: /**
1127: * Retrieves the value of the designated column in the current row
1128: * of this <code>CachedRowSetXImpl</code> object as a
1129: * <code>String</code> object.
1130: *
1131: * @param columnIndex the first column is <code>1</code>, the second
1132: * is <code>2</code>, and so on; must be <code>1</code> or larger
1133: * and equal to or less than the number of columns in the rowset
1134: * @return the column value; if the value is SQL <code>NULL</code>, the
1135: * result is <code>null</code>
1136: * @throws SQLException if (1) the given column index is out of bounds,
1137: * (2) the cursor is not on one of this rowset's rows or its
1138: * insert row, or (3) the designated column does not store an
1139: * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, REAL,
1140: * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, <b>CHAR</b>, <b>VARCHAR</b></code>
1141: * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1142: * recommended return type.
1143: */
1144: public String getString(int columnIndex) throws SQLException {
1145: throw new UnsupportedOperationException();
1146: }
1147:
1148: /**
1149: * Retrieves the value of the designated column in the current row
1150: * of this <code>CachedRowSetXImpl</code> object as a
1151: * <code>boolean</code> value.
1152: *
1153: * @param columnIndex the first column is <code>1</code>, the second
1154: * is <code>2</code>, and so on; must be <code>1</code> or larger
1155: * and equal to or less than the number of columns in the rowset
1156: * @return the column value as a <code>boolean</code> in the Java progamming language;
1157: * if the value is SQL <code>NULL</code>, the result is <code>false</code>
1158: * @throws SQLException if (1) the given column index is out of bounds,
1159: * (2) the cursor is not on one of this rowset's rows or its
1160: * insert row, or (3) the designated column does not store an
1161: * SQL <code>BOOLEAN</code> value
1162: * @see #getBoolean(String)
1163: */
1164: public boolean getBoolean(int columnIndex) throws SQLException {
1165: throw new UnsupportedOperationException();
1166: }
1167:
1168: /**
1169: * Retrieves the value of the designated column in the current row
1170: * of this <code>CachedRowSetXImpl</code> object as a
1171: * <code>byte</code> value.
1172: *
1173: * @param columnIndex the first column is <code>1</code>, the second
1174: * is <code>2</code>, and so on; must be <code>1</code> or larger
1175: * and equal to or less than the number of columns in the rowset
1176: * @return the column value as a <code>byte</code> in the Java programming
1177: * language; if the value is SQL <code>NULL</code>, the result is <code>0</code>
1178: * @throws SQLException if (1) the given column index is out of bounds,
1179: * (2) the cursor is not on one of this rowset's rows or its
1180: * insert row, or (3) the designated column does not store an
1181: * SQL <code><b>TINYINT</b>, SMALLINT, INTEGER, BIGINT, REAL,
1182: * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1183: * or <code>LONGVARCHAR</code> value. The bold SQL type
1184: * designates the recommended return type.
1185: * @see #getByte(String)
1186: */
1187: public byte getByte(int columnIndex) throws SQLException {
1188: throw new UnsupportedOperationException();
1189: }
1190:
1191: /**
1192: * Retrieves the value of the designated column in the current row
1193: * of this <code>CachedRowSetXImpl</code> object as a
1194: * <code>short</code> value.
1195: *
1196: * @param columnIndex the first column is <code>1</code>, the second
1197: * is <code>2</code>, and so on; must be <code>1</code> or larger
1198: * and equal to or less than the number of columns in the rowset
1199: * @return the column value; if the value is SQL <code>NULL</code>, the
1200: * result is <code>0</code>
1201: * @throws SQLException if (1) the given column index is out of bounds,
1202: * (2) the cursor is not on one of this rowset's rows or its
1203: * insert row, or (3) the designated column does not store an
1204: * SQL <code>TINYINT, <b>SMALLINT</b>, INTEGER, BIGINT, REAL
1205: * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1206: * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1207: * recommended return type.
1208: * @see #getShort(String)
1209: */
1210: public short getShort(int columnIndex) throws SQLException {
1211: throw new UnsupportedOperationException();
1212: }
1213:
1214: /**
1215: * Retrieves the value of the designated column in the current row
1216: * of this <code>CachedRowSetXImpl</code> object as an
1217: * <code>int</code> value.
1218: *
1219: * @param columnIndex the first column is <code>1</code>, the second
1220: * is <code>2</code>, and so on; must be <code>1</code> or larger
1221: * and equal to or less than the number of columns in the rowset
1222: * @return the column value; if the value is SQL <code>NULL</code>, the
1223: * result is <code>0</code>
1224: * @throws SQLException if (1) the given column index is out of bounds,
1225: * (2) the cursor is not on one of this rowset's rows or its
1226: * insert row, or (3) the designated column does not store an
1227: * SQL <code>TINYINT, SMALLINT, <b>INTEGER</b>, BIGINT, REAL
1228: * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1229: * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1230: * recommended return type.
1231: */
1232: public int getInt(int columnIndex) throws SQLException {
1233: throw new UnsupportedOperationException();
1234: }
1235:
1236: /**
1237: * Retrieves the value of the designated column in the current row
1238: * of this <code>CachedRowSetXImpl</code> object as a
1239: * <code>long</code> value.
1240: *
1241: * @param columnIndex the first column is <code>1</code>, the second
1242: * is <code>2</code>, and so on; must be <code>1</code> or larger
1243: * and equal to or less than the number of columns in the rowset
1244: * @return the column value; if the value is SQL <code>NULL</code>, the
1245: * result is <code>0</code>
1246: * @throws SQLException if (1) the given column index is out of bounds,
1247: * (2) the cursor is not on one of this rowset's rows or its
1248: * insert row, or (3) the designated column does not store an
1249: * SQL <code>TINYINT, SMALLINT, INTEGER, <b>BIGINT</b>, REAL
1250: * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1251: * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1252: * recommended return type.
1253: * @see #getLong(String)
1254: */
1255: public long getLong(int columnIndex) throws SQLException {
1256: throw new UnsupportedOperationException();
1257: }
1258:
1259: /**
1260: * Retrieves the value of the designated column in the current row
1261: * of this <code>CachedRowSetXImpl</code> object as a
1262: * <code>float</code> value.
1263: *
1264: * @param columnIndex the first column is <code>1</code>, the second
1265: * is <code>2</code>, and so on; must be <code>1</code> or larger
1266: * and equal to or less than the number of columns in the rowset
1267: * @return the column value; if the value is SQL <code>NULL</code>, the
1268: * result is <code>0</code>
1269: * @throws SQLException if (1) the given column index is out of bounds,
1270: * (2) the cursor is not on one of this rowset's rows or its
1271: * insert row, or (3) the designated column does not store an
1272: * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, <b>REAL</b>,
1273: * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1274: * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1275: * recommended return type.
1276: * @see #getFloat(String)
1277: */
1278: public float getFloat(int columnIndex) throws SQLException {
1279: throw new UnsupportedOperationException();
1280: }
1281:
1282: /**
1283: * Retrieves the value of the designated column in the current row
1284: * of this <code>CachedRowSetXImpl</code> object as a
1285: * <code>double</code> value.
1286: *
1287: * @param columnIndex the first column is <code>1</code>, the second
1288: * is <code>2</code>, and so on; must be <code>1</code> or larger
1289: * and equal to or less than the number of columns in the rowset
1290: * @return the column value; if the value is SQL <code>NULL</code>, the
1291: * result is <code>0</code>
1292: * @throws SQLException if (1) the given column index is out of bounds,
1293: * (2) the cursor is not on one of this rowset's rows or its
1294: * insert row, or (3) the designated column does not store an
1295: * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, REAL,
1296: * <b>FLOAT</b>, <b>DOUBLE</b>, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1297: * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1298: * recommended return type.
1299: * @see #getDouble(String)
1300: *
1301: */
1302: public double getDouble(int columnIndex) throws SQLException {
1303: throw new UnsupportedOperationException();
1304: }
1305:
1306: /**
1307: * Retrieves the value of the designated column in the current row
1308: * of this <code>CachedRowSetXImpl</code> object as a
1309: * <code>java.math.BigDecimal</code> object.
1310: * <P>
1311: * This method is deprecated; use the version of <code>getBigDecimal</code>
1312: * that does not take a scale parameter and returns a value with full
1313: * precision.
1314: *
1315: * @param columnIndex the first column is <code>1</code>, the second
1316: * is <code>2</code>, and so on; must be <code>1</code> or larger
1317: * and equal to or less than the number of columns in the rowset
1318: * @param scale the number of digits to the right of the decimal point in the
1319: * value returned
1320: * @return the column value with the specified number of digits to the right
1321: * of the decimal point; if the value is SQL <code>NULL</code>, the
1322: * result is <code>null</code>
1323: * @throws SQLException if the given column index is out of bounds,
1324: * the cursor is not on a valid row, or this method fails
1325: * @deprecated
1326: */
1327: public BigDecimal getBigDecimal(int columnIndex, int scale)
1328: throws SQLException {
1329: throw new UnsupportedOperationException();
1330: }
1331:
1332: /**
1333: * Retrieves the value of the designated column in the current row
1334: * of this <code>CachedRowSetXImpl</code> object as a
1335: * <code>byte</code> array value.
1336: *
1337: * @param columnIndex the first column is <code>1</code>, the second
1338: * is <code>2</code>, and so on; must be <code>1</code> or larger
1339: * and equal to or less than the number of columns in the rowset
1340: * @return the column value as a <code>byte</code> array in the Java programming
1341: * language; if the value is SQL <code>NULL</code>, the
1342: * result is <code>null</code>
1343: *
1344: * @throws SQLException if (1) the given column index is out of bounds,
1345: * (2) the cursor is not on one of this rowset's rows or its
1346: * insert row, or (3) the designated column does not store an
1347: * SQL <code><b>BINARY</b>, <b>VARBINARY</b> or
1348: * LONGVARBINARY</code> value.
1349: * The bold SQL type designates the recommended return type.
1350: * @see #getBytes(String)
1351: */
1352: public byte[] getBytes(int columnIndex) throws SQLException {
1353: throw new UnsupportedOperationException();
1354: }
1355:
1356: /**
1357: * Retrieves the value of the designated column in the current row
1358: * of this <code>CachedRowSetXImpl</code> object as a
1359: * <code>java.sql.Date</code> object.
1360: *
1361: * @param columnIndex the first column is <code>1</code>, the second
1362: * is <code>2</code>, and so on; must be <code>1</code> or larger
1363: * and equal to or less than the number of columns in the rowset
1364: * @return the column value as a <code>java.sql.Data</code> object; if
1365: * the value is SQL <code>NULL</code>, the
1366: * result is <code>null</code>
1367: * @throws SQLException if the given column index is out of bounds,
1368: * the cursor is not on a valid row, or this method fails
1369: */
1370: public java.sql.Date getDate(int columnIndex) throws SQLException {
1371: throw new UnsupportedOperationException();
1372: }
1373:
1374: /**
1375: * Retrieves the value of the designated column in the current row
1376: * of this <code>CachedRowSetXImpl</code> object as a
1377: * <code>java.sql.Time</code> object.
1378: *
1379: * @param columnIndex the first column is <code>1</code>, the second
1380: * is <code>2</code>, and so on; must be <code>1</code> or larger
1381: * and equal to or less than the number of columns in the rowset
1382: * @return the column value; if the value is SQL <code>NULL</code>, the
1383: * result is <code>null</code>
1384: * @throws SQLException if the given column index is out of bounds,
1385: * the cursor is not on a valid row, or this method fails
1386: */
1387: public java.sql.Time getTime(int columnIndex) throws SQLException {
1388: throw new UnsupportedOperationException();
1389: }
1390:
1391: /**
1392: * Retrieves the value of the designated column in the current row
1393: * of this <code>CachedRowSetXImpl</code> object as a
1394: * <code>java.sql.Timestamp</code> object.
1395: *
1396: * @param columnIndex the first column is <code>1</code>, the second
1397: * is <code>2</code>, and so on; must be <code>1</code> or larger
1398: * and equal to or less than the number of columns in the rowset
1399: * @return the column value; if the value is SQL <code>NULL</code>, the
1400: * result is <code>null</code>
1401: * @throws SQLException if the given column index is out of bounds,
1402: * the cursor is not on a valid row, or this method fails
1403: */
1404: public java.sql.Timestamp getTimestamp(int columnIndex)
1405: throws SQLException {
1406: throw new UnsupportedOperationException();
1407: }
1408:
1409: /**
1410: * Retrieves the value of the designated column in the current row of this
1411: * <code>CachedRowSetXImpl</code> object as a <code>java.io.InputStream</code>
1412: * object.
1413: *
1414: * A column value can be retrieved as a stream of ASCII characters
1415: * and then read in chunks from the stream. This method is particularly
1416: * suitable for retrieving large <code>LONGVARCHAR</code> values. The JDBC
1417: * driver will do any necessary conversion from the database format into ASCII.
1418: *
1419: * <P><B>Note:</B> All the data in the returned stream must be
1420: * read prior to getting the value of any other column. The next
1421: * call to a get method implicitly closes the stream. . Also, a
1422: * stream may return <code>0</code> for <code>CachedRowSetXImpl.available()</code>
1423: * whether there is data available or not.
1424: *
1425: * @param columnIndex the first column is <code>1</code>, the second
1426: * is <code>2</code>, and so on; must be <code>1</code> or larger
1427: * and equal to or less than the number of columns in this rowset
1428: * @return a Java input stream that delivers the database column value
1429: * as a stream of one-byte ASCII characters. If the value is SQL
1430: * <code>NULL</code>, the result is <code>null</code>.
1431: * @throws SQLException if (1) the given column index is out of bounds,
1432: * (2) the cursor is not on one of this rowset's rows or its
1433: * insert row, or (3) the designated column does not store an
1434: * SQL <code>CHAR, VARCHAR</code>, <code><b>LONGVARCHAR</b></code>
1435: * <code>BINARY, VARBINARY</code> or <code>LONGVARBINARY</code> value. The
1436: * bold SQL type designates the recommended return types that this method is
1437: * used to retrieve.
1438: * @see #getAsciiStream(String)
1439: */
1440: public java.io.InputStream getAsciiStream(int columnIndex)
1441: throws SQLException {
1442: throw new UnsupportedOperationException();
1443: }
1444:
1445: /**
1446: * A column value can be retrieved as a stream of Unicode characters
1447: * and then read in chunks from the stream. This method is particularly
1448: * suitable for retrieving large LONGVARCHAR values. The JDBC driver will
1449: * do any necessary conversion from the database format into Unicode.
1450: *
1451: * <P><B>Note:</B> All the data in the returned stream must be
1452: * read prior to getting the value of any other column. The next
1453: * call to a get method implicitly closes the stream. . Also, a
1454: * stream may return 0 for available() whether there is data
1455: * available or not.
1456: *
1457: * @param columnIndex the first column is <code>1</code>, the second
1458: * is <code>2</code>, and so on; must be <code>1</code> or larger
1459: * and equal to or less than the number of columns in this rowset
1460: * @return a Java input stream that delivers the database column value
1461: * as a stream of two byte Unicode characters. If the value is SQL NULL
1462: * then the result is null.
1463: * @throws SQLException if an error occurs
1464: * @deprecated
1465: */
1466: public java.io.InputStream getUnicodeStream(int columnIndex)
1467: throws SQLException {
1468: throw new UnsupportedOperationException();
1469: }
1470:
1471: /**
1472: * Retrieves the value of the designated column in the current row of this
1473: * <code>CachedRowSetXImpl</code> object as a <code>java.io.InputStream</code>
1474: * object.
1475: * <P>
1476: * A column value can be retrieved as a stream of uninterpreted bytes
1477: * and then read in chunks from the stream. This method is particularly
1478: * suitable for retrieving large <code>LONGVARBINARY</code> values.
1479: *
1480: * <P><B>Note:</B> All the data in the returned stream must be
1481: * read prior to getting the value of any other column. The next
1482: * call to a get method implicitly closes the stream. Also, a
1483: * stream may return <code>0</code> for
1484: * <code>CachedRowSetXImpl.available()</code> whether there is data
1485: * available or not.
1486: *
1487: * @param columnIndex the first column is <code>1</code>, the second
1488: * is <code>2</code>, and so on; must be <code>1</code> or larger
1489: * and equal to or less than the number of columns in the rowset
1490: * @return a Java input stream that delivers the database column value
1491: * as a stream of uninterpreted bytes. If the value is SQL <code>NULL</code>
1492: * then the result is <code>null</code>.
1493: * @throws SQLException if (1) the given column index is out of bounds,
1494: * (2) the cursor is not on one of this rowset's rows or its
1495: * insert row, or (3) the designated column does not store an
1496: * SQL <code>BINARY, VARBINARY</code> or <code><b>LONGVARBINARY</b></code>
1497: * The bold type indicates the SQL type that this method is recommened
1498: * to retrieve.
1499: * @see #getBinaryStream(String)
1500: */
1501: public java.io.InputStream getBinaryStream(int columnIndex)
1502: throws SQLException {
1503: throw new UnsupportedOperationException();
1504:
1505: }
1506:
1507: //======================================================================
1508: // Methods for accessing results by column name
1509: //======================================================================
1510:
1511: /**
1512: * Retrieves the value stored in the designated column
1513: * of the current row as a <code>String</code> object.
1514: *
1515: * @param columnName a <code>String</code> object giving the SQL name of
1516: * a column in this <code>CachedRowSetXImpl</code> object
1517: * @return the column value; if the value is SQL <code>NULL</code>,
1518: * the result is <code>null</code>
1519: * @throws SQLException if (1) the given column name is not the name of
1520: * a column in this rowset, (2) the cursor is not on one of
1521: * this rowset's rows or its insert row, or (3) the designated
1522: * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
1523: * BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, <b>CHAR</b>,
1524: * <b>VARCHAR</b></code> or <code>LONGVARCHAR<</code> value. The bold SQL type
1525: * designates the recommended return type.
1526: */
1527: public String getString(String columnName) throws SQLException {
1528: throw new UnsupportedOperationException();
1529: }
1530:
1531: /**
1532: * Retrieves the value stored in the designated column
1533: * of the current row as a <code>boolean</code> value.
1534: *
1535: * @param columnName a <code>String</code> object giving the SQL name of
1536: * a column in this <code>CachedRowSetXImpl</code> object
1537: * @return the column value as a <code>boolean</code> in the Java programming
1538: * language; if the value is SQL <code>NULL</code>,
1539: * the result is <code>false</code>
1540: * @throws SQLException if (1) the given column name is not the name of
1541: * a column in this rowset, (2) the cursor is not on one of
1542: * this rowset's rows or its insert row, or (3) the designated
1543: * column does not store an SQL <code>BOOLEAN</code> value
1544: * @see #getBoolean(int)
1545: */
1546: public boolean getBoolean(String columnName) throws SQLException {
1547: throw new UnsupportedOperationException();
1548: }
1549:
1550: /**
1551: * Retrieves the value stored in the designated column
1552: * of the current row as a <code>byte</code> value.
1553: *
1554: * @param columnName a <code>String</code> object giving the SQL name of
1555: * a column in this <code>CachedRowSetXImpl</code> object
1556: * @return the column value as a <code>byte</code> in the Java programming
1557: * language; if the value is SQL <code>NULL</code>, the result is <code>0</code>
1558: * @throws SQLException if (1) the given column name is not the name of
1559: * a column in this rowset, (2) the cursor is not on one of
1560: * this rowset's rows or its insert row, or (3) the designated
1561: * column does not store an SQL <code><B>TINYINT</B>, SMALLINT, INTEGER,
1562: * BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
1563: * VARCHAR</code> or <code>LONGVARCHAR</code> value. The
1564: * bold type designates the recommended return type
1565: */
1566: public byte getByte(String columnName) throws SQLException {
1567: throw new UnsupportedOperationException();
1568: }
1569:
1570: /**
1571: * Retrieves the value stored in the designated column
1572: * of the current row as a <code>short</code> value.
1573: *
1574: * @param columnName a <code>String</code> object giving the SQL name of
1575: * a column in this <code>CachedRowSetXImpl</code> object
1576: * @return the column value; if the value is SQL <code>NULL</code>,
1577: * the result is <code>0</code>
1578: * @throws SQLException if (1) the given column name is not the name of
1579: * a column in this rowset, (2) the cursor is not on one of
1580: * this rowset's rows or its insert row, or (3) the designated
1581: * column does not store an SQL <code>TINYINT, <b>SMALLINT</b>, INTEGER
1582: * BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
1583: * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
1584: * designates the recommended return type.
1585: * @see #getShort(int)
1586: */
1587: public short getShort(String columnName) throws SQLException {
1588: throw new UnsupportedOperationException();
1589: }
1590:
1591: /**
1592: * Retrieves the value stored in the designated column
1593: * of the current row as an <code>int</code> value.
1594: *
1595: * @param columnName a <code>String</code> object giving the SQL name of
1596: * a column in this <code>CachedRowSetXImpl</code> object
1597: * @return the column value; if the value is SQL <code>NULL</code>,
1598: * the result is <code>0</code>
1599: * @throws SQLException if (1) the given column name is not the name
1600: * of a column in this rowset,
1601: * (2) the cursor is not on one of this rowset's rows or its
1602: * insert row, or (3) the designated column does not store an
1603: * SQL <code>TINYINT, SMALLINT, <b>INTEGER</b>, BIGINT, REAL
1604: * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code>
1605: * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
1606: * recommended return type.
1607: */
1608: public int getInt(String columnName) throws SQLException {
1609: throw new UnsupportedOperationException();
1610: }
1611:
1612: /**
1613: * Retrieves the value stored in the designated column
1614: * of the current row as a <code>long</code> value.
1615: *
1616: * @param columnName a <code>String</code> object giving the SQL name of
1617: * a column in this <code>CachedRowSetXImpl</code> object
1618: * @return the column value; if the value is SQL <code>NULL</code>,
1619: * the result is <code>0</code>
1620: * @throws SQLException if (1) the given column name is not the name of
1621: * a column in this rowset, (2) the cursor is not on one of
1622: * this rowset's rows or its insert row, or (3) the designated
1623: * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
1624: * <b>BIGINT</b>, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
1625: * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
1626: * designates the recommended return type.
1627: * @see #getLong(int)
1628: */
1629: public long getLong(String columnName) throws SQLException {
1630: throw new UnsupportedOperationException();
1631: }
1632:
1633: /**
1634: * Retrieves the value stored in the designated column
1635: * of the current row as a <code>float</code> value.
1636: *
1637: * @param columnName a <code>String</code> object giving the SQL name of
1638: * a column in this <code>CachedRowSetXImpl</code> object
1639: * @return the column value; if the value is SQL <code>NULL</code>,
1640: * the result is <code>0</code>
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, <b>REAL</b>, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR,
1646: * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
1647: * designates the recommended return type.
1648: * @see #getFloat(String)
1649: */
1650: public float getFloat(String columnName) throws SQLException {
1651: throw new UnsupportedOperationException();
1652: }
1653:
1654: /**
1655: * Retrieves the value stored in the designated column
1656: * of the current row of this <code>CachedRowSetXImpl</code> object
1657: * as a <code>double</code> value.
1658: *
1659: * @param columnName a <code>String</code> object giving the SQL name of
1660: * a column in this <code>CachedRowSetXImpl</code> object
1661: * @return the column value; if the value is SQL <code>NULL</code>,
1662: * the result is <code>0</code>
1663: * @throws SQLException if (1) the given column name is not the name of
1664: * a column in this rowset, (2) the cursor is not on one of
1665: * this rowset's rows or its insert row, or (3) the designated
1666: * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
1667: * BIGINT, REAL, <b>FLOAT</b>, <b>DOUBLE</b>, DECIMAL, NUMERIC, BIT, CHAR,
1668: * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
1669: * designates the recommended return types.
1670: * @see #getDouble(int)
1671: */
1672: public double getDouble(String columnName) throws SQLException {
1673: throw new UnsupportedOperationException();
1674: }
1675:
1676: /**
1677: * Retrieves the value stored in the designated column
1678: * of the current row as a <code>java.math.BigDecimal</code> object.
1679: *
1680: * @param columnName a <code>String</code> object giving the SQL name of
1681: * a column in this <code>CachedRowSetXImpl</code> object
1682: * @param scale the number of digits to the right of the decimal point
1683: * @return a java.math.BugDecimal object with <code><i>scale</i></code>
1684: * number of digits to the right of the decimal point.
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>TINYINT, SMALLINT, INTEGER
1689: * BIGINT, REAL, FLOAT, DOUBLE, <b>DECIMAL</b>, <b>NUMERIC</b>, BIT CHAR,
1690: * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
1691: * designates the recommended return type that this method is used to
1692: * retrieve.
1693: * @deprecated Use the <code>getBigDecimal(String columnName)</code>
1694: * method instead
1695: */
1696: public BigDecimal getBigDecimal(String columnName, int scale)
1697: throws SQLException {
1698: throw new UnsupportedOperationException();
1699: }
1700:
1701: /**
1702: * Retrieves the value stored in the designated column
1703: * of the current row as a <code>byte</code> array.
1704: * The bytes represent the raw values returned by the driver.
1705: *
1706: * @param columnName a <code>String</code> object giving the SQL name of
1707: * a column in this <code>CachedRowSetXImpl</code> object
1708: * @return the column value as a <code>byte</code> array in the Java programming
1709: * language; if the value is SQL <code>NULL</code>, the result is <code>null</code>
1710: * @throws SQLException if (1) the given column name is not the name of
1711: * a column in this rowset, (2) the cursor is not on one of
1712: * this rowset's rows or its insert row, or (3) the designated
1713: * column does not store an SQL <code><b>BINARY</b>, <b>VARBINARY</b>
1714: * </code> or <code>LONGVARBINARY</code> values
1715: * The bold SQL type designates the recommended return type.
1716: * @see #getBytes(int)
1717: */
1718: public byte[] getBytes(String columnName) throws SQLException {
1719: throw new UnsupportedOperationException();
1720: }
1721:
1722: /**
1723: * Retrieves the value stored in the designated column
1724: * of the current row as a <code>java.sql.Date</code> object.
1725: *
1726: * @param columnName a <code>String</code> object giving the SQL name of
1727: * a column in this <code>CachedRowSetXImpl</code> object
1728: * @return the column value; if the value is SQL <code>NULL</code>,
1729: * the result is <code>null</code>
1730: * @throws SQLException if (1) the given column name is not the name of
1731: * a column in this rowset, (2) the cursor is not on one of
1732: * this rowset's rows or its insert row, or (3) the designated
1733: * column does not store an SQL <code>DATE</code> or
1734: * <code>TIMESTAMP</code> value
1735: */
1736: public java.sql.Date getDate(String columnName) throws SQLException {
1737: throw new UnsupportedOperationException();
1738: }
1739:
1740: /**
1741: * Retrieves the value stored in the designated column
1742: * of the current row as a <code>java.sql.Time</code> object.
1743: *
1744: * @param columnName a <code>String</code> object giving the SQL name of
1745: * a column in this <code>CachedRowSetXImpl</code> object
1746: * @return the column value; if the value is SQL <code>NULL</code>,
1747: * the result is <code>null</code>
1748: * @throws SQLException if the given column name does not match one of
1749: * this rowset's column names or the cursor is not on one of
1750: * this rowset's rows or its insert row
1751: */
1752: public java.sql.Time getTime(String columnName) throws SQLException {
1753: throw new UnsupportedOperationException();
1754: }
1755:
1756: /**
1757: * Retrieves the value stored in the designated column
1758: * of the current row as a <code>java.sql.Timestamp</code> object.
1759: *
1760: * @param columnName a <code>String</code> object giving the SQL name of
1761: * a column in this <code>CachedRowSetXImpl</code> object
1762: * @return the column value; if the value is SQL <code>NULL</code>,
1763: * the result is <code>null</code>
1764: * @throws SQLException if the given column name does not match one of
1765: * this rowset's column names or the cursor is not on one of
1766: * this rowset's rows or its insert row
1767: */
1768: public java.sql.Timestamp getTimestamp(String columnName)
1769: throws SQLException {
1770: throw new UnsupportedOperationException();
1771: }
1772:
1773: /**
1774: * Retrieves the value of the designated column in the current row of this
1775: * <code>CachedRowSetXImpl</code> object as a <code>java.io.InputStream</code>
1776: * object.
1777: *
1778: * A column value can be retrieved as a stream of ASCII characters
1779: * and then read in chunks from the stream. This method is particularly
1780: * suitable for retrieving large <code>LONGVARCHAR</code> values. The
1781: * <code>SyncProvider</code> will rely on the JDBC driver to do any necessary
1782: * conversion from the database format into ASCII format.
1783: *
1784: * <P><B>Note:</B> All the data in the returned stream must
1785: * be read prior to getting the value of any other column. The
1786: * next call to a <code>getXXX</code> method implicitly closes the stream.
1787: *
1788: * @param columnName a <code>String</code> object giving the SQL name of
1789: * a column in this <code>CachedRowSetXImpl</code> object
1790: * @return a Java input stream that delivers the database column value
1791: * as a stream of one-byte ASCII characters. If the value is SQL
1792: * <code>NULL</code>, the result is <code>null</code>.
1793: * @throws SQLException if (1) the given column name is not the name of
1794: * a column in this rowset
1795: * (2) the cursor is not on one of this rowset's rows or its
1796: * insert row, or (3) the designated column does not store an
1797: * SQL <code>CHAR, VARCHAR</code>, <code><b>LONGVARCHAR</b></code>
1798: * <code>BINARY, VARBINARY</code> or <code>LONGVARBINARY</code> value. The
1799: * bold SQL type designates the recommended return types that this method is
1800: * used to retrieve.
1801: * @see #getAsciiStream(int)
1802: */
1803: public java.io.InputStream getAsciiStream(String columnName)
1804: throws SQLException {
1805: throw new UnsupportedOperationException();
1806:
1807: }
1808:
1809: /**
1810: * A column value can be retrieved as a stream of Unicode characters
1811: * and then read in chunks from the stream. This method is particularly
1812: * suitable for retrieving large <code>LONGVARCHAR</code> values.
1813: * The JDBC driver will do any necessary conversion from the database
1814: * format into Unicode.
1815: *
1816: * <P><B>Note:</B> All the data in the returned stream must
1817: * be read prior to getting the value of any other column. The
1818: * next call to a <code>getXXX</code> method implicitly closes the stream.
1819: *
1820: * @param columnName a <code>String</code> object giving the SQL name of
1821: * a column in this <code>CachedRowSetXImpl</code> object
1822: * @return a Java input stream that delivers the database column value
1823: * as a stream of two-byte Unicode characters. If the value is
1824: * SQL <code>NULL</code>, the result is <code>null</code>.
1825: * @throws SQLException if the given column name does not match one of
1826: * this rowset's column names or the cursor is not on one of
1827: * this rowset's rows or its insert row
1828: * @deprecated use the method <code>getCharacterStream</code> instead
1829: */
1830: public java.io.InputStream getUnicodeStream(String columnName)
1831: throws SQLException {
1832: throw new UnsupportedOperationException();
1833: }
1834:
1835: /**
1836: * Retrieves the value of the designated column in the current row of this
1837: * <code>CachedRowSetXImpl</code> object as a <code>java.io.InputStream</code>
1838: * object.
1839: * <P>
1840: * A column value can be retrieved as a stream of uninterpreted bytes
1841: * and then read in chunks from the stream. This method is particularly
1842: * suitable for retrieving large <code>LONGVARBINARY</code> values.
1843: *
1844: * <P><B>Note:</B> All the data in the returned stream must be
1845: * read prior to getting the value of any other column. The next
1846: * call to a get method implicitly closes the stream. Also, a
1847: * stream may return <code>0</code> for <code>CachedRowSetXImpl.available()</code>
1848: * whether there is data available or not.
1849: *
1850: * @param columnName a <code>String</code> object giving the SQL name of
1851: * a column in this <code>CachedRowSetXImpl</code> object
1852: * @return a Java input stream that delivers the database column value
1853: * as a stream of uninterpreted bytes. If the value is SQL
1854: * <code>NULL</code>, the result is <code>null</code>.
1855: * @throws SQLException if (1) the given column name is unknown,
1856: * (2) the cursor is not on one of this rowset's rows or its
1857: * insert row, or (3) the designated column does not store an
1858: * SQL <code>BINARY, VARBINARY</code> or <code><b>LONGVARBINARY</b></code>
1859: * The bold type indicates the SQL type that this method is recommened
1860: * to retrieve.
1861: * @see #getBinaryStream(int)
1862: *
1863: */
1864: public java.io.InputStream getBinaryStream(String columnName)
1865: throws SQLException {
1866: throw new UnsupportedOperationException();
1867: }
1868:
1869: //=====================================================================
1870: // Advanced features:
1871: //=====================================================================
1872:
1873: /**
1874: * The first warning reported by calls on this <code>CachedRowSetXImpl</code>
1875: * object is returned. Subsequent <code>CachedRowSetXImpl</code> warnings will
1876: * be chained to this <code>SQLWarning</code>.
1877: *
1878: * <P>The warning chain is automatically cleared each time a new
1879: * row is read.
1880: *
1881: * <P><B>Note:</B> This warning chain only covers warnings caused
1882: * by <code>ResultSet</code> methods. Any warning caused by statement
1883: * methods (such as reading OUT parameters) will be chained on the
1884: * <code>Statement</code> object.
1885: *
1886: * @return the first SQLWarning or null
1887: */
1888: public SQLWarning getWarnings() {
1889: throw new UnsupportedOperationException();
1890: }
1891:
1892: /**
1893: * Clears all the warnings reporeted for the <code>CachedRowSetXImpl</code>
1894: * object. After a call to this method, the <code>getWarnings</code> method
1895: * returns <code>null</code> until a new warning is reported for this
1896: * <code>CachedRowSetXImpl</code> object.
1897: */
1898: public void clearWarnings() {
1899: throw new UnsupportedOperationException();
1900: }
1901:
1902: /**
1903: * Retrieves the name of the SQL cursor used by this
1904: * <code>CachedRowSetXImpl</code> object.
1905: *
1906: * <P>In SQL, a result table is retrieved through a cursor that is
1907: * named. The current row of a <code>ResultSet</code> can be updated or deleted
1908: * using a positioned update/delete statement that references the
1909: * cursor name. To ensure that the cursor has the proper isolation
1910: * level to support an update operation, the cursor's <code>SELECT</code>
1911: * statement should be of the form <code>select for update</code>.
1912: * If the <code>for update</code> clause
1913: * is omitted, positioned updates may fail.
1914: *
1915: * <P>JDBC supports this SQL feature by providing the name of the
1916: * SQL cursor used by a <code>ResultSet</code> object. The current row
1917: * of a result set is also the current row of this SQL cursor.
1918: *
1919: * <P><B>Note:</B> If positioned updates are not supported, an
1920: * <code>SQLException</code> is thrown.
1921: *
1922: * @return the SQL cursor name for this <code>CachedRowSetXImpl</code> object's
1923: * cursor
1924: * @throws SQLException if an error occurs
1925: */
1926: public String getCursorName() throws SQLException {
1927: throw new UnsupportedOperationException();
1928: }
1929:
1930: /**
1931: * Retrieves a <code>ResultSetMetaData</code> object instance that
1932: * contains information about the <code>CachedRowSet</code> object.
1933: * However, applications should cast the returned object to a
1934: * <code>RowSetMetaData</code> interface implementation. In the
1935: * reference implementation, this cast can be done on the
1936: * <code>RowSetMetaDataXImpl</code> class.
1937: * <P>
1938: * For example:
1939: * <pre>
1940: * CachedRowSet crs = new CachedRowSetXImpl();
1941: * RowSetMetaDataXImpl metaData =
1942: * (RowSetMetaDataXImpl)crs.getMetaData();
1943: * // Set the number of columns in the RowSet object for
1944: * // which this RowSetMetaDataXImpl object was created to the
1945: * // given number.
1946: * metaData.setColumnCount(3);
1947: * crs.setMetaData(metaData);
1948: * </pre>
1949: *
1950: * @return the <code>ResultSetMetaData</code> object that describes this
1951: * <code>CachedRowSetXImpl</code> object's columns
1952: * @throws SQLException if an error occurs in generating the RowSet
1953: * meta data; or if the <code>CachedRowSetXImpl</code> is empty.
1954: * @see javax.sql.RowSetMetaData
1955: */
1956: public ResultSetMetaData getMetaData() throws SQLException {
1957: throw new UnsupportedOperationException();
1958: }
1959:
1960: /**
1961: * Retrieves the value of the designated column in the current row
1962: * of this <code>CachedRowSetXImpl</code> object as an
1963: * <code>Object</code> value.
1964: * <P>
1965: * The type of the <code>Object</code> will be the default
1966: * Java object type corresponding to the column's SQL type,
1967: * following the mapping for built-in types specified in the JDBC 3.0
1968: * specification.
1969: * <P>
1970: * This method may also be used to read datatabase-specific
1971: * abstract data types.
1972: * <P>
1973: * This implementation of the method <code>getObject</code> extends its
1974: * behavior so that it gets the attributes of an SQL structured type
1975: * as an array of <code>Object</code> values. This method also custom
1976: * maps SQL user-defined types to classes in the Java programming language.
1977: * When the specified column contains
1978: * a structured or distinct value, the behavior of this method is as
1979: * if it were a call to the method <code>getObject(columnIndex,
1980: * this.getStatement().getConnection().getTypeMap())</code>.
1981: *
1982: * @param columnIndex the first column is <code>1</code>, the second
1983: * is <code>2</code>, and so on; must be <code>1</code> or larger
1984: * and equal to or less than the number of columns in the rowset
1985: * @return a <code>java.lang.Object</code> holding the column value;
1986: * if the value is SQL <code>NULL</code>, the result is <code>null</code>
1987: * @throws SQLException if the given column index is out of bounds,
1988: * the cursor is not on a valid row, or there is a problem getting
1989: * the <code>Class</code> object for a custom mapping
1990: * @see #getObject(String)
1991: */
1992: public Object getObject(int columnIndex) throws SQLException {
1993: throw new UnsupportedOperationException();
1994: }
1995:
1996: /**
1997: * Retrieves the value of the designated column in the current row
1998: * of this <code>CachedRowSetXImpl</code> object as an
1999: * <code>Object</code> value.
2000: * <P>
2001: * The type of the <code>Object</code> will be the default
2002: * Java object type corresponding to the column's SQL type,
2003: * following the mapping for built-in types specified in the JDBC 3.0
2004: * specification.
2005: * <P>
2006: * This method may also be used to read datatabase-specific
2007: * abstract data types.
2008: * <P>
2009: * This implementation of the method <code>getObject</code> extends its
2010: * behavior so that it gets the attributes of an SQL structured type
2011: * as an array of <code>Object</code> values. This method also custom
2012: * maps SQL user-defined types to classes
2013: * in the Java programming language. When the specified column contains
2014: * a structured or distinct value, the behavior of this method is as
2015: * if it were a call to the method <code>getObject(columnIndex,
2016: * this.getStatement().getConnection().getTypeMap())</code>.
2017: *
2018: * @param columnName a <code>String</code> object that must match the
2019: * SQL name of a column in this rowset, ignoring case
2020: * @return a <code>java.lang.Object</code> holding the column value;
2021: * if the value is SQL <code>NULL</code>, the result is <code>null</code>
2022: * @throws SQLException if (1) the given column name does not match one of
2023: * this rowset's column names, (2) the cursor is not
2024: * on a valid row, or (3) there is a problem getting
2025: * the <code>Class</code> object for a custom mapping
2026: * @see #getObject(int)
2027: */
2028: public Object getObject(String columnName) throws SQLException {
2029: throw new UnsupportedOperationException();
2030: }
2031:
2032: //----------------------------------------------------------------
2033:
2034: /**
2035: * Maps the given column name for one of this <code>CachedRowSetXImpl</code>
2036: * object's columns to its column number.
2037: *
2038: * @param columnName a <code>String</code> object that must match the
2039: * SQL name of a column in this rowset, ignoring case
2040: * @return the column index of the given column name
2041: * @throws SQLException if the given column name does not match one
2042: * of this rowset's column names
2043: */
2044: public int findColumn(String columnName) throws SQLException {
2045: throw new UnsupportedOperationException();
2046: }
2047:
2048: //--------------------------JDBC 2.0-----------------------------------
2049:
2050: //---------------------------------------------------------------------
2051: // Getter's and Setter's
2052: //---------------------------------------------------------------------
2053:
2054: /**
2055: * Retrieves the value stored in the designated column
2056: * of the current row as a <code>java.io.Reader</code> object.
2057: *
2058: * <P><B>Note:</B> All the data in the returned stream must
2059: * be read prior to getting the value of any other column. The
2060: * next call to a <code>getXXX</code> method implicitly closes the stream.
2061: *
2062: * @param columnIndex the first column is <code>1</code>, the second
2063: * is <code>2</code>, and so on; must be <code>1</code> or larger
2064: * and equal to or less than the number of columns in the rowset
2065: * @return a Java character stream that delivers the database column value
2066: * as a stream of two-byte unicode characters in a
2067: * <code>java.io.Reader</code> object. If the value is
2068: * SQL <code>NULL</code>, the result is <code>null</code>.
2069: * @throws SQLException if (1) the given column index is out of bounds,
2070: * (2) the cursor is not on one of this rowset's rows or its
2071: * insert row, or (3) the designated column does not store an
2072: * SQL <code>CHAR, VARCHAR, <b>LONGVARCHAR</b>, BINARY, VARBINARY</code> or
2073: * <code>LONGVARBINARY</code> value.
2074: * The bold SQL type designates the recommended return type.
2075: * @see #getCharacterStream(String)
2076: */
2077: public java.io.Reader getCharacterStream(int columnIndex)
2078: throws SQLException {
2079: throw new UnsupportedOperationException();
2080: }
2081:
2082: /**
2083: * Retrieves the value stored in the designated column
2084: * of the current row as a <code>java.io.Reader</code> object.
2085: *
2086: * <P><B>Note:</B> All the data in the returned stream must
2087: * be read prior to getting the value of any other column. The
2088: * next call to a <code>getXXX</code> method implicitly closes the stream.
2089: *
2090: * @param columnName a <code>String</code> object giving the SQL name of
2091: * a column in this <code>CachedRowSetXImpl</code> object
2092: * @return a Java input stream that delivers the database column value
2093: * as a stream of two-byte Unicode characters. If the value is
2094: * SQL <code>NULL</code>, the result is <code>null</code>.
2095: * @throws SQLException if (1) the given column name is not the name of
2096: * a column in this rowset, (2) the cursor is not on one of
2097: * this rowset's rows or its insert row, or (3) the designated
2098: * column does not store an SQL <code>CHAR, VARCHAR, <b>LONGVARCHAR</b>,
2099: * BINARY, VARYBINARY</code> or <code>LONGVARBINARY</code> value.
2100: * The bold SQL type designates the recommended return type.
2101: */
2102: public java.io.Reader getCharacterStream(String columnName)
2103: throws SQLException {
2104: throw new UnsupportedOperationException();
2105: }
2106:
2107: /**
2108: * Retrieves the value of the designated column in the current row
2109: * of this <code>CachedRowSetXImpl</code> object as a
2110: * <code>java.math.BigDecimal</code> object.
2111: *
2112: * @param columnIndex the first column is <code>1</code>, the second
2113: * is <code>2</code>, and so on; must be <code>1</code> or larger
2114: * and equal to or less than the number of columns in the rowset
2115: * @return a <code>java.math.BigDecimal</code> value with full precision;
2116: * if the value is SQL <code>NULL</code>, the result is <code>null</code>
2117: * @throws SQLException if (1) the given column index is out of bounds,
2118: * (2) the cursor is not on one of this rowset's rows or its
2119: * insert row, or (3) the designated column does not store an
2120: * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, REAL,
2121: * FLOAT, DOUBLE, <b>DECIMAL</b>, <b>NUMERIC</b>, BIT, CHAR, VARCHAR</code>
2122: * or <code>LONGVARCHAR</code> value. The bold SQL type designates the
2123: * recommended return types that this method is used to retrieve.
2124: * @see #getBigDecimal(String)
2125: */
2126: public BigDecimal getBigDecimal(int columnIndex)
2127: throws SQLException {
2128: throw new UnsupportedOperationException();
2129: }
2130:
2131: /**
2132: * Retrieves the value of the designated column in the current row
2133: * of this <code>CachedRowSetXImpl</code> object as a
2134: * <code>java.math.BigDecimal</code> object.
2135: *
2136: * @param columnName a <code>String</code> object that must match the
2137: * SQL name of a column in this rowset, ignoring case
2138: * @return a <code>java.math.BigDecimal</code> value with full precision;
2139: * if the value is SQL <code>NULL</code>, the result is <code>null</code>
2140: * @throws SQLException if (1) the given column name is not the name of
2141: * a column in this rowset, (2) the cursor is not on one of
2142: * this rowset's rows or its insert row, or (3) the designated
2143: * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER
2144: * BIGINT, REAL, FLOAT, DOUBLE, <b>DECIMAL</b>, <b>NUMERIC</b>, BIT CHAR,
2145: * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type
2146: * designates the recommended return type that this method is used to
2147: * retrieve
2148: * @see #getBigDecimal(int)
2149: */
2150: public BigDecimal getBigDecimal(String columnName)
2151: throws SQLException {
2152: throw new UnsupportedOperationException();
2153: }
2154:
2155: //---------------------------------------------------------------------
2156: // Traversal/Positioning
2157: //---------------------------------------------------------------------
2158:
2159: /**
2160: * Returns the number of rows in this <code>CachedRowSetXImpl</code> object.
2161: *
2162: * @return number of rows in the rowset
2163: */
2164: public int size() {
2165: throw new UnsupportedOperationException();
2166: }
2167:
2168: /**
2169: * Indicates whether the cursor is before the first row in this
2170: * <code>CachedRowSetXImpl</code> object.
2171: *
2172: * @return <code>true</code> if the cursor is before the first row;
2173: * <code>false</code> otherwise or if the rowset contains no rows
2174: * @throws SQLException if an error occurs
2175: */
2176: public boolean isBeforeFirst() throws SQLException {
2177: throw new UnsupportedOperationException();
2178: }
2179:
2180: /**
2181: * Indicates whether the cursor is after the last row in this
2182: * <code>CachedRowSetXImpl</code> object.
2183: *
2184: * @return <code>true</code> if the cursor is after the last row;
2185: * <code>false</code> otherwise or if the rowset contains no rows
2186: * @throws SQLException if an error occurs
2187: */
2188: public boolean isAfterLast() throws SQLException {
2189: throw new UnsupportedOperationException();
2190: }
2191:
2192: /**
2193: * Indicates whether the cursor is on the first row in this
2194: * <code>CachedRowSetXImpl</code> object.
2195: *
2196: * @return <code>true</code> if the cursor is on the first row;
2197: * <code>false</code> otherwise or if the rowset contains no rows
2198: * @throws SQLException if an error occurs
2199: */
2200: public boolean isFirst() throws SQLException {
2201: throw new UnsupportedOperationException();
2202: }
2203:
2204: /**
2205: * Indicates whether the cursor is on the last row in this
2206: * <code>CachedRowSetXImpl</code> object.
2207: * <P>
2208: * Note: Calling the method <code>isLast</code> may be expensive
2209: * because the JDBC driver might need to fetch ahead one row in order
2210: * to determine whether the current row is the last row in this rowset.
2211: *
2212: * @return <code>true</code> if the cursor is on the last row;
2213: * <code>false</code> otherwise or if this rowset contains no rows
2214: * @throws SQLException if an error occurs
2215: */
2216: public boolean isLast() throws SQLException {
2217: throw new UnsupportedOperationException();
2218: }
2219:
2220: /**
2221: * Moves this <code>CachedRowSetXImpl</code> object's cursor to the front of
2222: * the rowset, just before the first row. This method has no effect if
2223: * this rowset contains no rows.
2224: *
2225: * @throws SQLException if an error occurs or the type of this rowset
2226: * is <code>ResultSet.TYPE_FORWARD_ONLY</code>
2227: */
2228: public void beforeFirst() throws SQLException {
2229: throw new UnsupportedOperationException();
2230: }
2231:
2232: /**
2233: * Moves this <code>CachedRowSetXImpl</code> object's cursor to the end of
2234: * the rowset, just after the last row. This method has no effect if
2235: * this rowset contains no rows.
2236: *
2237: * @throws SQLException if an error occurs
2238: */
2239: public void afterLast() throws SQLException {
2240: throw new UnsupportedOperationException();
2241: }
2242:
2243: /**
2244: * Moves this <code>CachedRowSetXImpl</code> object's cursor to the first row
2245: * and returns <code>true</code> if the operation was successful. This
2246: * method also notifies registered listeners that the cursor has moved.
2247: *
2248: * @return <code>true</code> if the cursor is on a valid row;
2249: * <code>false</code> otherwise or if there are no rows in this
2250: * <code>CachedRowSetXImpl</code> object
2251: * @throws SQLException if the type of this rowset
2252: * is <code>ResultSet.TYPE_FORWARD_ONLY</code>
2253: */
2254: public boolean first() throws SQLException {
2255: throw new UnsupportedOperationException();
2256: }
2257:
2258: /**
2259: * Moves this <code>CachedRowSetXImpl</code> object's cursor to the first
2260: * row and returns <code>true</code> if the operation is successful.
2261: * <P>
2262: * This method is called internally by the methods <code>first</code>,
2263: * <code>isFirst</code>, and <code>absolute</code>.
2264: * It in turn calls the method <code>internalNext</code> in order to
2265: * handle the case where the first row is a deleted row that is not visible.
2266: * <p>
2267: * This is a implementation only method and is not required as a standard
2268: * implementation of the <code>CachedRowSet</code> interface.
2269: *
2270: * @return <code>true</code> if the cursor moved to the first row;
2271: * <code>false</code> otherwise
2272: * @throws SQLException if an error occurs
2273: */
2274: protected boolean internalFirst() throws SQLException {
2275: throw new UnsupportedOperationException();
2276: }
2277:
2278: /**
2279: * Moves this <code>CachedRowSetXImpl</code> object's cursor to the last row
2280: * and returns <code>true</code> if the operation was successful. This
2281: * method also notifies registered listeners that the cursor has moved.
2282: *
2283: * @return <code>true</code> if the cursor is on a valid row;
2284: * <code>false</code> otherwise or if there are no rows in this
2285: * <code>CachedRowSetXImpl</code> object
2286: * @throws SQLException if the type of this rowset
2287: * is <code>ResultSet.TYPE_FORWARD_ONLY</code>
2288: */
2289: public boolean last() throws SQLException {
2290: throw new UnsupportedOperationException();
2291: }
2292:
2293: /**
2294: * Moves this <code>CachedRowSetXImpl</code> object's cursor to the last
2295: * row and returns <code>true</code> if the operation is successful.
2296: * <P>
2297: * This method is called internally by the method <code>last</code>
2298: * when rows have been deleted and the deletions are not visible.
2299: * The method <code>internalLast</code> handles the case where the
2300: * last row is a deleted row that is not visible by in turn calling
2301: * the method <code>internalPrevious</code>.
2302: * <p>
2303: * This is a implementation only method and is not required as a standard
2304: * implementation of the <code>CachedRowSet</code> interface.
2305: *
2306: * @return <code>true</code> if the cursor moved to the last row;
2307: * <code>false</code> otherwise
2308: * @throws SQLException if an error occurs
2309: */
2310: protected boolean internalLast() throws SQLException {
2311: throw new UnsupportedOperationException();
2312: }
2313:
2314: /**
2315: * Returns the number of the current row in this <code>CachedRowSetXImpl</code>
2316: * object. The first row is number 1, the second number 2, and so on.
2317: *
2318: * @return the number of the current row; <code>0</code> if there is no
2319: * current row
2320: * @throws SQLException if an error occurs; or if the <code>CacheRowSetImpl</code>
2321: * is empty
2322: */
2323: public int getRow() throws SQLException {
2324: return crsSync.getRow();
2325: }
2326:
2327: /**
2328: * Moves this <code>CachedRowSetXImpl</code> object's cursor to the row number
2329: * specified.
2330: *
2331: * <p>If the number is positive, the cursor moves to an absolute row with
2332: * respect to the beginning of the rowset. The first row is row 1, the second
2333: * is row 2, and so on. For example, the following command, in which
2334: * <code>crs</code> is a <code>CachedRowSetXImpl</code> object, moves the cursor
2335: * to the fourth row, starting from the beginning of the rowset.
2336: * <PRE><code>
2337: *
2338: * crs.absolute(4);
2339: *
2340: * </code> </PRE>
2341: * <P>
2342: * If the number is negative, the cursor moves to an absolute row position
2343: * with respect to the end of the rowset. For example, calling
2344: * <code>absolute(-1)</code> positions the cursor on the last row,
2345: * <code>absolute(-2)</code> moves it on the next-to-last row, and so on.
2346: * If the <code>CachedRowSetXImpl</code> object <code>crs</code> has five rows,
2347: * the following command moves the cursor to the fourth-to-last row, which
2348: * in the case of a rowset with five rows, is also the second row, counting
2349: * from the beginning.
2350: * <PRE><code>
2351: *
2352: * crs.absolute(-4);
2353: *
2354: * </code> </PRE>
2355: *
2356: * If the number specified is larger than the number of rows, the cursor
2357: * will move to the position after the last row. If the number specified
2358: * would move the cursor one or more rows before the first row, the cursor
2359: * moves to the position before the first row.
2360: * <P>
2361: * Note: Calling <code>absolute(1)</code> is the same as calling the
2362: * method <code>first()</code>. Calling <code>absolute(-1)</code> is the
2363: * same as calling <code>last()</code>.
2364: *
2365: * @param row a positive number to indicate the row, starting row numbering from
2366: * the first row, which is <code>1</code>; a negative number to indicate
2367: * the row, starting row numbering from the last row, which is
2368: * <code>-1</code>; it must not be <code>0</code>
2369: * @return <code>true</code> if the cursor is on the rowset; <code>false</code>
2370: * otherwise
2371: * @throws SQLException if the given cursor position is <code>0</code> or the
2372: * type of this rowset is <code>ResultSet.TYPE_FORWARD_ONLY</code>
2373: */
2374: public boolean absolute(int row) throws SQLException {
2375: throw new UnsupportedOperationException();
2376: }
2377:
2378: /**
2379: * Moves the cursor the specified number of rows from the current
2380: * position, with a positive number moving it forward and a
2381: * negative number moving it backward.
2382: * <P>
2383: * If the number is positive, the cursor moves the specified number of
2384: * rows toward the end of the rowset, starting at the current row.
2385: * For example, the following command, in which
2386: * <code>crs</code> is a <code>CachedRowSetXImpl</code> object with 100 rows,
2387: * moves the cursor forward four rows from the current row. If the
2388: * current row is 50, the cursor would move to row 54.
2389: * <PRE><code>
2390: *
2391: * crs.relative(4);
2392: *
2393: * </code> </PRE>
2394: * <P>
2395: * If the number is negative, the cursor moves back toward the beginning
2396: * the specified number of rows, starting at the current row.
2397: * For example, calling the method
2398: * <code>absolute(-1)</code> positions the cursor on the last row,
2399: * <code>absolute(-2)</code> moves it on the next-to-last row, and so on.
2400: * If the <code>CachedRowSetXImpl</code> object <code>crs</code> has five rows,
2401: * the following command moves the cursor to the fourth-to-last row, which
2402: * in the case of a rowset with five rows, is also the second row
2403: * from the beginning.
2404: * <PRE><code>
2405: *
2406: * crs.absolute(-4);
2407: *
2408: * </code> </PRE>
2409: *
2410: * If the number specified is larger than the number of rows, the cursor
2411: * will move to the position after the last row. If the number specified
2412: * would move the cursor one or more rows before the first row, the cursor
2413: * moves to the position before the first row. In both cases, this method
2414: * throws an <code>SQLException</code>.
2415: * <P>
2416: * Note: Calling <code>absolute(1)</code> is the same as calling the
2417: * method <code>first()</code>. Calling <code>absolute(-1)</code> is the
2418: * same as calling <code>last()</code>. Calling <code>relative(0)</code>
2419: * is valid, but it does not change the cursor position.
2420: *
2421: * @param rows an <code>int</code> indicating the number of rows to move
2422: * the cursor, starting at the current row; a positive number
2423: * moves the cursor forward; a negative number moves the cursor
2424: * backward; must not move the cursor past the valid
2425: * rows
2426: * @return <code>true</code> if the cursor is on a row in this
2427: * <code>CachedRowSetXImpl</code> object; <code>false</code>
2428: * otherwise
2429: * @throws SQLException if there are no rows in this rowset, the cursor is
2430: * positioned either before the first row or after the last row, or
2431: * the rowset is type <code>ResultSet.TYPE_FORWARD_ONLY</code>
2432: */
2433: public boolean relative(int rows) throws SQLException {
2434: throw new UnsupportedOperationException();
2435: }
2436:
2437: /**
2438: * Moves this <code>CachedRowSetXImpl</code> object's cursor to the
2439: * previous row and returns <code>true</code> if the cursor is on
2440: * a valid row or <code>false</code> if it is not.
2441: * This method also notifies all listeners registered with this
2442: * <code>CachedRowSetXImpl</code> object that its cursor has moved.
2443: * <P>
2444: * Note: calling the method <code>previous()</code> is not the same
2445: * as calling the method <code>relative(-1)</code>. This is true
2446: * because it is possible to call <code>previous()</code> from the insert
2447: * row, from after the last row, or from the current row, whereas
2448: * <code>relative</code> may only be called from the current row.
2449: * <P>
2450: * The method <code>previous</code> may used in a <code>while</code>
2451: * loop to iterate through a rowset starting after the last row
2452: * and moving toward the beginning. The loop ends when <code>previous</code>
2453: * returns <code>false</code>, meaning that there are no more rows.
2454: * For example, the following code fragment retrieves all the data in
2455: * the <code>CachedRowSetXImpl</code> object <code>crs</code>, which has
2456: * three columns. Note that the cursor must initially be positioned
2457: * after the last row so that the first call to the method
2458: * <code>previous</code> places the cursor on the last line.
2459: * <PRE> <code>
2460: *
2461: * crs.afterLast();
2462: * while (previous()) {
2463: * String name = crs.getString(1);
2464: * int age = crs.getInt(2);
2465: * short ssn = crs.getShort(3);
2466: * System.out.println(name + " " + age + " " + ssn);
2467: * }
2468: *
2469: * </code> </PRE>
2470: * This method throws an <code>SQLException</code> if the cursor is not
2471: * on a row in the rowset, before the first row, or after the last row.
2472: *
2473: * @return <code>true</code> if the cursor is on a valid row;
2474: * <code>false</code> if it is before the first row or after the
2475: * last row
2476: * @throws SQLException if the cursor is not on a valid position or the
2477: * type of this rowset is <code>ResultSet.TYPE_FORWARD_ONLY</code>
2478: */
2479: public boolean previous() throws SQLException {
2480: throw new UnsupportedOperationException();
2481: }
2482:
2483: /**
2484: * Moves the cursor to the previous row in this <code>CachedRowSetXImpl</code>
2485: * object, skipping past deleted rows that are not visible; returns
2486: * <code>true</code> if the cursor is on a row in this rowset and
2487: * <code>false</code> when the cursor goes before the first row.
2488: * <P>
2489: * This method is called internally by the method <code>previous</code>.
2490: * <P>
2491: * This is a implementation only method and is not required as a standard
2492: * implementation of the <code>CachedRowSet</code> interface.
2493: *
2494: * @return <code>true</code> if the cursor is on a row in this rowset;
2495: * <code>false</code> when the cursor reaches the position before
2496: * the first row
2497: * @throws SQLException if an error occurs
2498: */
2499: protected boolean internalPrevious() throws SQLException {
2500: throw new UnsupportedOperationException();
2501: }
2502:
2503: //---------------------------------------------------------------------
2504: // Updates
2505: //---------------------------------------------------------------------
2506:
2507: /**
2508: * Indicates whether the current row of this <code>CachedRowSetXImpl</code>
2509: * object has been updated. The value returned
2510: * depends on whether this rowset can detect updates: <code>false</code>
2511: * will always be returned if it does not detect updates.
2512: *
2513: * @return <code>true</code> if the row has been visibly updated
2514: * by the owner or another and updates are detected;
2515: * <code>false</code> otherwise
2516: * @throws SQLException if the cursor is on the insert row or not
2517: * not on a valid row
2518: *
2519: * @see DatabaseMetaData#updatesAreDetected
2520: */
2521: public boolean rowUpdated() throws SQLException {
2522: throw new UnsupportedOperationException();
2523: }
2524:
2525: /**
2526: * Indicates whether the designated column of the current row of
2527: * this <code>CachedRowSetXImpl</code> object has been updated. The
2528: * value returned depends on whether this rowset can detcted updates:
2529: * <code>false</code> will always be returned if it does not detect updates.
2530: *
2531: * @param idx the index identifier of the column that may be have been updated.
2532: * @return <code>true</code> is the designated column has been updated
2533: * and the rowset detects updates; <code>false</code> if the rowset has not
2534: * been updated or the rowset does not detect updates
2535: * @throws SQLException if the cursor is on the insert row or not
2536: * on a valid row
2537: * @see DatabaseMetaData#updatesAreDetected
2538: */
2539: public boolean columnUpdated(int idx) throws SQLException {
2540: throw new UnsupportedOperationException();
2541: }
2542:
2543: /**
2544: * Indicates whether the designated column of the current row of
2545: * this <code>CachedRowSetXImpl</code> object has been updated. The
2546: * value returned depends on whether this rowset can detcted updates:
2547: * <code>false</code> will always be returned if it does not detect updates.
2548: *
2549: * @param columnName the <code>String</code> column name column that may be have
2550: * been updated.
2551: * @return <code>true</code> is the designated column has been updated
2552: * and the rowset detects updates; <code>false</code> if the rowset has not
2553: * been updated or the rowset does not detect updates
2554: * @throws SQLException if the cursor is on the insert row or not
2555: * on a valid row
2556: * @see DatabaseMetaData#updatesAreDetected
2557: */
2558: public boolean columnUpdated(String columnName) throws SQLException {
2559: throw new UnsupportedOperationException();
2560: }
2561:
2562: /**
2563: * Indicates whether the current row has been inserted. The value returned
2564: * depends on whether or not the rowset can detect visible inserts.
2565: *
2566: * @return <code>true</code> if a row has been inserted and inserts are detected;
2567: * <code>false</code> otherwise
2568: * @throws SQLException if the cursor is on the insert row or not
2569: * not on a valid row
2570: *
2571: * @see DatabaseMetaData#insertsAreDetected
2572: */
2573: public boolean rowInserted() throws SQLException {
2574: throw new UnsupportedOperationException();
2575: }
2576:
2577: /**
2578: * Indicates whether the current row has been deleted. A deleted row
2579: * may leave a visible "hole" in a rowset. This method can be used to
2580: * detect such holes if the rowset can detect deletions. This method
2581: * will always return <code>false</code> if this rowset cannot detect
2582: * deletions.
2583: *
2584: * @return <code>true</code> if (1)the current row is blank, indicating that
2585: * the row has been deleted, and (2)deletions are detected;
2586: * <code>false</code> otherwise
2587: * @throws SQLException if the cursor is on a valid row in this rowset
2588: * @see DatabaseMetaData#deletesAreDetected
2589: */
2590: public boolean rowDeleted() throws SQLException {
2591: throw new UnsupportedOperationException();
2592: }
2593:
2594: /**
2595: * Sets the designated nullable column in the current row or the
2596: * insert row of this <code>CachedRowSetXImpl</code> object with
2597: * <code>null</code> value.
2598: * <P>
2599: * This method updates a column value in the current row or the insert
2600: * row of this rowset; however, another method must be called to complete
2601: * the update process. If the cursor is on a row in the rowset, the
2602: * method {@link #updateRow} must be called to mark the row as updated
2603: * and to notify listeners that the row has changed.
2604: * If the cursor is on the insert row, the method {@link #insertRow}
2605: * must be called to insert the new row into this rowset and to notify
2606: * listeners that a row has changed.
2607: * <P>
2608: * In order to propagate updates in this rowset to the underlying
2609: * data source, an application must call the method {@link #acceptChanges}
2610: * after it calls either <code>updateRow</code> or <code>insertRow</code>.
2611: *
2612: * @param columnIndex the first column is <code>1</code>, the second
2613: * is <code>2</code>, and so on; must be <code>1</code> or larger
2614: * and equal to or less than the number of columns in this rowset
2615: * @throws SQLException if (1) the given column index is out of bounds,
2616: * (2) the cursor is not on one of this rowset's rows or its
2617: * insert row, or (3) this rowset is
2618: * <code>ResultSet.CONCUR_READ_ONLY</code>
2619: */
2620: public void updateNull(int columnIndex) throws SQLException {
2621: throw new UnsupportedOperationException();
2622: }
2623:
2624: /**
2625: * Sets the designated column in either the current row or the insert
2626: * row of this <code>CachedRowSetXImpl</code> object with the given
2627: * <code>boolean</code> value.
2628: * <P>
2629: * This method updates a column value in the current row or the insert
2630: * row of this rowset, but it does not update the database.
2631: * If the cursor is on a row in the rowset, the
2632: * method {@link #updateRow} must be called to update the database.
2633: * If the cursor is on the insert row, the method {@link #insertRow}
2634: * must be called, which will insert the new row into both this rowset
2635: * and the database. Both of these methods must be called before the
2636: * cursor moves to another row.
2637: *
2638: * @param columnIndex the first column is <code>1</code>, the second
2639: * is <code>2</code>, and so on; must be <code>1</code> or larger
2640: * and equal to or less than the number of columns in this rowset
2641: * @param x the new column value
2642: * @throws SQLException if (1) the given column index is out of bounds,
2643: * (2) the cursor is not on one of this rowset's rows or its
2644: * insert row, or (3) this rowset is
2645: * <code>ResultSet.CONCUR_READ_ONLY</code>
2646: */
2647: public void updateBoolean(int columnIndex, boolean x)
2648: throws SQLException {
2649: throw new UnsupportedOperationException();
2650: }
2651:
2652: /**
2653: * Sets the designated column in either the current row or the insert
2654: * row of this <code>CachedRowSetXImpl</code> object with the given
2655: * <code>byte</code> value.
2656: * <P>
2657: * This method updates a column value in the current row or the insert
2658: * row of this rowset, but it does not update the database.
2659: * If the cursor is on a row in the rowset, the
2660: * method {@link #updateRow} must be called to update the database.
2661: * If the cursor is on the insert row, the method {@link #insertRow}
2662: * must be called, which will insert the new row into both this rowset
2663: * and the database. Both of these methods must be called before the
2664: * cursor moves to another row.
2665: *
2666: * @param columnIndex the first column is <code>1</code>, the second
2667: * is <code>2</code>, and so on; must be <code>1</code> or larger
2668: * and equal to or less than the number of columns in this rowset
2669: * @param x the new column value
2670: * @throws SQLException if (1) the given column index is out of bounds,
2671: * (2) the cursor is not on one of this rowset's rows or its
2672: * insert row, or (3) this rowset is
2673: * <code>ResultSet.CONCUR_READ_ONLY</code>
2674: */
2675: public void updateByte(int columnIndex, byte x) throws SQLException {
2676: throw new UnsupportedOperationException();
2677: }
2678:
2679: /**
2680: * Sets the designated column in either the current row or the insert
2681: * row of this <code>CachedRowSetXImpl</code> object with the given
2682: * <code>short</code> value.
2683: * <P>
2684: * This method updates a column value in the current row or the insert
2685: * row of this rowset, but it does not update the database.
2686: * If the cursor is on a row in the rowset, the
2687: * method {@link #updateRow} must be called to update the database.
2688: * If the cursor is on the insert row, the method {@link #insertRow}
2689: * must be called, which will insert the new row into both this rowset
2690: * and the database. Both of these methods must be called before the
2691: * cursor moves to another row.
2692: *
2693: * @param columnIndex the first column is <code>1</code>, the second
2694: * is <code>2</code>, and so on; must be <code>1</code> or larger
2695: * and equal to or less than the number of columns in this rowset
2696: * @param x the new column value
2697: * @throws SQLException if (1) the given column index is out of bounds,
2698: * (2) the cursor is not on one of this rowset's rows or its
2699: * insert row, or (3) this rowset is
2700: * <code>ResultSet.CONCUR_READ_ONLY</code>
2701: */
2702: public void updateShort(int columnIndex, short x)
2703: throws SQLException {
2704: throw new UnsupportedOperationException();
2705: }
2706:
2707: /**
2708: * Sets the designated column in either the current row or the insert
2709: * row of this <code>CachedRowSetXImpl</code> object with the given
2710: * <code>int</code> value.
2711: * <P>
2712: * This method updates a column value in the current row or the insert
2713: * row of this rowset, but it does not update the database.
2714: * If the cursor is on a row in the rowset, the
2715: * method {@link #updateRow} must be called to update the database.
2716: * If the cursor is on the insert row, the method {@link #insertRow}
2717: * must be called, which will insert the new row into both this rowset
2718: * and the database. Both of these methods must be called before the
2719: * cursor moves to another row.
2720: *
2721: * @param columnIndex the first column is <code>1</code>, the second
2722: * is <code>2</code>, and so on; must be <code>1</code> or larger
2723: * and equal to or less than the number of columns in this rowset
2724: * @param x the new column value
2725: * @throws SQLException if (1) the given column index is out of bounds,
2726: * (2) the cursor is not on one of this rowset's rows or its
2727: * insert row, or (3) this rowset is
2728: * <code>ResultSet.CONCUR_READ_ONLY</code>
2729: */
2730: public void updateInt(int columnIndex, int x) throws SQLException {
2731: throw new UnsupportedOperationException();
2732: }
2733:
2734: /**
2735: * Sets the designated column in either the current row or the insert
2736: * row of this <code>CachedRowSetXImpl</code> object with the given
2737: * <code>long</code> value.
2738: * <P>
2739: * This method updates a column value in the current row or the insert
2740: * row of this rowset, but it does not update the database.
2741: * If the cursor is on a row in the rowset, the
2742: * method {@link #updateRow} must be called to update the database.
2743: * If the cursor is on the insert row, the method {@link #insertRow}
2744: * must be called, which will insert the new row into both this rowset
2745: * and the database. Both of these methods must be called before the
2746: * cursor moves to another row.
2747: *
2748: * @param columnIndex the first column is <code>1</code>, the second
2749: * is <code>2</code>, and so on; must be <code>1</code> or larger
2750: * and equal to or less than the number of columns in this rowset
2751: * @param x the new column value
2752: * @throws SQLException if (1) the given column index is out of bounds,
2753: * (2) the cursor is not on one of this rowset's rows or its
2754: * insert row, or (3) this rowset is
2755: * <code>ResultSet.CONCUR_READ_ONLY</code>
2756: */
2757: public void updateLong(int columnIndex, long x) throws SQLException {
2758: throw new UnsupportedOperationException();
2759:
2760: }
2761:
2762: /**
2763: * Sets the designated column in either the current row or the insert
2764: * row of this <code>CachedRowSetXImpl</code> object with the given
2765: * <code>float</code> value.
2766: * <P>
2767: * This method updates a column value in the current row or the insert
2768: * row of this rowset, but it does not update the database.
2769: * If the cursor is on a row in the rowset, the
2770: * method {@link #updateRow} must be called to update the database.
2771: * If the cursor is on the insert row, the method {@link #insertRow}
2772: * must be called, which will insert the new row into both this rowset
2773: * and the database. Both of these methods must be called before the
2774: * cursor moves to another row.
2775: *
2776: * @param columnIndex the first column is <code>1</code>, the second
2777: * is <code>2</code>, and so on; must be <code>1</code> or larger
2778: * and equal to or less than the number of columns in this rowset
2779: * @param x the new column value
2780: * @throws SQLException if (1) the given column index is out of bounds,
2781: * (2) the cursor is not on one of this rowset's rows or its
2782: * insert row, or (3) this rowset is
2783: * <code>ResultSet.CONCUR_READ_ONLY</code>
2784: */
2785: public void updateFloat(int columnIndex, float x)
2786: throws SQLException {
2787: throw new UnsupportedOperationException();
2788: }
2789:
2790: /**
2791: * Sets the designated column in either the current row or the insert
2792: * row of this <code>CachedRowSetXImpl</code> object with the given
2793: * <code>double</code> value.
2794: *
2795: * This method updates a column value in either the current row or
2796: * the insert row of this rowset, but it does not update the
2797: * database. If the cursor is on a row in the rowset, the
2798: * method {@link #updateRow} must be called to update the database.
2799: * If the cursor is on the insert row, the method {@link #insertRow}
2800: * must be called, which will insert the new row into both this rowset
2801: * and the database. Both of these methods must be called before the
2802: * cursor moves to another row.
2803: *
2804: * @param columnIndex the first column is <code>1</code>, the second
2805: * is <code>2</code>, and so on; must be <code>1</code> or larger
2806: * and equal to or less than the number of columns in this rowset
2807: * @param x the new column value
2808: * @throws SQLException if (1) the given column index is out of bounds,
2809: * (2) the cursor is not on one of this rowset's rows or its
2810: * insert row, or (3) this rowset is
2811: * <code>ResultSet.CONCUR_READ_ONLY</code>
2812: */
2813: public void updateDouble(int columnIndex, double x)
2814: throws SQLException {
2815: throw new UnsupportedOperationException();
2816: }
2817:
2818: /**
2819: * Sets the designated column in either the current row or the insert
2820: * row of this <code>CachedRowSetXImpl</code> object with the given
2821: * <code>java.math.BigDecimal</code> object.
2822: * <P>
2823: * This method updates a column value in the current row or the insert
2824: * row of this rowset, but it does not update the database.
2825: * If the cursor is on a row in the rowset, the
2826: * method {@link #updateRow} must be called to update the database.
2827: * If the cursor is on the insert row, the method {@link #insertRow}
2828: * must be called, which will insert the new row into both this rowset
2829: * and the database. Both of these methods must be called before the
2830: * cursor moves to another row.
2831: *
2832: * @param columnIndex the first column is <code>1</code>, the second
2833: * is <code>2</code>, and so on; must be <code>1</code> or larger
2834: * and equal to or less than the number of columns in this rowset
2835: * @param x the new column value
2836: * @throws SQLException if (1) the given column index is out of bounds,
2837: * (2) the cursor is not on one of this rowset's rows or its
2838: * insert row, or (3) this rowset is
2839: * <code>ResultSet.CONCUR_READ_ONLY</code>
2840: */
2841: public void updateBigDecimal(int columnIndex, BigDecimal x)
2842: throws SQLException {
2843: throw new UnsupportedOperationException();
2844: }
2845:
2846: /**
2847: * Sets the designated column in either the current row or the insert
2848: * row of this <code>CachedRowSetXImpl</code> object with the given
2849: * <code>String</code> object.
2850: * <P>
2851: * This method updates a column value in either the current row or
2852: * the insert row of this rowset, but it does not update the
2853: * database. If the cursor is on a row in the rowset, the
2854: * method {@link #updateRow} must be called to mark the row as updated.
2855: * If the cursor is on the insert row, the method {@link #insertRow}
2856: * must be called to insert the new row into this rowset and mark it
2857: * as inserted. Both of these methods must be called before the
2858: * cursor moves to another row.
2859: * <P>
2860: * The method <code>acceptChanges</code> must be called if the
2861: * updated values are to be written back to the underlying database.
2862: *
2863: * @param columnIndex the first column is <code>1</code>, the second
2864: * is <code>2</code>, and so on; must be <code>1</code> or larger
2865: * and equal to or less than the number of columns in this rowset
2866: * @param x the new column value
2867: * @throws SQLException if (1) the given column index is out of bounds,
2868: * (2) the cursor is not on one of this rowset's rows or its
2869: * insert row, or (3) this rowset is
2870: * <code>ResultSet.CONCUR_READ_ONLY</code>
2871: */
2872: public void updateString(int columnIndex, String x)
2873: throws SQLException {
2874: throw new UnsupportedOperationException();
2875: }
2876:
2877: /**
2878: * Sets the designated column in either the current row or the insert
2879: * row of this <code>CachedRowSetXImpl</code> object with the given
2880: * <code>byte</code> array.
2881: *
2882: * This method updates a column value in either the current row or
2883: * the insert row of this rowset, but it does not update the
2884: * database. If the cursor is on a row in the rowset, the
2885: * method {@link #updateRow} must be called to update the database.
2886: * If the cursor is on the insert row, the method {@link #insertRow}
2887: * must be called, which will insert the new row into both this rowset
2888: * and the database. Both of these methods must be called before the
2889: * cursor moves to another row.
2890: *
2891: * @param columnIndex the first column is <code>1</code>, the second
2892: * is <code>2</code>, and so on; must be <code>1</code> or larger
2893: * and equal to or less than the number of columns in this rowset
2894: * @param x the new column value
2895: * @throws SQLException if (1) the given column index is out of bounds,
2896: * (2) the cursor is not on one of this rowset's rows or its
2897: * insert row, or (3) this rowset is
2898: * <code>ResultSet.CONCUR_READ_ONLY</code>
2899: */
2900: public void updateBytes(int columnIndex, byte x[])
2901: throws SQLException {
2902: throw new UnsupportedOperationException();
2903: }
2904:
2905: /**
2906: * Sets the designated column in either the current row or the insert
2907: * row of this <code>CachedRowSetXImpl</code> object with the given
2908: * <code>Date</code> object.
2909: *
2910: * This method updates a column value in either the current row or
2911: * the insert row of this rowset, but it does not update the
2912: * database. If the cursor is on a row in the rowset, the
2913: * method {@link #updateRow} must be called to update the database.
2914: * If the cursor is on the insert row, the method {@link #insertRow}
2915: * must be called, which will insert the new row into both this rowset
2916: * and the database. Both of these methods must be called before the
2917: * cursor moves to another row.
2918: *
2919: * @param columnIndex the first column is <code>1</code>, the second
2920: * is <code>2</code>, and so on; must be <code>1</code> or larger
2921: * and equal to or less than the number of columns in this rowset
2922: * @param x the new column value
2923: * @throws SQLException if (1) the given column index is out of bounds,
2924: * (2) the cursor is not on one of this rowset's rows or its
2925: * insert row, (3) the type of the designated column is not
2926: * an SQL <code>DATE</code> or <code>TIMESTAMP</code>, or
2927: * (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
2928: */
2929: public void updateDate(int columnIndex, java.sql.Date x)
2930: throws SQLException {
2931: throw new UnsupportedOperationException();
2932: }
2933:
2934: /**
2935: * Sets the designated column in either the current row or the insert
2936: * row of this <code>CachedRowSetXImpl</code> object with the given
2937: * <code>Time</code> object.
2938: *
2939: * This method updates a column value in either the current row or
2940: * the insert row of this rowset, but it does not update the
2941: * database. If the cursor is on a row in the rowset, the
2942: * method {@link #updateRow} must be called to update the database.
2943: * If the cursor is on the insert row, the method {@link #insertRow}
2944: * must be called, which will insert the new row into both this rowset
2945: * and the database. Both of these methods must be called before the
2946: * cursor moves to another row.
2947: *
2948: * @param columnIndex the first column is <code>1</code>, the second
2949: * is <code>2</code>, and so on; must be <code>1</code> or larger
2950: * and equal to or less than the number of columns in this rowset
2951: * @param x the new column value
2952: * @throws SQLException if (1) the given column index is out of bounds,
2953: * (2) the cursor is not on one of this rowset's rows or its
2954: * insert row, (3) the type of the designated column is not
2955: * an SQL <code>TIME</code> or <code>TIMESTAMP</code>, or
2956: * (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
2957: */
2958: public void updateTime(int columnIndex, java.sql.Time x)
2959: throws SQLException {
2960: throw new UnsupportedOperationException();
2961: }
2962:
2963: /**
2964: * Sets the designated column in either the current row or the insert
2965: * row of this <code>CachedRowSetXImpl</code> object with the given
2966: * <code>Timestamp</code> object.
2967: *
2968: * This method updates a column value in either the current row or
2969: * the insert row of this rowset, but it does not update the
2970: * database. If the cursor is on a row in the rowset, the
2971: * method {@link #updateRow} must be called to update the database.
2972: * If the cursor is on the insert row, the method {@link #insertRow}
2973: * must be called, which will insert the new row into both this rowset
2974: * and the database. Both of these methods must be called before the
2975: * cursor moves to another row.
2976: *
2977: * @param columnIndex the first column is <code>1</code>, the second
2978: * is <code>2</code>, and so on; must be <code>1</code> or larger
2979: * and equal to or less than the number of columns in this rowset
2980: * @param x the new column value
2981: * @throws SQLException if (1) the given column index is out of bounds,
2982: * (2) the cursor is not on one of this rowset's rows or its
2983: * insert row, (3) the type of the designated column is not
2984: * an SQL <code>DATE</code>, <code>TIME</code>, or
2985: * <code>TIMESTAMP</code>, or (4) this rowset is
2986: * <code>ResultSet.CONCUR_READ_ONLY</code>
2987: */
2988: public void updateTimestamp(int columnIndex, java.sql.Timestamp x)
2989: throws SQLException {
2990: throw new UnsupportedOperationException();
2991: }
2992:
2993: /**
2994: * Sets the designated column in either the current row or the insert
2995: * row of this <code>CachedRowSetXImpl</code> object with the given
2996: * ASCII stream value.
2997: * <P>
2998: * This method updates a column value in either the current row or
2999: * the insert row of this rowset, but it does not update the
3000: * database. If the cursor is on a row in the rowset, the
3001: * method {@link #updateRow} must be called to update the database.
3002: * If the cursor is on the insert row, the method {@link #insertRow}
3003: * must be called, which will insert the new row into both this rowset
3004: * and the database. Both of these methods must be called before the
3005: * cursor moves to another row.
3006: *
3007: * @param columnIndex the first column is <code>1</code>, the second
3008: * is <code>2</code>, and so on; must be <code>1</code> or larger
3009: * and equal to or less than the number of columns in this rowset
3010: * @param x the new column value
3011: * @param length the number of one-byte ASCII characters in the stream
3012: * @throws SQLException if this method is invoked
3013: */
3014: public void updateAsciiStream(int columnIndex,
3015: java.io.InputStream x, int length) throws SQLException {
3016: throw new UnsupportedOperationException();
3017: }
3018:
3019: /**
3020: * Sets the designated column in either the current row or the insert
3021: * row of this <code>CachedRowSetXImpl</code> object with the given
3022: * <code>java.io.InputStream</code> object.
3023: * <P>
3024: * This method updates a column value in either the current row or
3025: * the insert row of this rowset, but it does not update the
3026: * database. If the cursor is on a row in the rowset, the
3027: * method {@link #updateRow} must be called to update the database.
3028: * If the cursor is on the insert row, the method {@link #insertRow}
3029: * must be called, which will insert the new row into both this rowset
3030: * and the database. Both of these methods must be called before the
3031: * cursor moves to another row.
3032: *
3033: * @param columnIndex the first column is <code>1</code>, the second
3034: * is <code>2</code>, and so on; must be <code>1</code> or larger
3035: * and equal to or less than the number of columns in this rowset
3036: * @param x the new column value; must be a <code>java.io.InputStream</code>
3037: * containing <code>BINARY</code>, <code>VARBINARY</code>, or
3038: * <code>LONGVARBINARY</code> data
3039: * @param length the length of the stream in bytes
3040: * @throws SQLException if (1) the given column index is out of bounds,
3041: * (2) the cursor is not on one of this rowset's rows or its
3042: * insert row, (3) the data in the stream is not binary, or
3043: * (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3044: */
3045: public void updateBinaryStream(int columnIndex,
3046: java.io.InputStream x, int length) throws SQLException {
3047: throw new UnsupportedOperationException();
3048: }
3049:
3050: /**
3051: * Sets the designated column in either the current row or the insert
3052: * row of this <code>CachedRowSetXImpl</code> object with the given
3053: * <code>java.io.Reader</code> object.
3054: * <P>
3055: * This method updates a column value in either the current row or
3056: * the insert row of this rowset, but it does not update the
3057: * database. If the cursor is on a row in the rowset, the
3058: * method {@link #updateRow} must be called to update the database.
3059: * If the cursor is on the insert row, the method {@link #insertRow}
3060: * must be called, which will insert the new row into both this rowset
3061: * and the database. Both of these methods must be called before the
3062: * cursor moves to another row.
3063: *
3064: * @param columnIndex the first column is <code>1</code>, the second
3065: * is <code>2</code>, and so on; must be <code>1</code> or larger
3066: * and equal to or less than the number of columns in this rowset
3067: * @param x the new column value; must be a <code>java.io.Reader</code>
3068: * containing <code>BINARY</code>, <code>VARBINARY</code>,
3069: * <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>,
3070: * or <code>LONGVARCHAR</code> data
3071: * @param length the length of the stream in characters
3072: * @throws SQLException if (1) the given column index is out of bounds,
3073: * (2) the cursor is not on one of this rowset's rows or its
3074: * insert row, (3) the data in the stream is not a binary or
3075: * character type, or (4) this rowset is
3076: * <code>ResultSet.CONCUR_READ_ONLY</code>
3077: */
3078: public void updateCharacterStream(int columnIndex,
3079: java.io.Reader x, int length) throws SQLException {
3080: throw new UnsupportedOperationException();
3081: }
3082:
3083: /**
3084: * Sets the designated column in either the current row or the insert
3085: * row of this <code>CachedRowSetXImpl</code> object with the given
3086: * <code>Object</code> value. The <code>scale</code> parameter indicates
3087: * the number of digits to the right of the decimal point and is ignored
3088: * if the new column value is not a type that will be mapped to an SQL
3089: * <code>DECIMAL</code> or <code>NUMERIC</code> value.
3090: * <P>
3091: * This method updates a column value in either the current row or
3092: * the insert row of this rowset, but it does not update the
3093: * database. If the cursor is on a row in the rowset, the
3094: * method {@link #updateRow} must be called to update the database.
3095: * If the cursor is on the insert row, the method {@link #insertRow}
3096: * must be called, which will insert the new row into both this rowset
3097: * and the database. Both of these methods must be called before the
3098: * cursor moves to another row.
3099: *
3100: * @param columnIndex the first column is <code>1</code>, the second
3101: * is <code>2</code>, and so on; must be <code>1</code> or larger
3102: * and equal to or less than the number of columns in this rowset
3103: * @param x the new column value
3104: * @param scale the number of digits to the right of the decimal point (for
3105: * <code>DECIMAL</code> and <code>NUMERIC</code> types only)
3106: * @throws SQLException if (1) the given column index is out of bounds,
3107: * (2) the cursor is not on one of this rowset's rows or its
3108: * insert row, or (3) this rowset is
3109: * <code>ResultSet.CONCUR_READ_ONLY</code>
3110: */
3111: public void updateObject(int columnIndex, Object x, int scale)
3112: throws SQLException {
3113: throw new UnsupportedOperationException();
3114: }
3115:
3116: /**
3117: * Sets the designated column in either the current row or the insert
3118: * row of this <code>CachedRowSetXImpl</code> object with the given
3119: * <code>Object</code> value.
3120: * <P>
3121: * This method updates a column value in either the current row or
3122: * the insert row of this rowset, but it does not update the
3123: * database. If the cursor is on a row in the rowset, the
3124: * method {@link #updateRow} must be called to update the database.
3125: * If the cursor is on the insert row, the method {@link #insertRow}
3126: * must be called, which will insert the new row into both this rowset
3127: * and the database. Both of these methods must be called before the
3128: * cursor moves to another row.
3129: *
3130: * @param columnIndex the first column is <code>1</code>, the second
3131: * is <code>2</code>, and so on; must be <code>1</code> or larger
3132: * and equal to or less than the number of columns in this rowset
3133: * @param x the new column value
3134: * @throws SQLException if (1) the given column index is out of bounds,
3135: * (2) the cursor is not on one of this rowset's rows or its
3136: * insert row, or (3) this rowset is
3137: * <code>ResultSet.CONCUR_READ_ONLY</code>
3138: */
3139: public void updateObject(int columnIndex, Object x)
3140: throws SQLException {
3141: throw new UnsupportedOperationException();
3142: }
3143:
3144: /**
3145: * Sets the designated nullable column in the current row or the
3146: * insert row of this <code>CachedRowSetXImpl</code> object with
3147: * <code>null</code> value.
3148: * <P>
3149: * This method updates a column value in the current row or the insert
3150: * row of this rowset, but it does not update the database.
3151: * If the cursor is on a row in the rowset, the
3152: * method {@link #updateRow} must be called to update the database.
3153: * If the cursor is on the insert row, the method {@link #insertRow}
3154: * must be called, which will insert the new row into both this rowset
3155: * and the database.
3156: *
3157: * @param columnName a <code>String</code> object that must match the
3158: * SQL name of a column in this rowset, ignoring case
3159: * @throws SQLException if (1) the given column name does not match the
3160: * name of a column in this rowset, (2) the cursor is not on
3161: * one of this rowset's rows or its insert row, or (3) this
3162: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3163: */
3164: public void updateNull(String columnName) throws SQLException {
3165: throw new UnsupportedOperationException();
3166: }
3167:
3168: /**
3169: * Sets the designated column in either the current row or the insert
3170: * row of this <code>CachedRowSetXImpl</code> object with the given
3171: * <code>boolean</code> value.
3172: * <P>
3173: * This method updates a column value in the current row or the insert
3174: * row of this rowset, but it does not update the database.
3175: * If the cursor is on a row in the rowset, the
3176: * method {@link #updateRow} must be called to update the database.
3177: * If the cursor is on the insert row, the method {@link #insertRow}
3178: * must be called, which will insert the new row into both this rowset
3179: * and the database. Both of these methods must be called before the
3180: * cursor moves to another row.
3181: *
3182: * @param columnName a <code>String</code> object that must match the
3183: * SQL name of a column in this rowset, ignoring case
3184: * @param x the new column value
3185: * @throws SQLException if (1) the given column name does not match the
3186: * name of a column in this rowset, (2) the cursor is not on
3187: * one of this rowset's rows or its insert row, or (3) this
3188: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3189: */
3190: public void updateBoolean(String columnName, boolean x)
3191: throws SQLException {
3192: throw new UnsupportedOperationException();
3193: }
3194:
3195: /**
3196: * Sets the designated column in either the current row or the insert
3197: * row of this <code>CachedRowSetXImpl</code> object with the given
3198: * <code>byte</code> value.
3199: * <P>
3200: * This method updates a column value in the current row or the insert
3201: * row of this rowset, but it does not update the database.
3202: * If the cursor is on a row in the rowset, the
3203: * method {@link #updateRow} must be called to update the database.
3204: * If the cursor is on the insert row, the method {@link #insertRow}
3205: * must be called, which will insert the new row into both this rowset
3206: * and the database. Both of these methods must be called before the
3207: * cursor moves to another row.
3208: *
3209: * @param columnName a <code>String</code> object that must match the
3210: * SQL name of a column in this rowset, ignoring case
3211: * @param x the new column value
3212: * @throws SQLException if (1) the given column name does not match the
3213: * name of a column in this rowset, (2) the cursor is not on
3214: * one of this rowset's rows or its insert row, or (3) this
3215: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3216: */
3217: public void updateByte(String columnName, byte x)
3218: throws SQLException {
3219: throw new UnsupportedOperationException();
3220: }
3221:
3222: /**
3223: * Sets the designated column in either the current row or the insert
3224: * row of this <code>CachedRowSetXImpl</code> object with the given
3225: * <code>short</code> value.
3226: * <P>
3227: * This method updates a column value in the current row or the insert
3228: * row of this rowset, but it does not update the database.
3229: * If the cursor is on a row in the rowset, the
3230: * method {@link #updateRow} must be called to update the database.
3231: * If the cursor is on the insert row, the method {@link #insertRow}
3232: * must be called, which will insert the new row into both this rowset
3233: * and the database. Both of these methods must be called before the
3234: * cursor moves to another row.
3235: *
3236: * @param columnName a <code>String</code> object that must match the
3237: * SQL name of a column in this rowset, ignoring case
3238: * @param x the new column value
3239: * @throws SQLException if (1) the given column name does not match the
3240: * name of a column in this rowset, (2) the cursor is not on
3241: * one of this rowset's rows or its insert row, or (3) this
3242: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3243: */
3244: public void updateShort(String columnName, short x)
3245: throws SQLException {
3246: throw new UnsupportedOperationException();
3247: }
3248:
3249: /**
3250: * Sets the designated column in either the current row or the insert
3251: * row of this <code>CachedRowSetXImpl</code> object with the given
3252: * <code>int</code> value.
3253: * <P>
3254: * This method updates a column value in the current row or the insert
3255: * row of this rowset, but it does not update the database.
3256: * If the cursor is on a row in the rowset, the
3257: * method {@link #updateRow} must be called to update the database.
3258: * If the cursor is on the insert row, the method {@link #insertRow}
3259: * must be called, which will insert the new row into both this rowset
3260: * and the database. Both of these methods must be called before the
3261: * cursor moves to another row.
3262: *
3263: * @param columnName a <code>String</code> object that must match the
3264: * SQL name of a column in this rowset, ignoring case
3265: * @param x the new column value
3266: * @throws SQLException if (1) the given column name does not match the
3267: * name of a column in this rowset, (2) the cursor is not on
3268: * one of this rowset's rows or its insert row, or (3) this
3269: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3270: */
3271: public void updateInt(String columnName, int x) throws SQLException {
3272: throw new UnsupportedOperationException();
3273: }
3274:
3275: /**
3276: * Sets the designated column in either the current row or the insert
3277: * row of this <code>CachedRowSetXImpl</code> object with the given
3278: * <code>long</code> value.
3279: * <P>
3280: * This method updates a column value in the current row or the insert
3281: * row of this rowset, but it does not update the database.
3282: * If the cursor is on a row in the rowset, the
3283: * method {@link #updateRow} must be called to update the database.
3284: * If the cursor is on the insert row, the method {@link #insertRow}
3285: * must be called, which will insert the new row into both this rowset
3286: * and the database. Both of these methods must be called before the
3287: * cursor moves to another row.
3288: *
3289: * @param columnName a <code>String</code> object that must match the
3290: * SQL name of a column in this rowset, ignoring case
3291: * @param x the new column value
3292: * @throws SQLException if (1) the given column name does not match the
3293: * name of a column in this rowset, (2) the cursor is not on
3294: * one of this rowset's rows or its insert row, or (3) this
3295: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3296: */
3297: public void updateLong(String columnName, long x)
3298: throws SQLException {
3299: throw new UnsupportedOperationException();
3300: }
3301:
3302: /**
3303: * Sets the designated column in either the current row or the insert
3304: * row of this <code>CachedRowSetXImpl</code> object with the given
3305: * <code>float</code> value.
3306: * <P>
3307: * This method updates a column value in the current row or the insert
3308: * row of this rowset, but it does not update the database.
3309: * If the cursor is on a row in the rowset, the
3310: * method {@link #updateRow} must be called to update the database.
3311: * If the cursor is on the insert row, the method {@link #insertRow}
3312: * must be called, which will insert the new row into both this rowset
3313: * and the database. Both of these methods must be called before the
3314: * cursor moves to another row.
3315: *
3316: * @param columnName a <code>String</code> object that must match the
3317: * SQL name of a column in this rowset, ignoring case
3318: * @param x the new column value
3319: * @throws SQLException if (1) the given column name does not match the
3320: * name of a column in this rowset, (2) the cursor is not on
3321: * one of this rowset's rows or its insert row, or (3) this
3322: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3323: */
3324: public void updateFloat(String columnName, float x)
3325: throws SQLException {
3326: throw new UnsupportedOperationException();
3327: }
3328:
3329: /**
3330: * Sets the designated column in either the current row or the insert
3331: * row of this <code>CachedRowSetXImpl</code> object with the given
3332: * <code>double</code> value.
3333: *
3334: * This method updates a column value in either the current row or
3335: * the insert row of this rowset, but it does not update the
3336: * database. If the cursor is on a row in the rowset, the
3337: * method {@link #updateRow} must be called to update the database.
3338: * If the cursor is on the insert row, the method {@link #insertRow}
3339: * must be called, which will insert the new row into both this rowset
3340: * and the database. Both of these methods must be called before the
3341: * cursor moves to another row.
3342: *
3343: * @param columnName a <code>String</code> object that must match the
3344: * SQL name of a column in this rowset, ignoring case
3345: * @param x the new column value
3346: * @throws SQLException if (1) the given column name does not match the
3347: * name of a column in this rowset, (2) the cursor is not on
3348: * one of this rowset's rows or its insert row, or (3) this
3349: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3350: */
3351: public void updateDouble(String columnName, double x)
3352: throws SQLException {
3353: throw new UnsupportedOperationException();
3354: }
3355:
3356: /**
3357: * Sets the designated column in either the current row or the insert
3358: * row of this <code>CachedRowSetXImpl</code> object with the given
3359: * <code>java.math.BigDecimal</code> object.
3360: * <P>
3361: * This method updates a column value in the current row or the insert
3362: * row of this rowset, but it does not update the database.
3363: * If the cursor is on a row in the rowset, the
3364: * method {@link #updateRow} must be called to update the database.
3365: * If the cursor is on the insert row, the method {@link #insertRow}
3366: * must be called, which will insert the new row into both this rowset
3367: * and the database. Both of these methods must be called before the
3368: * cursor moves to another row.
3369: *
3370: * @param columnName a <code>String</code> object that must match the
3371: * SQL name of a column in this rowset, ignoring case
3372: * @param x the new column value
3373: * @throws SQLException if (1) the given column name does not match the
3374: * name of a column in this rowset, (2) the cursor is not on
3375: * one of this rowset's rows or its insert row, or (3) this
3376: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3377: */
3378: public void updateBigDecimal(String columnName, BigDecimal x)
3379: throws SQLException {
3380: throw new UnsupportedOperationException();
3381: }
3382:
3383: /**
3384: * Sets the designated column in either the current row or the insert
3385: * row of this <code>CachedRowSetXImpl</code> object with the given
3386: * <code>String</code> object.
3387: *
3388: * This method updates a column value in either the current row or
3389: * the insert row of this rowset, but it does not update the
3390: * database. If the cursor is on a row in the rowset, the
3391: * method {@link #updateRow} must be called to update the database.
3392: * If the cursor is on the insert row, the method {@link #insertRow}
3393: * must be called, which will insert the new row into both this rowset
3394: * and the database. Both of these methods must be called before the
3395: * cursor moves to another row.
3396: *
3397: * @param columnName a <code>String</code> object that must match the
3398: * SQL name of a column in this rowset, ignoring case
3399: * @param x the new column value
3400: * @throws SQLException if (1) the given column name does not match the
3401: * name of a column in this rowset, (2) the cursor is not on
3402: * one of this rowset's rows or its insert row, or (3) this
3403: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3404: */
3405: public void updateString(String columnName, String x)
3406: throws SQLException {
3407: throw new UnsupportedOperationException();
3408: }
3409:
3410: /**
3411: * Sets the designated column in either the current row or the insert
3412: * row of this <code>CachedRowSetXImpl</code> object with the given
3413: * <code>byte</code> array.
3414: *
3415: * This method updates a column value in either the current row or
3416: * the insert row of this rowset, but it does not update the
3417: * database. If the cursor is on a row in the rowset, the
3418: * method {@link #updateRow} must be called to update the database.
3419: * If the cursor is on the insert row, the method {@link #insertRow}
3420: * must be called, which will insert the new row into both this rowset
3421: * and the database. Both of these methods must be called before the
3422: * cursor moves to another row.
3423: *
3424: * @param columnName a <code>String</code> object that must match the
3425: * SQL name of a column in this rowset, ignoring case
3426: * @param x the new column value
3427: * @throws SQLException if (1) the given column name does not match the
3428: * name of a column in this rowset, (2) the cursor is not on
3429: * one of this rowset's rows or its insert row, or (3) this
3430: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3431: */
3432: public void updateBytes(String columnName, byte x[])
3433: throws SQLException {
3434: throw new UnsupportedOperationException();
3435: }
3436:
3437: /**
3438: * Sets the designated column in either the current row or the insert
3439: * row of this <code>CachedRowSetXImpl</code> object with the given
3440: * <code>Date</code> object.
3441: *
3442: * This method updates a column value in either the current row or
3443: * the insert row of this rowset, but it does not update the
3444: * database. If the cursor is on a row in the rowset, the
3445: * method {@link #updateRow} must be called to update the database.
3446: * If the cursor is on the insert row, the method {@link #insertRow}
3447: * must be called, which will insert the new row into both this rowset
3448: * and the database. Both of these methods must be called before the
3449: * cursor moves to another row.
3450: *
3451: * @param columnName a <code>String</code> object that must match the
3452: * SQL name of a column in this rowset, ignoring case
3453: * @param x the new column value
3454: * @throws SQLException if (1) the given column name does not match the
3455: * name of a column in this rowset, (2) the cursor is not on
3456: * one of this rowset's rows or its insert row, (3) the type
3457: * of the designated column is not an SQL <code>DATE</code> or
3458: * <code>TIMESTAMP</code>, or (4) this rowset is
3459: * <code>ResultSet.CONCUR_READ_ONLY</code>
3460: */
3461: public void updateDate(String columnName, java.sql.Date x)
3462: throws SQLException {
3463: throw new UnsupportedOperationException();
3464: }
3465:
3466: /**
3467: * Sets the designated column in either the current row or the insert
3468: * row of this <code>CachedRowSetXImpl</code> object with the given
3469: * <code>Time</code> object.
3470: *
3471: * This method updates a column value in either the current row or
3472: * the insert row of this rowset, but it does not update the
3473: * database. If the cursor is on a row in the rowset, the
3474: * method {@link #updateRow} must be called to update the database.
3475: * If the cursor is on the insert row, the method {@link #insertRow}
3476: * must be called, which will insert the new row into both this rowset
3477: * and the database. Both of these methods must be called before the
3478: * cursor moves to another row.
3479: *
3480: * @param columnName a <code>String</code> object that must match the
3481: * SQL name of a column in this rowset, ignoring case
3482: * @param x the new column value
3483: * @throws SQLException if (1) the given column name does not match the
3484: * name of a column in this rowset, (2) the cursor is not on
3485: * one of this rowset's rows or its insert row, (3) the type
3486: * of the designated column is not an SQL <code>TIME</code> or
3487: * <code>TIMESTAMP</code>, or (4) this rowset is
3488: * <code>ResultSet.CONCUR_READ_ONLY</code>
3489: */
3490: public void updateTime(String columnName, java.sql.Time x)
3491: throws SQLException {
3492: throw new UnsupportedOperationException();
3493: }
3494:
3495: /**
3496: * Sets the designated column in either the current row or the insert
3497: * row of this <code>CachedRowSetXImpl</code> object with the given
3498: * <code>Timestamp</code> object.
3499: *
3500: * This method updates a column value in either the current row or
3501: * the insert row of this rowset, but it does not update the
3502: * database. If the cursor is on a row in the rowset, the
3503: * method {@link #updateRow} must be called to update the database.
3504: * If the cursor is on the insert row, the method {@link #insertRow}
3505: * must be called, which will insert the new row into both this rowset
3506: * and the database. Both of these methods must be called before the
3507: * cursor moves to another row.
3508: *
3509: * @param columnName a <code>String</code> object that must match the
3510: * SQL name of a column in this rowset, ignoring case
3511: * @param x the new column value
3512: * @throws SQLException if the given column index is out of bounds or
3513: * the cursor is not on one of this rowset's rows or its
3514: * insert row
3515: * @throws SQLException if (1) the given column name does not match the
3516: * name of a column in this rowset, (2) the cursor is not on
3517: * one of this rowset's rows or its insert row, (3) the type
3518: * of the designated column is not an SQL <code>DATE</code>,
3519: * <code>TIME</code>, or <code>TIMESTAMP</code>, or (4) this
3520: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3521: */
3522: public void updateTimestamp(String columnName, java.sql.Timestamp x)
3523: throws SQLException {
3524: throw new UnsupportedOperationException();
3525: }
3526:
3527: /**
3528: * Sets the designated column in either the current row or the insert
3529: * row of this <code>CachedRowSetXImpl</code> object with the given
3530: * ASCII stream value.
3531: * <P>
3532: * This method updates a column value in either the current row or
3533: * the insert row of this rowset, but it does not update the
3534: * database. If the cursor is on a row in the rowset, the
3535: * method {@link #updateRow} must be called to update the database.
3536: * If the cursor is on the insert row, the method {@link #insertRow}
3537: * must be called, which will insert the new row into both this rowset
3538: * and the database. Both of these methods must be called before the
3539: * cursor moves to another row.
3540: *
3541: * @param columnName a <code>String</code> object that must match the
3542: * SQL name of a column in this rowset, ignoring case
3543: * @param x the new column value
3544: * @param length the number of one-byte ASCII characters in the stream
3545: */
3546: public void updateAsciiStream(String columnName,
3547: java.io.InputStream x, int length) throws SQLException {
3548: throw new UnsupportedOperationException();
3549: }
3550:
3551: /**
3552: * Sets the designated column in either the current row or the insert
3553: * row of this <code>CachedRowSetXImpl</code> object with the given
3554: * <code>java.io.InputStream</code> object.
3555: * <P>
3556: * This method updates a column value in either the current row or
3557: * the insert row of this rowset, but it does not update the
3558: * database. If the cursor is on a row in the rowset, the
3559: * method {@link #updateRow} must be called to update the database.
3560: * If the cursor is on the insert row, the method {@link #insertRow}
3561: * must be called, which will insert the new row into both this rowset
3562: * and the database. Both of these methods must be called before the
3563: * cursor moves to another row.
3564: *
3565: * @param columnName a <code>String</code> object that must match the
3566: * SQL name of a column in this rowset, ignoring case
3567: * @param x the new column value; must be a <code>java.io.InputStream</code>
3568: * containing <code>BINARY</code>, <code>VARBINARY</code>, or
3569: * <code>LONGVARBINARY</code> data
3570: * @param length the length of the stream in bytes
3571: * @throws SQLException if (1) the given column name does not match the
3572: * name of a column in this rowset, (2) the cursor is not on
3573: * one of this rowset's rows or its insert row, (3) the data
3574: * in the stream is not binary, or (4) this rowset is
3575: * <code>ResultSet.CONCUR_READ_ONLY</code>
3576: */
3577: public void updateBinaryStream(String columnName,
3578: java.io.InputStream x, int length) throws SQLException {
3579: throw new UnsupportedOperationException();
3580: }
3581:
3582: /**
3583: * Sets the designated column in either the current row or the insert
3584: * row of this <code>CachedRowSetXImpl</code> object with the given
3585: * <code>java.io.Reader</code> object.
3586: * <P>
3587: * This method updates a column value in either the current row or
3588: * the insert row of this rowset, but it does not update the
3589: * database. If the cursor is on a row in the rowset, the
3590: * method {@link #updateRow} must be called to update the database.
3591: * If the cursor is on the insert row, the method {@link #insertRow}
3592: * must be called, which will insert the new row into both this rowset
3593: * and the database. Both of these methods must be called before the
3594: * cursor moves to another row.
3595: *
3596: * @param columnName a <code>String</code> object that must match the
3597: * SQL name of a column in this rowset, ignoring case
3598: * @param reader the new column value; must be a
3599: * <code>java.io.Reader</code> containing <code>BINARY</code>,
3600: * <code>VARBINARY</code>, <code>LONGVARBINARY</code>, <code>CHAR</code>,
3601: * <code>VARCHAR</code>, or <code>LONGVARCHAR</code> data
3602: * @param length the length of the stream in characters
3603: * @throws SQLException if (1) the given column name does not match the
3604: * name of a column in this rowset, (2) the cursor is not on
3605: * one of this rowset's rows or its insert row, (3) the data
3606: * in the stream is not a binary or character type, or (4) this
3607: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3608: */
3609: public void updateCharacterStream(String columnName,
3610: java.io.Reader reader, int length) throws SQLException {
3611: throw new UnsupportedOperationException();
3612: }
3613:
3614: /**
3615: * Sets the designated column in either the current row or the insert
3616: * row of this <code>CachedRowSetXImpl</code> object with the given
3617: * <code>Object</code> value. The <code>scale</code> parameter
3618: * indicates the number of digits to the right of the decimal point
3619: * and is ignored if the new column value is not a type that will be
3620: * mapped to an SQL <code>DECIMAL</code> or <code>NUMERIC</code> value.
3621: * <P>
3622: * This method updates a column value in either the current row or
3623: * the insert row of this rowset, but it does not update the
3624: * database. If the cursor is on a row in the rowset, the
3625: * method {@link #updateRow} must be called to update the database.
3626: * If the cursor is on the insert row, the method {@link #insertRow}
3627: * must be called, which will insert the new row into both this rowset
3628: * and the database. Both of these methods must be called before the
3629: * cursor moves to another row.
3630: *
3631: * @param columnName a <code>String</code> object that must match the
3632: * SQL name of a column in this rowset, ignoring case
3633: * @param x the new column value
3634: * @param scale the number of digits to the right of the decimal point (for
3635: * <code>DECIMAL</code> and <code>NUMERIC</code> types only)
3636: * @throws SQLException if (1) the given column name does not match the
3637: * name of a column in this rowset, (2) the cursor is not on
3638: * one of this rowset's rows or its insert row, or (3) this
3639: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3640: */
3641: public void updateObject(String columnName, Object x, int scale)
3642: throws SQLException {
3643: throw new UnsupportedOperationException();
3644: }
3645:
3646: /**
3647: * Sets the designated column in either the current row or the insert
3648: * row of this <code>CachedRowSetXImpl</code> object with the given
3649: * <code>Object</code> value.
3650: * <P>
3651: * This method updates a column value in either the current row or
3652: * the insert row of this rowset, but it does not update the
3653: * database. If the cursor is on a row in the rowset, the
3654: * method {@link #updateRow} must be called to update the database.
3655: * If the cursor is on the insert row, the method {@link #insertRow}
3656: * must be called, which will insert the new row into both this rowset
3657: * and the database. Both of these methods must be called before the
3658: * cursor moves to another row.
3659: *
3660: * @param columnName a <code>String</code> object that must match the
3661: * SQL name of a column in this rowset, ignoring case
3662: * @param x the new column value
3663: * @throws SQLException if (1) the given column name does not match the
3664: * name of a column in this rowset, (2) the cursor is not on
3665: * one of this rowset's rows or its insert row, or (3) this
3666: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3667: */
3668: public void updateObject(String columnName, Object x)
3669: throws SQLException {
3670: throw new UnsupportedOperationException();
3671: }
3672:
3673: /**
3674: * Inserts the contents of this <code>CachedRowSetXImpl</code> object's insert
3675: * row into this rowset immediately following the current row.
3676: * If the current row is the
3677: * position after the last row or before the first row, the new row will
3678: * be inserted at the end of the rowset. This method also notifies
3679: * listeners registered with this rowset that the row has changed.
3680: * <P>
3681: * The cursor must be on the insert row when this method is called.
3682: *
3683: * @throws SQLException if (1) the cursor is not on the insert row,
3684: * (2) one or more of the non-nullable columns in the insert
3685: * row has not been given a value, or (3) this rowset is
3686: * <code>ResultSet.CONCUR_READ_ONLY</code>
3687: */
3688: public void insertRow() throws SQLException {
3689: throw new UnsupportedOperationException();
3690: }
3691:
3692: /**
3693: * Marks the current row of this <code>CachedRowSetXImpl</code> object as
3694: * updated and notifies listeners registered with this rowset that the
3695: * row has changed.
3696: * <P>
3697: * This method cannot be called when the cursor is on the insert row, and
3698: * it should be called before the cursor moves to another row. If it is
3699: * called after the cursor moves to another row, this method has no effect,
3700: * and the updates made before the cursor moved will be lost.
3701: *
3702: * @throws SQLException if the cursor is on the insert row or this
3703: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3704: */
3705: public void updateRow() throws SQLException {
3706: throw new UnsupportedOperationException();
3707: }
3708:
3709: /**
3710: * Deletes the current row from this <code>CachedRowSetXImpl</code> object and
3711: * notifies listeners registered with this rowset that a row has changed.
3712: * This method cannot be called when the cursor is on the insert row.
3713: * <P>
3714: * This method marks the current row as deleted, but it does not delete
3715: * the row from the underlying data source. The method
3716: * <code>acceptChanges</code> must be called to delete the row in
3717: * the data source.
3718: *
3719: * @throws SQLException if (1) this method is called when the cursor
3720: * is on the insert row, before the first row, or after the
3721: * last row or (2) this rowset is
3722: * <code>ResultSet.CONCUR_READ_ONLY</code>
3723: */
3724: public void deleteRow() throws SQLException {
3725: throw new UnsupportedOperationException();
3726: }
3727:
3728: /**
3729: * Sets the current row with its original value and marks the row as
3730: * not updated, thus undoing any changes made to the row since the
3731: * last call to the methods <code>updateRow</code> or <code>deleteRow</code>.
3732: * This method should be called only when the cursor is on a row in
3733: * this rowset.
3734: *
3735: * @throws SQLException if the cursor is on the insert row, before the
3736: * first row, or after the last row
3737: */
3738: public void refreshRow() throws SQLException {
3739: throw new UnsupportedOperationException();
3740: }
3741:
3742: /**
3743: * Rolls back any updates made to the current row of this
3744: * <code>CachedRowSetXImpl</code> object and notifies listeners that
3745: * a row has changed. To have an effect, this method
3746: * must be called after an <code>updateXXX</code> method has been
3747: * called and before the method <code>updateRow</code> has been called.
3748: * If no updates have been made or the method <code>updateRow</code>
3749: * has already been called, this method has no effect.
3750: *
3751: * @throws SQLException if the cursor is on the insert row, before the
3752: * first row, or after the last row
3753: */
3754: public void cancelRowUpdates() throws SQLException {
3755: throw new UnsupportedOperationException();
3756: }
3757:
3758: /**
3759: * Moves the cursor for this <code>CachedRowSetXImpl</code> object
3760: * to the insert row. The current row in the rowset is remembered
3761: * while the cursor is on the insert row.
3762: * <P>
3763: * The insert row is a special row associated with an updatable
3764: * rowset. It is essentially a buffer where a new row may
3765: * be constructed by calling the appropriate <code>updateXXX</code>
3766: * methods to assign a value to each column in the row. A complete
3767: * row must be constructed; that is, every column that is not nullable
3768: * must be assigned a value. In order for the new row to become part
3769: * of this rowset, the method <code>insertRow</code> must be called
3770: * before the cursor is moved back to the rowset.
3771: * <P>
3772: * Only certain methods may be invoked while the cursor is on the insert
3773: * row; many methods throw an exception if they are called while the
3774: * cursor is there. In addition to the <code>updateXXX</code>
3775: * and <code>insertRow</code> methods, only the <code>getXXX</code> methods
3776: * may be called when the cursor is on the insert row. A <code>getXXX</code>
3777: * method should be called on a column only after an <code>updateXXX</code>
3778: * method has been called on that column; otherwise, the value returned is
3779: * undetermined.
3780: *
3781: * @throws SQLException if this <code>CachedRowSetXImpl</code> object is
3782: * <code>ResultSet.CONCUR_READ_ONLY</code>
3783: */
3784: public void moveToInsertRow() throws SQLException {
3785: throw new UnsupportedOperationException();
3786: }
3787:
3788: /**
3789: * Moves the cursor for this <code>CachedRowSetXImpl</code> object to
3790: * the current row. The current row is the row the cursor was on
3791: * when the method <code>moveToInsertRow</code> was called.
3792: * <P>
3793: * Calling this method has no effect unless it is called while the
3794: * cursor is on the insert row.
3795: *
3796: * @throws SQLException if an error occurs
3797: */
3798: public void moveToCurrentRow() throws SQLException {
3799: throw new UnsupportedOperationException();
3800: }
3801:
3802: /**
3803: * Returns <code>null</code>.
3804: *
3805: * @return <code>null</code>
3806: * @throws SQLException if an error occurs
3807: */
3808: public Statement getStatement() throws SQLException {
3809: throw new UnsupportedOperationException();
3810: }
3811:
3812: /**
3813: * Retrieves the value of the designated column in this
3814: * <code>CachedRowSetXImpl</code> object as an <code>Object</code> in
3815: * the Java programming language, using the given
3816: * <code>java.util.Map</code> object to custom map the value if
3817: * appropriate.
3818: *
3819: * @param columnIndex the first column is <code>1</code>, the second
3820: * is <code>2</code>, and so on; must be <code>1</code> or larger
3821: * and equal to or less than the number of columns in this rowset
3822: * @param map a <code>java.util.Map</code> object showing the mapping
3823: * from SQL type names to classes in the Java programming
3824: * language
3825: * @return an <code>Object</code> representing the SQL value
3826: * @throws SQLException if the given column index is out of bounds or
3827: * the cursor is not on one of this rowset's rows or its
3828: * insert row
3829: */
3830: public Object getObject(int columnIndex, java.util.Map map)
3831: throws SQLException {
3832: throw new UnsupportedOperationException();
3833: }
3834:
3835: /**
3836: * Retrieves the value of the designated column in this
3837: * <code>CachedRowSetXImpl</code> object as a <code>Ref</code> object
3838: * in the Java programming language.
3839: *
3840: * @param columnIndex the first column is <code>1</code>, the second
3841: * is <code>2</code>, and so on; must be <code>1</code> or larger
3842: * and equal to or less than the number of columns in this rowset
3843: * @return a <code>Ref</code> object representing an SQL<code> REF</code> value
3844: * @throws SQLException if (1) the given column index is out of bounds,
3845: * (2) the cursor is not on one of this rowset's rows or its
3846: * insert row, or (3) the designated column does not store an
3847: * SQL <code>REF</code> value
3848: * @see #getRef(String)
3849: */
3850: public Ref getRef(int columnIndex) throws SQLException {
3851: throw new UnsupportedOperationException();
3852: }
3853:
3854: /**
3855: * Retrieves the value of the designated column in this
3856: * <code>CachedRowSetXImpl</code> object as a <code>Blob</code> object
3857: * in the Java programming language.
3858: *
3859: * @param columnIndex the first column is <code>1</code>, the second
3860: * is <code>2</code>, and so on; must be <code>1</code> or larger
3861: * and equal to or less than the number of columns in this rowset
3862: * @return a <code>Blob</code> object representing an SQL <code>BLOB</code> value
3863: * @throws SQLException if (1) the given column index is out of bounds,
3864: * (2) the cursor is not on one of this rowset's rows or its
3865: * insert row, or (3) the designated column does not store an
3866: * SQL <code>BLOB</code> value
3867: * @see #getBlob(String)
3868: */
3869: public Blob getBlob(int columnIndex) throws SQLException {
3870: throw new UnsupportedOperationException();
3871: }
3872:
3873: /**
3874: * Retrieves the value of the designated column in this
3875: * <code>CachedRowSetXImpl</code> object as a <code>Clob</code> object
3876: * in the Java programming language.
3877: *
3878: * @param columnIndex the first column is <code>1</code>, the second
3879: * is <code>2</code>, and so on; must be <code>1</code> or larger
3880: * and equal to or less than the number of columns in this rowset
3881: * @return a <code>Clob</code> object representing an SQL <code>CLOB</code> value
3882: * @throws SQLException if (1) the given column index is out of bounds,
3883: * (2) the cursor is not on one of this rowset's rows or its
3884: * insert row, or (3) the designated column does not store an
3885: * SQL <code>CLOB</code> value
3886: * @see #getClob(String)
3887: */
3888: public Clob getClob(int columnIndex) throws SQLException {
3889: throw new UnsupportedOperationException();
3890: }
3891:
3892: /**
3893: * Retrieves the value of the designated column in this
3894: * <code>CachedRowSetXImpl</code> object as an <code>Array</code> object
3895: * in the Java programming language.
3896: *
3897: * @param columnIndex the first column is <code>1</code>, the second
3898: * is <code>2</code>, and so on; must be <code>1</code> or larger
3899: * and equal to or less than the number of columns in this rowset
3900: * @return an <code>Array</code> object representing an SQL
3901: * <code>ARRAY</code> value
3902: * @throws SQLException if (1) the given column index is out of bounds,
3903: * (2) the cursor is not on one of this rowset's rows or its
3904: * insert row, or (3) the designated column does not store an
3905: * SQL <code>ARRAY</code> value
3906: * @see #getArray(String)
3907: */
3908: public Array getArray(int columnIndex) throws SQLException {
3909: throw new UnsupportedOperationException();
3910: }
3911:
3912: /**
3913: * Retrieves the value of the designated column in this
3914: * <code>CachedRowSetXImpl</code> object as an <code>Object</code> in
3915: * the Java programming language, using the given
3916: * <code>java.util.Map</code> object to custom map the value if
3917: * appropriate.
3918: *
3919: * @param columnName a <code>String</code> object that must match the
3920: * SQL name of a column in this rowset, ignoring case
3921: * @param map a <code>java.util.Map</code> object showing the mapping
3922: * from SQL type names to classes in the Java programming
3923: * language
3924: * @return an <code>Object</code> representing the SQL value
3925: * @throws SQLException if the given column name is not the name of
3926: * a column in this rowset or the cursor is not on one of
3927: * this rowset's rows or its insert row
3928: */
3929: public Object getObject(String columnName, java.util.Map map)
3930: throws SQLException {
3931: throw new UnsupportedOperationException();
3932: }
3933:
3934: /**
3935: * Retrieves the value of the designated column in this
3936: * <code>CachedRowSetXImpl</code> object as a <code>Ref</code> object
3937: * in the Java programming language.
3938: *
3939: * @param colName a <code>String</code> object that must match the
3940: * SQL name of a column in this rowset, ignoring case
3941: * @return a <code>Ref</code> object representing an SQL<code> REF</code> value
3942: * @throws SQLException if (1) the given column name is not the name of
3943: * a column in this rowset, (2) the cursor is not on one of
3944: * this rowset's rows or its insert row, or (3) the column value
3945: * is not an SQL <code>REF</code> value
3946: * @see #getRef(int)
3947: */
3948: public Ref getRef(String colName) throws SQLException {
3949: throw new UnsupportedOperationException();
3950: }
3951:
3952: /**
3953: * Retrieves the value of the designated column in this
3954: * <code>CachedRowSetXImpl</code> object as a <code>Blob</code> object
3955: * in the Java programming language.
3956: *
3957: * @param colName a <code>String</code> object that must match the
3958: * SQL name of a column in this rowset, ignoring case
3959: * @return a <code>Blob</code> object representing an SQL <code>BLOB</code> value
3960: * @throws SQLException if (1) the given column name is not the name of
3961: * a column in this rowset, (2) the cursor is not on one of
3962: * this rowset's rows or its insert row, or (3) the designated
3963: * column does not store an SQL <code>BLOB</code> value
3964: * @see #getBlob(int)
3965: */
3966: public Blob getBlob(String colName) throws SQLException {
3967: throw new UnsupportedOperationException();
3968: }
3969:
3970: /**
3971: * Retrieves the value of the designated column in this
3972: * <code>CachedRowSetXImpl</code> object as a <code>Clob</code> object
3973: * in the Java programming language.
3974: *
3975: * @param colName a <code>String</code> object that must match the
3976: * SQL name of a column in this rowset, ignoring case
3977: * @return a <code>Clob</code> object representing an SQL
3978: * <code>CLOB</code> value
3979: * @throws SQLException if (1) the given column name is not the name of
3980: * a column in this rowset, (2) the cursor is not on one of
3981: * this rowset's rows or its insert row, or (3) the designated
3982: * column does not store an SQL <code>CLOB</code> value
3983: * @see #getClob(int)
3984: */
3985: public Clob getClob(String colName) throws SQLException {
3986: throw new UnsupportedOperationException();
3987: }
3988:
3989: /**
3990: * Retrieves the value of the designated column in this
3991: * <code>CachedRowSetXImpl</code> object as an <code>Array</code> object
3992: * in the Java programming langugage.
3993: *
3994: * @param colName a <code>String</code> object that must match the
3995: * SQL name of a column in this rowset, ignoring case
3996: * @return an <code>Array</code> object representing an SQL
3997: * <code>ARRAY</code> value
3998: * @throws SQLException if (1) the given column name is not the name of
3999: * a column in this rowset, (2) the cursor is not on one of
4000: * this rowset's rows or its insert row, or (3) the designated
4001: * column does not store an SQL <code>ARRAY</code> value
4002: * @see #getArray(int)
4003: */
4004: public Array getArray(String colName) throws SQLException {
4005: throw new UnsupportedOperationException();
4006: }
4007:
4008: /**
4009: * Retrieves the value of the designated column in the current row
4010: * of this <code>CachedRowSetXImpl</code> object as a <code>java.sql.Date</code>
4011: * object, using the given <code>Calendar</code> object to construct an
4012: * appropriate millisecond value for the date.
4013: *
4014: * @param columnIndex the first column is <code>1</code>, the second
4015: * is <code>2</code>, and so on; must be <code>1</code> or larger
4016: * and equal to or less than the number of columns in the rowset
4017: * @param cal the <code>java.util.Calendar</code> object to use in
4018: * constructing the date
4019: * @return the column value; if the value is SQL <code>NULL</code>,
4020: * the result is <code>null</code>
4021: * @throws SQLException if (1) the given column name is not the name of
4022: * a column in this rowset, (2) the cursor is not on one of
4023: * this rowset's rows or its insert row, or (3) the designated
4024: * column does not store an SQL <code>DATE</code> or
4025: * <code>TIMESTAMP</code> value
4026: */
4027: public java.sql.Date getDate(int columnIndex, Calendar cal)
4028: throws SQLException {
4029: throw new UnsupportedOperationException();
4030: }
4031:
4032: /**
4033: * Retrieves the value of the designated column in the current row
4034: * of this <code>CachedRowSetXImpl</code> object as a <code>java.sql.Date</code>
4035: * object, using the given <code>Calendar</code> object to construct an
4036: * appropriate millisecond value for the date.
4037: *
4038: * @param columnName a <code>String</code> object that must match the
4039: * SQL name of a column in this rowset, ignoring case
4040: * @param cal the <code>java.util.Calendar</code> object to use in
4041: * constructing the date
4042: * @return the column value; if the value is SQL <code>NULL</code>,
4043: * the result is <code>null</code>
4044: * @throws SQLException if (1) the given column name is not the name of
4045: * a column in this rowset, (2) the cursor is not on one of
4046: * this rowset's rows or its insert row, or (3) the designated
4047: * column does not store an SQL <code>DATE</code> or
4048: * <code>TIMESTAMP</code> value
4049: */
4050: public java.sql.Date getDate(String columnName, Calendar cal)
4051: throws SQLException {
4052: throw new UnsupportedOperationException();
4053: }
4054:
4055: /**
4056: * Retrieves the value of the designated column in the current row
4057: * of this <code>CachedRowSetXImpl</code> object as a <code>java.sql.Time</code>
4058: * object, using the given <code>Calendar</code> object to construct an
4059: * appropriate millisecond value for the date.
4060: *
4061: * @param columnIndex the first column is <code>1</code>, the second
4062: * is <code>2</code>, and so on; must be <code>1</code> or larger
4063: * and equal to or less than the number of columns in the rowset
4064: * @param cal the <code>java.util.Calendar</code> object to use in
4065: * constructing the date
4066: * @return the column value; if the value is SQL <code>NULL</code>,
4067: * the result is <code>null</code>
4068: * @throws SQLException if (1) the given column name is not the name of
4069: * a column in this rowset, (2) the cursor is not on one of
4070: * this rowset's rows or its insert row, or (3) the designated
4071: * column does not store an SQL <code>TIME</code> or
4072: * <code>TIMESTAMP</code> value
4073: */
4074: public java.sql.Time getTime(int columnIndex, Calendar cal)
4075: throws SQLException {
4076: throw new UnsupportedOperationException();
4077: }
4078:
4079: /**
4080: * Retrieves the value of the designated column in the current row
4081: * of this <code>CachedRowSetXImpl</code> object as a <code>java.sql.Time</code>
4082: * object, using the given <code>Calendar</code> object to construct an
4083: * appropriate millisecond value for the date.
4084: *
4085: * @param columnName a <code>String</code> object that must match the
4086: * SQL name of a column in this rowset, ignoring case
4087: * @param cal the <code>java.util.Calendar</code> object to use in
4088: * constructing the date
4089: * @return the column value; if the value is SQL <code>NULL</code>,
4090: * the result is <code>null</code>
4091: * @throws SQLException if (1) the given column name is not the name of
4092: * a column in this rowset, (2) the cursor is not on one of
4093: * this rowset's rows or its insert row, or (3) the designated
4094: * column does not store an SQL <code>TIME</code> or
4095: * <code>TIMESTAMP</code> value
4096: */
4097: public java.sql.Time getTime(String columnName, Calendar cal)
4098: throws SQLException {
4099: throw new UnsupportedOperationException();
4100: }
4101:
4102: /**
4103: * Retrieves the value of the designated column in the current row
4104: * of this <code>CachedRowSetXImpl</code> object as a <code>java.sql.Timestamp</code>
4105: * object, using the given <code>Calendar</code> object to construct an
4106: * appropriate millisecond value for the date.
4107: *
4108: * @param columnIndex the first column is <code>1</code>, the second
4109: * is <code>2</code>, and so on; must be <code>1</code> or larger
4110: * and equal to or less than the number of columns in the rowset
4111: * @param cal the <code>java.util.Calendar</code> object to use in
4112: * constructing the date
4113: * @return the column value; if the value is SQL <code>NULL</code>,
4114: * the result is <code>null</code>
4115: * @throws SQLException if (1) the given column name is not the name of
4116: * a column in this rowset, (2) the cursor is not on one of
4117: * this rowset's rows or its insert row, or (3) the designated
4118: * column does not store an SQL <code>TIME</code> or
4119: * <code>TIMESTAMP</code> value
4120: */
4121: public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal)
4122: throws SQLException {
4123: throw new UnsupportedOperationException();
4124: }
4125:
4126: /**
4127: * Retrieves the value of the designated column in the current row
4128: * of this <code>CachedRowSetXImpl</code> object as a
4129: * <code>java.sql.Timestamp</code> object, using the given
4130: * <code>Calendar</code> object to construct an appropriate
4131: * millisecond value for the date.
4132: *
4133: * @param columnName a <code>String</code> object that must match the
4134: * SQL name of a column in this rowset, ignoring case
4135: * @param cal the <code>java.util.Calendar</code> object to use in
4136: * constructing the date
4137: * @return the column value; if the value is SQL <code>NULL</code>,
4138: * the result is <code>null</code>
4139: * @throws SQLException if (1) the given column name is not the name of
4140: * a column in this rowset, (2) the cursor is not on one of
4141: * this rowset's rows or its insert row, or (3) the designated
4142: * column does not store an SQL <code>DATE</code>,
4143: * <code>TIME</code>, or <code>TIMESTAMP</code> value
4144: */
4145: public java.sql.Timestamp getTimestamp(String columnName,
4146: Calendar cal) throws SQLException {
4147: throw new UnsupportedOperationException();
4148: }
4149:
4150: /*
4151: * RowSetInternal Interface
4152: */
4153:
4154: /**
4155: * Retrieves the <code>Connection</code> object passed to this
4156: * <code>CachedRowSetXImpl</code> object. This connection may be
4157: * used to populate this rowset with data or to write data back
4158: * to its underlying data source.
4159: *
4160: * @return the <code>Connection</code> object passed to this rowset;
4161: * may be <code>null</code> if there is no connection
4162: * @throws SQLException if an error occurs
4163: */
4164: public Connection getConnection() throws SQLException {
4165: throw new UnsupportedOperationException();
4166: }
4167:
4168: /**
4169: * Sets the metadata for this <code>CachedRowSetXImpl</code> object
4170: * with the given <code>RowSetMetaData</code> object.
4171: *
4172: * @param md a <code>RowSetMetaData</code> object instance containing
4173: * metadata about the columsn in the rowset
4174: * @throws SQLException if invalid meta data is supplied to the
4175: * rowset
4176: */
4177: public void setMetaData(RowSetMetaData md) throws SQLException {
4178: throw new UnsupportedOperationException();
4179: }
4180:
4181: /**
4182: * Returns a result set containing the original value of the rowset. The
4183: * original value is the state of the <code>CachedRowSetXImpl</code> after the
4184: * last population or synchronization (whichever occured most recently) with
4185: * the data source.
4186: * <p>
4187: * The cursor is positioned before the first row in the result set.
4188: * Only rows contained in the result set returned by <code>getOriginal()</code>
4189: * are said to have an original value.
4190: *
4191: * @return the original result set of the rowset
4192: * @throws SQLException if an error occurs produce the
4193: * <code>ResultSet</code> object
4194: */
4195: public ResultSet getOriginal() throws SQLException {
4196: throw new UnsupportedOperationException();
4197: }
4198:
4199: /**
4200: * Returns a result set containing the original value of the current
4201: * row only.
4202: * The original value is the state of the <code>CachedRowSetXImpl</code> after
4203: * the last population or synchronization (whichever occured most recently)
4204: * with the data source.
4205: *
4206: * @return the original result set of the row
4207: * @throws SQLException if there is no current row
4208: * @see #setOriginalRow
4209: */
4210: public ResultSet getOriginalRow() throws SQLException {
4211: throw new UnsupportedOperationException();
4212:
4213: }
4214:
4215: /**
4216: * Marks the current row in this rowset as being an original row.
4217: *
4218: * @throws SQLException if there is no current row
4219: * @see #getOriginalRow
4220: */
4221: public void setOriginalRow() throws SQLException {
4222: throw new UnsupportedOperationException();
4223: }
4224:
4225: /**
4226: * Marks all rows in this rowset as being original rows. Any updates
4227: * made to the rows become the original values for the rowset.
4228: * Calls to the method <code>setOriginal</code> connot be reversed.
4229: *
4230: * @throws SQLException if an error occurs
4231: */
4232: public void setOriginal() throws SQLException {
4233: throw new UnsupportedOperationException();
4234: }
4235:
4236: /**
4237: * Returns an identifier for the object (table) that was used to create this
4238: * rowset.
4239: *
4240: * @return a <code>String</code> object that identifies the table from
4241: * which this <code>CachedRowSetXImpl</code> object was derived
4242: * @throws SQLException if an error occurs
4243: */
4244: public String getTableName() throws SQLException {
4245: throw new UnsupportedOperationException();
4246: }
4247:
4248: /**
4249: * Sets the identifier for the table from which this rowset was derived
4250: * to the given table name.
4251: *
4252: * @param tabName a <code>String</code> object that identifies the
4253: * table from which this <code>CachedRowSetXImpl</code> object
4254: * was derived
4255: * @throws SQLException if an error occurs
4256: */
4257: public void setTableName(String tabName) throws SQLException {
4258: throw new UnsupportedOperationException();
4259: }
4260:
4261: /**
4262: * Returns the columns that make a key to uniquely identify a
4263: * row in this <code>CachedRowSetXImpl</code> object.
4264: *
4265: * @return an array of column numbers that constitutes a primary
4266: * key for this rowset. This array should be empty
4267: * if no column is representitive of a primary key
4268: * @throws SQLException if the rowset is empty or no columns
4269: * are designated as primary keys
4270: * @see #setKeyColumns
4271: */
4272: public int[] getKeyColumns() throws SQLException {
4273: throw new UnsupportedOperationException();
4274: }
4275:
4276: /**
4277: * Sets this <code>CachedRowSetXImpl</code> object's
4278: * <code>keyCols</code> field with the given array of column
4279: * numbers, which forms a key for uniquely identifying a row
4280: * in this rowset.
4281: *
4282: * @param keys an array of <code>int</code> indicating the
4283: * columns that form a primary key for this
4284: * <code>CachedRowSetXImpl</code> object; every
4285: * element in the array must be greater than
4286: * <code>0</code> and less than or equal to the number
4287: * of columns in this rowset
4288: * @throws SQLException if any of the numbers in the
4289: * given array is not valid for this rowset
4290: * @see #getKeyColumns
4291: */
4292: public void setKeyColumns(int[] keys) throws SQLException {
4293: throw new UnsupportedOperationException();
4294: }
4295:
4296: /**
4297: * Sets the designated column in either the current row or the insert
4298: * row of this <code>CachedRowSetXImpl</code> object with the given
4299: * <code>double</code> value.
4300: *
4301: * This method updates a column value in either the current row or
4302: * the insert row of this rowset, but it does not update the
4303: * database. If the cursor is on a row in the rowset, the
4304: * method {@link #updateRow} must be called to update the database.
4305: * If the cursor is on the insert row, the method {@link #insertRow}
4306: * must be called, which will insert the new row into both this rowset
4307: * and the database. Both of these methods must be called before the
4308: * cursor moves to another row.
4309: *
4310: * @param columnIndex the first column is <code>1</code>, the second
4311: * is <code>2</code>, and so on; must be <code>1</code> or larger
4312: * and equal to or less than the number of columns in this rowset
4313: * @param ref the new column <code>java.sql.Ref</code> value
4314: * @throws SQLException if (1) the given column index is out of bounds,
4315: * (2) the cursor is not on one of this rowset's rows or its
4316: * insert row, or (3) this rowset is
4317: * <code>ResultSet.CONCUR_READ_ONLY</code>
4318: */
4319: public void updateRef(int columnIndex, java.sql.Ref ref)
4320: throws SQLException {
4321: throw new UnsupportedOperationException();
4322: }
4323:
4324: /**
4325: * Sets the designated column in either the current row or the insert
4326: * row of this <code>CachedRowSetXImpl</code> object with the given
4327: * <code>double</code> value.
4328: *
4329: * This method updates a column value in either the current row or
4330: * the insert row of this rowset, but it does not update the
4331: * database. If the cursor is on a row in the rowset, the
4332: * method {@link #updateRow} must be called to update the database.
4333: * If the cursor is on the insert row, the method {@link #insertRow}
4334: * must be called, which will insert the new row into both this rowset
4335: * and the database. Both of these methods must be called before the
4336: * cursor moves to another row.
4337: *
4338: * @param columnName a <code>String</code> object that must match the
4339: * SQL name of a column in this rowset, ignoring case
4340: * @param ref the new column <code>java.sql.Ref</code> value
4341: * @throws SQLException if (1) the given column name does not match the
4342: * name of a column in this rowset, (2) the cursor is not on
4343: * one of this rowset's rows or its insert row, or (3) this
4344: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4345: */
4346: public void updateRef(String columnName, java.sql.Ref ref)
4347: throws SQLException {
4348: throw new UnsupportedOperationException();
4349: }
4350:
4351: /**
4352: * Sets the designated column in either the current row or the insert
4353: * row of this <code>CachedRowSetXImpl</code> object with the given
4354: * <code>double</code> value.
4355: *
4356: * This method updates a column value in either the current row or
4357: * the insert row of this rowset, but it does not update the
4358: * database. If the cursor is on a row in the rowset, the
4359: * method {@link #updateRow} must be called to update the database.
4360: * If the cursor is on the insert row, the method {@link #insertRow}
4361: * must be called, which will insert the new row into both this rowset
4362: * and the database. Both of these methods must be called before the
4363: * cursor moves to another row.
4364: *
4365: * @param columnIndex the first column is <code>1</code>, the second
4366: * is <code>2</code>, and so on; must be <code>1</code> or larger
4367: * and equal to or less than the number of columns in this rowset
4368: * @param c the new column <code>Clob value
4369: * @throws SQLException if (1) the given column index is out of bounds,
4370: * (2) the cursor is not on one of this rowset's rows or its
4371: * insert row, or (3) this rowset is
4372: * <code>ResultSet.CONCUR_READ_ONLY</code>
4373: */
4374: public void updateClob(int columnIndex, Clob c) throws SQLException {
4375: throw new UnsupportedOperationException();
4376: }
4377:
4378: /**
4379: * Sets the designated column in either the current row or the insert
4380: * row of this <code>CachedRowSetXImpl</code> object with the given
4381: * <code>double</code> value.
4382: *
4383: * This method updates a column value in either the current row or
4384: * the insert row of this rowset, but it does not update the
4385: * database. If the cursor is on a row in the rowset, the
4386: * method {@link #updateRow} must be called to update the database.
4387: * If the cursor is on the insert row, the method {@link #insertRow}
4388: * must be called, which will insert the new row into both this rowset
4389: * and the database. Both of these methods must be called before the
4390: * cursor moves to another row.
4391: *
4392: * @param columnName a <code>String</code> object that must match the
4393: * SQL name of a column in this rowset, ignoring case
4394: * @param c the new column <code>Clob</code>value
4395: * @throws SQLException if (1) the given column name does not match the
4396: * name of a column in this rowset, (2) the cursor is not on
4397: * one of this rowset's rows or its insert row, or (3) this
4398: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4399: */
4400: public void updateClob(String columnName, Clob c)
4401: throws SQLException {
4402: throw new UnsupportedOperationException();
4403: }
4404:
4405: /**
4406: * Sets the designated column in either the current row or the insert
4407: * row of this <code>CachedRowSetXImpl</code> object with the given
4408: * <code>java.sql.Blob</code> value.
4409: *
4410: * This method updates a column value in either the current row or
4411: * the insert row of this rowset, but it does not update the
4412: * database. If the cursor is on a row in the rowset, the
4413: * method {@link #updateRow} must be called to update the database.
4414: * If the cursor is on the insert row, the method {@link #insertRow}
4415: * must be called, which will insert the new row into both this rowset
4416: * and the database. Both of these methods must be called before the
4417: * cursor moves to another row.
4418: *
4419: * @param columnIndex the first column is <code>1</code>, the second
4420: * is <code>2</code>, and so on; must be <code>1</code> or larger
4421: * and equal to or less than the number of columns in this rowset
4422: * @param b the new column <code>Blob</code> value
4423: * @throws SQLException if (1) the given column index is out of bounds,
4424: * (2) the cursor is not on one of this rowset's rows or its
4425: * insert row, or (3) this rowset is
4426: * <code>ResultSet.CONCUR_READ_ONLY</code>
4427: */
4428: public void updateBlob(int columnIndex, Blob b) throws SQLException {
4429: throw new UnsupportedOperationException();
4430: }
4431:
4432: /**
4433: * Sets the designated column in either the current row or the insert
4434: * row of this <code>CachedRowSetXImpl</code> object with the given
4435: * <code>java.sql.Blob </code> value.
4436: *
4437: * This method updates a column value in either the current row or
4438: * the insert row of this rowset, but it does not update the
4439: * database. If the cursor is on a row in the rowset, the
4440: * method {@link #updateRow} must be called to update the database.
4441: * If the cursor is on the insert row, the method {@link #insertRow}
4442: * must be called, which will insert the new row into both this rowset
4443: * and the database. Both of these methods must be called before the
4444: * cursor moves to another row.
4445: *
4446: * @param columnName a <code>String</code> object that must match the
4447: * SQL name of a column in this rowset, ignoring case
4448: * @param b the new column <code>Blob</code> value
4449: * @throws SQLException if (1) the given column name does not match the
4450: * name of a column in this rowset, (2) the cursor is not on
4451: * one of this rowset's rows or its insert row, or (3) this
4452: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4453: */
4454: public void updateBlob(String columnName, Blob b)
4455: throws SQLException {
4456: throw new UnsupportedOperationException();
4457: }
4458:
4459: /**
4460: * Sets the designated column in either the current row or the insert
4461: * row of this <code>CachedRowSetXImpl</code> object with the given
4462: * <code>java.sql.Array</code> values.
4463: *
4464: * This method updates a column value in either the current row or
4465: * the insert row of this rowset, but it does not update the
4466: * database. If the cursor is on a row in the rowset, the
4467: * method {@link #updateRow} must be called to update the database.
4468: * If the cursor is on the insert row, the method {@link #insertRow}
4469: * must be called, which will insert the new row into both this rowset
4470: * and the database. Both of these methods must be called before the
4471: * cursor moves to another row.
4472: *
4473: * @param columnIndex the first column is <code>1</code>, the second
4474: * is <code>2</code>, and so on; must be <code>1</code> or larger
4475: * and equal to or less than the number of columns in this rowset
4476: * @param a the new column <code>Array</code> value
4477: * @throws SQLException if (1) the given column index is out of bounds,
4478: * (2) the cursor is not on one of this rowset's rows or its
4479: * insert row, or (3) this rowset is
4480: * <code>ResultSet.CONCUR_READ_ONLY</code>
4481: */
4482: public void updateArray(int columnIndex, Array a)
4483: throws SQLException {
4484: throw new UnsupportedOperationException();
4485: }
4486:
4487: /**
4488: * Sets the designated column in either the current row or the insert
4489: * row of this <code>CachedRowSetXImpl</code> object with the given
4490: * <code>java.sql.Array</code> value.
4491: *
4492: * This method updates a column value in either the current row or
4493: * the insert row of this rowset, but it does not update the
4494: * database. If the cursor is on a row in the rowset, the
4495: * method {@link #updateRow} must be called to update the database.
4496: * If the cursor is on the insert row, the method {@link #insertRow}
4497: * must be called, which will insert the new row into both this rowset
4498: * and the database. Both of these methods must be called before the
4499: * cursor moves to another row.
4500: *
4501: * @param columnName a <code>String</code> object that must match the
4502: * SQL name of a column in this rowset, ignoring case
4503: * @param a the new column <code>Array</code> value
4504: * @throws SQLException if (1) the given column name does not match the
4505: * name of a column in this rowset, (2) the cursor is not on
4506: * one of this rowset's rows or its insert row, or (3) this
4507: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
4508: */
4509: public void updateArray(String columnName, Array a)
4510: throws SQLException {
4511: throw new UnsupportedOperationException();
4512: }
4513:
4514: /**
4515: * Retrieves the value of the designated column in this
4516: * <code>CachedRowSetXImpl</code> object as a <code>java.net.URL</code> object
4517: * in the Java programming language.
4518: *
4519: * @return a java.net.URL object containing the resource reference described by
4520: * the URL
4521: * @throws SQLException if (1) the given column index is out of bounds,
4522: * (2) the cursor is not on one of this rowset's rows or its
4523: * insert row, or (3) the designated column does not store an
4524: * SQL <code>DATALINK</code> value.
4525: * @see #getURL(String)
4526: */
4527: public java.net.URL getURL(int columnIndex) throws SQLException {
4528: throw new UnsupportedOperationException();
4529: }
4530:
4531: /**
4532: * Retrieves the value of the designated column in this
4533: * <code>CachedRowSetXImpl</code> object as a <code>java.net.URL</code> object
4534: * in the Java programming language.
4535: *
4536: * @return a java.net.URL object containing the resource reference described by
4537: * the URL
4538: * @throws SQLException if (1) the given column name not the name of a column
4539: * in this rowset, or
4540: * (2) the cursor is not on one of this rowset's rows or its
4541: * insert row, or (3) the designated column does not store an
4542: * SQL <code>DATALINK</code> value.
4543: * @see #getURL(int)
4544: */
4545: public java.net.URL getURL(String columnName) throws SQLException {
4546: throw new UnsupportedOperationException();
4547:
4548: }
4549:
4550: /**
4551: * The first warning reported by calls on this <code>CachedRowSetXImpl</code>
4552: * object is returned. Subsequent <code>CachedRowSetXImpl</code> warnings will
4553: * be chained to this <code>SQLWarning</code>. All <code>RowSetWarnings</code>
4554: * warnings are generated in the disconnected environment and remain a
4555: * seperate warning chain to that provided by the <code>getWarnings</code>
4556: * method.
4557: *
4558: * <P>The warning chain is automatically cleared each time a new
4559: * row is read.
4560: *
4561: * <P><B>Note:</B> This warning chain only covers warnings caused
4562: * by <code>CachedRowSet</code> (and their child interface)
4563: * methods. All <code>SQLWarnings</code> can be obtained using the
4564: * <code>getWarnings</code> method which tracks warnings generated
4565: * by the underlying JDBC driver.
4566: * @return the first SQLWarning or null
4567: *
4568: */
4569: public RowSetWarning getRowSetWarnings() {
4570: throw new UnsupportedOperationException();
4571: }
4572:
4573: /**
4574: * Commits all changes performed by the <code>acceptChanges()</code>
4575: * methods
4576: *
4577: * @see java.sql.Connection#commit
4578: */
4579: public void commit() throws SQLException {
4580: throw new UnsupportedOperationException();
4581: }
4582:
4583: /**
4584: * Rolls back all changes performed by the <code>acceptChanges()</code>
4585: * methods
4586: *
4587: * @see java.sql.Connection#rollback
4588: */
4589: public void rollback() throws SQLException {
4590: throw new UnsupportedOperationException();
4591: }
4592:
4593: /**
4594: * Rolls back all changes performed by the <code>acceptChanges()</code>
4595: * to the last <code>Savepoint</code> transaction marker.
4596: *
4597: * @see java.sql.Connection#rollback(Savepoint)
4598: */
4599: public void rollback(Savepoint s) throws SQLException {
4600: throw new UnsupportedOperationException();
4601: }
4602:
4603: /**
4604: * Unsets the designated parameter to the given int array.
4605: * This was set using <code>setMatchColumn</code>
4606: * as the column which will form the basis of the join.
4607: * <P>
4608: * The parameter value unset by this method should be same
4609: * as was set.
4610: *
4611: * @param columnIdxes the index into this rowset
4612: * object's internal representation of parameter values
4613: * @throws SQLException if an error occurs or the
4614: * parameter index is out of bounds or if the columnIdx is
4615: * not the same as set using <code>setMatchColumn(int [])</code>
4616: */
4617: public void unsetMatchColumn(int[] columnIdxes) throws SQLException {
4618: throw new UnsupportedOperationException();
4619: }
4620:
4621: /**
4622: * Unsets the designated parameter to the given String array.
4623: * This was set using <code>setMatchColumn</code>
4624: * as the column which will form the basis of the join.
4625: * <P>
4626: * The parameter value unset by this method should be same
4627: * as was set.
4628: *
4629: * @param columnIdxes the columnIndexes to unset
4630: * @throws SQLException if an error occurs or the
4631: * parameter index is out of bounds or if the columnName is
4632: * not the same as set using <code>setMatchColumn(String [])</code>
4633: */
4634: public void unsetMatchColumn(String[] columnIdxes)
4635: throws SQLException {
4636: throw new UnsupportedOperationException();
4637: }
4638:
4639: /**
4640: * Retrieves the column name as <code>String</code> array
4641: * that was set using <code>setMatchColumn(String [])</code>
4642: * for this rowset.
4643: *
4644: * @return a <code>String</code> array object that contains the column names
4645: * for the rowset which has this the match columns
4646: *
4647: * @throws SQLException if an error occurs or column name is not set
4648: */
4649: public String[] getMatchColumnNames() throws SQLException {
4650: throw new UnsupportedOperationException();
4651: }
4652:
4653: /**
4654: * Retrieves the column id as <code>int</code> array that was set using
4655: * <code>setMatchColumn(int [])</code> for this rowset.
4656: *
4657: * @return a <code>int</code> array object that contains the column ids
4658: * for the rowset which has this as the match columns.
4659: *
4660: * @throws SQLException if an error occurs or column index is not set
4661: */
4662: public int[] getMatchColumnIndexes() throws SQLException {
4663: throw new UnsupportedOperationException();
4664: }
4665:
4666: /**
4667: * Sets the designated parameter to the given int array.
4668: * This forms the basis of the join for the
4669: * <code>JoinRowSet</code> as the column which will form the basis of the
4670: * join.
4671: * <P>
4672: * The parameter value set by this method is stored internally and
4673: * will be supplied as the appropriate parameter in this rowset's
4674: * command when the method <code>getMatchColumnIndexes</code> is called.
4675: *
4676: * @param columnIdxes the indexes into this rowset
4677: * object's internal representation of parameter values; the
4678: * first parameter is 0, the second is 1, and so on; must be
4679: * <code>0</code> or greater
4680: * @throws SQLException if an error occurs or the
4681: * parameter index is out of bounds
4682: */
4683: public void setMatchColumn(int[] columnIdxes) throws SQLException {
4684: throw new UnsupportedOperationException();
4685: }
4686:
4687: /**
4688: * Sets the designated parameter to the given String array.
4689: * This forms the basis of the join for the
4690: * <code>JoinRowSet</code> as the column which will form the basis of the
4691: * join.
4692: * <P>
4693: * The parameter value set by this method is stored internally and
4694: * will be supplied as the appropriate parameter in this rowset's
4695: * command when the method <code>getMatchColumn</code> is called.
4696: *
4697: * @param columnNames the name of the column into this rowset
4698: * object's internal representation of parameter values
4699: * @throws SQLException if an error occurs or the
4700: * parameter index is out of bounds
4701: */
4702: public void setMatchColumn(String[] columnNames)
4703: throws SQLException {
4704: throw new UnsupportedOperationException();
4705: }
4706:
4707: /**
4708: * Sets the designated parameter to the given <code>int</code>
4709: * object. This forms the basis of the join for the
4710: * <code>JoinRowSet</code> as the column which will form the basis of the
4711: * join.
4712: * <P>
4713: * The parameter value set by this method is stored internally and
4714: * will be supplied as the appropriate parameter in this rowset's
4715: * command when the method <code>getMatchColumn</code> is called.
4716: *
4717: * @param columnIdx the index into this rowset
4718: * object's internal representation of parameter values; the
4719: * first parameter is 0, the second is 1, and so on; must be
4720: * <code>0</code> or greater
4721: * @throws SQLException if an error occurs or the
4722: * parameter index is out of bounds
4723: */
4724: public void setMatchColumn(int columnIdx) throws SQLException {
4725: throw new UnsupportedOperationException();
4726: }
4727:
4728: /**
4729: * Sets the designated parameter to the given <code>String</code>
4730: * object. This forms the basis of the join for the
4731: * <code>JoinRowSet</code> as the column which will form the basis of the
4732: * join.
4733: * <P>
4734: * The parameter value set by this method is stored internally and
4735: * will be supplied as the appropriate parameter in this rowset's
4736: * command when the method <code>getMatchColumn</code> is called.
4737: *
4738: * @param columnName the name of the column into this rowset
4739: * object's internal representation of parameter values
4740: * @throws SQLException if an error occurs or the
4741: * parameter index is out of bounds
4742: */
4743: public void setMatchColumn(String columnName) throws SQLException {
4744: throw new UnsupportedOperationException();
4745: }
4746:
4747: /**
4748: * Unsets the designated parameter to the given <code>int</code>
4749: * object. This was set using <code>setMatchColumn</code>
4750: * as the column which will form the basis of the join.
4751: * <P>
4752: * The parameter value unset by this method should be same
4753: * as was set.
4754: *
4755: * @param columnIdx the index into this rowset
4756: * object's internal representation of parameter values
4757: * @throws SQLException if an error occurs or the
4758: * parameter index is out of bounds or if the columnIdx is
4759: * not the same as set using <code>setMatchColumn(int)</code>
4760: */
4761: public void unsetMatchColumn(int columnIdx) throws SQLException {
4762: throw new UnsupportedOperationException();
4763: }
4764:
4765: /**
4766: * Unsets the designated parameter to the given <code>String</code>
4767: * object. This was set using <code>setMatchColumn</code>
4768: * as the column which will form the basis of the join.
4769: * <P>
4770: * The parameter value unset by this method should be same
4771: * as was set.
4772: *
4773: * @param columnName the index into this rowset
4774: * object's internal representation of parameter values
4775: * @throws SQLException if an error occurs or the
4776: * parameter index is out of bounds or if the columnName is
4777: * not the same as set using <code>setMatchColumn(String)</code>
4778: */
4779: public void unsetMatchColumn(String columnName) throws SQLException {
4780: throw new UnsupportedOperationException();
4781: }
4782:
4783: /**
4784: * Notifies registered listeners that a RowSet object in the given RowSetEvent
4785: * object has populated a number of additional rows. The <code>numRows</code> parameter
4786: * ensures that this event will only be fired every <code>numRow</code>.
4787: * <p>
4788: * The source of the event can be retrieved with the method event.getSource.
4789: *
4790: * @param event a <code>RowSetEvent</code> object that contains the
4791: * <code>RowSet</code> object that is the source of the events
4792: * @param numRows when populating, the number of rows interval on which the
4793: * <code>CachedRowSet</code> populated should fire; the default value
4794: * is zero; cannot be less than <code>fetchSize</code> or zero
4795: */
4796: public void rowSetPopulated(RowSetEvent event, int numRows)
4797: throws SQLException {
4798: throw new UnsupportedOperationException();
4799: }
4800:
4801: /**
4802: * Populates this <code>CachedRowSet</code> object with data from
4803: * the given <code>ResultSet</code> object. While related to the <code>populate(ResultSet)</code>
4804: * method, an additional parameter is provided to allow starting position within
4805: * the <code>ResultSet</code> from where to populate the CachedRowSet
4806: * instance.
4807: *
4808: * This method is an alternative to the method <code>execute</code>
4809: * for filling the rowset with data. The method <code>populate</code>
4810: * does not require that the properties needed by the method
4811: * <code>execute</code>, such as the <code>command</code> property,
4812: * be set. This is true because the method <code>populate</code>
4813: * is given the <code>ResultSet</code> object from
4814: * which to get data and thus does not need to use the properties
4815: * required for setting up a connection and executing this
4816: * <code>CachedRowSetXImpl</code> object's command.
4817: * <P>
4818: * After populating this rowset with data, the method
4819: * <code>populate</code> sets the rowset's metadata and
4820: * then sends a <code>RowSetChangedEvent</code> object
4821: * to all registered listeners prior to returning.
4822: *
4823: * @param data the <code>ResultSet</code> object containing the data
4824: * to be read into this <code>CachedRowSetXImpl</code> object
4825: * @param start the integer specifing the position in the
4826: * <code>ResultSet</code> object to popultate the
4827: * <code>CachedRowSetXImpl</code> object.
4828: * @throws SQLException if an error occurs; or the max row setting is
4829: * violated while populating the RowSet.Also id the start position
4830: * is negative.
4831: * @see #execute
4832: */
4833: public void populate(ResultSet data, int start) throws SQLException {
4834: throw new UnsupportedOperationException();
4835:
4836: }
4837:
4838: /**
4839: * The nextPage gets the next page, that is a <code>CachedRowSetXImpl</code> object
4840: * containing the number of rows specified by page size.
4841: * @return boolean value true indicating whether there are more pages to come and
4842: * false indicating that this is the last page.
4843: * @throws SQLException if an error occurs or this called before calling populate.
4844: */
4845: public boolean nextPage() throws SQLException {
4846: throw new UnsupportedOperationException();
4847: }
4848:
4849: /**
4850: * This is the setter function for setting the size of the page, which specifies
4851: * how many rows have to be retrived at a time.
4852: *
4853: * @param size which is the page size
4854: * @throws SQLException if size is less than zero or greater than max rows.
4855: */
4856: public void setPageSize(int size) throws SQLException {
4857: throw new UnsupportedOperationException();
4858: }
4859:
4860: /**
4861: * This is the getter function for the size of the page.
4862: *
4863: * @return an integer that is the page size.
4864: */
4865: public int getPageSize() {
4866: throw new UnsupportedOperationException();
4867: }
4868:
4869: /**
4870: * Retrieves the data present in the page prior to the page from where it is
4871: * called.
4872: * @return boolean value true if it retrieves the previous page, flase if it
4873: * is on the first page.
4874: * @throws SQLException if it is called before populate is called or ResultSet
4875: * is of type <code>ResultSet.TYPE_FORWARD_ONLY</code> or if an error
4876: * occurs.
4877: */
4878: public boolean previousPage() throws SQLException {
4879: throw new UnsupportedOperationException();
4880: }
4881:
4882: public Object unwrap(Class arg0) throws SQLException {
4883: return null;
4884: }
4885:
4886: } //end class
|