/* * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */package com.sun.rowset;import java.sql.*;import javax.sql.*;import java.io.*;import java.math.*;import java.util.*;import java.text.*;import java.security.AccessController;import java.security.PrivilegedActionException;import java.security.PrivilegedExceptionAction;import javax.sql.rowset.*;import javax.sql.rowset.spi.*;import javax.sql.rowset.serial.*;import com.sun.rowset.internal.*;import com.sun.rowset.providers.*;import sun.reflect.misc.ReflectUtil;/** * The standard implementation of the <code>CachedRowSet</code> interface. * * See interface definition for full behavior and implementation requirements. * This reference implementation has made provision for a one-to-one write back * facility and it is curremtly be possible to change the peristence provider * during the life-time of any CachedRowSetImpl. * * @author Jonathan Bruce, Amit Handa */public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetInternal, Serializable, Cloneable, CachedRowSet { /** * The <code>SyncProvider</code> used by the CachedRowSet */ private SyncProvider provider; /** * The <code>RowSetReaderImpl</code> object that is the reader * for this rowset. The method <code>execute</code> uses this * reader as part of its implementation. * @serial */ private RowSetReader rowSetReader; /** * The <code>RowSetWriterImpl</code> object that is the writer * for this rowset. The method <code>acceptChanges</code> uses * this writer as part of its implementation. * @serial */ private RowSetWriter rowSetWriter; /** * The <code>Connection</code> object that connects with this * <code>CachedRowSetImpl</code> object's current underlying data source. */ private transient Connection conn; /** * The <code>ResultSetMetaData</code> object that contains information * about the columns in the <code>ResultSet</code> object that is the * current source of data for this <code>CachedRowSetImpl</code> object. */ private transient ResultSetMetaData RSMD; /** * The <code>RowSetMetaData</code> object that contains information about * the columns in this <code>CachedRowSetImpl</code> object. * @serial */ private RowSetMetaDataImpl RowSetMD; // Properties of this RowSet /** * An array containing the columns in this <code>CachedRowSetImpl</code> * object that form a unique identifier for a row. This array * is used by the writer. * @serial */ private int keyCols[]; /** * The name of the table in the underlying database to which updates * should be written. This name is needed because most drivers * do not return this information in a <code>ResultSetMetaData</code> * object. * @serial */ private String tableName; /** * A <code>Vector</code> object containing the <code>Row</code> * objects that comprise this <code>CachedRowSetImpl</code> object. * @serial */ private Vector<Object> rvh; /** * The current position of the cursor in this <code>CachedRowSetImpl</code> * object. * @serial */ private int cursorPos; /** * The current position of the cursor in this <code>CachedRowSetImpl</code> * object not counting rows that have been deleted, if any. * <P> * For example, suppose that the cursor is on the last row of a rowset * that started with five rows and subsequently had the second and third * rows deleted. The <code>absolutePos</code> would be <code>3</code>, * whereas the <code>cursorPos</code> would be <code>5</code>. * @serial */ private int absolutePos; /** * The number of deleted rows currently in this <code>CachedRowSetImpl</code> * object. * @serial */ private int numDeleted; /** * The total number of rows currently in this <code>CachedRowSetImpl</code> * object. * @serial */ private int numRows; /** * A special row used for constructing a new row. A new * row is constructed by using <code>ResultSet.updateXXX</code> * methods to insert column values into the insert row. * @serial */ private InsertRow insertRow; /** * A <code>boolean</code> indicating whether the cursor is * currently on the insert row. * @serial */ private boolean onInsertRow; /** * The field that temporarily holds the last position of the * cursor before it moved to the insert row, thus preserving * the number of the current row to which the cursor may return. * @serial */ private int currentRow; /** * A <code>boolean</code> indicating whether the last value * returned was an SQL <code>NULL</code>. * @serial */ private boolean lastValueNull; /** * A <code>SQLWarning</code> which logs on the warnings */ private SQLWarning sqlwarn; /** * Used to track match column for JoinRowSet consumption */ private String strMatchColumn =""; /** * Used to track match column for JoinRowSet consumption */ private int iMatchColumn = -1; /** * A <code>RowSetWarning</code> which logs on the warnings */ private RowSetWarning rowsetWarning; /** * The default SyncProvider for the RI CachedRowSetImpl */ private String DEFAULT_SYNC_PROVIDER = "com.sun.rowset.providers.RIOptimisticProvider"; /** * The boolean variable indicating locatorsUpdateValue */ private boolean dbmslocatorsUpdateCopy; /** * The <code>ResultSet</code> object that is used to maintain the data when * a ResultSet and start position are passed as parameters to the populate function */ private transient ResultSet resultSet; /** * The integer value indicating the end position in the ResultSetwhere the picking * up of rows for populating a CachedRowSet object was left off. */ private int endPos; /** * The integer value indicating the end position in the ResultSetwhere the picking * up of rows for populating a CachedRowSet object was left off. */ private int prevEndPos; /** * The integer value indicating the position in the ResultSet, to populate the * CachedRowSet object. */ private int startPos; /** * The integer value indicating the position from where the page prior to this * was populated. */ private int startPrev; /** * The integer value indicating size of the page. */ private int pageSize; /** * The integer value indicating number of rows that have been processed so far. * Used for checking whether maxRows has been reached or not. */ private int maxRowsreached; /** * The boolean value when true signifies that pages are still to follow and a * false value indicates that this is the last page. */ private boolean pagenotend = true; /** * The boolean value indicating whether this is the first page or not. */ private boolean onFirstPage; /** * The boolean value indicating whether this is the last page or not. */ private boolean onLastPage; /** * The integer value indicating how many times the populate function has been called. */ private int populatecallcount; /** * The integer value indicating the total number of rows to be processed in the * ResultSet object passed to the populate function. */ private int totalRows; /** * The boolean value indicating how the CahedRowSet object has been populated for * paging purpose. True indicates that connection parameter is passed. */ private boolean callWithCon; /** * CachedRowSet reader object to read the data from the ResultSet when a connection * parameter is passed to populate the CachedRowSet object for paging. */ private CachedRowSetReader crsReader; /** * The Vector holding the Match Columns */ private Vector<Integer> iMatchColumns; /** * The Vector that will hold the Match Column names. */ private Vector<String> strMatchColumns; /** * Trigger that indicates whether the active SyncProvider is exposes the * additional TransactionalWriter method */ private boolean tXWriter = false; /** * The field object for a transactional RowSet writer */ private TransactionalWriter tWriter = null; protected transient JdbcRowSetResourceBundle resBundle; private boolean updateOnInsert; /** * Constructs a new default <code>CachedRowSetImpl</code> object with * the capacity to hold 100 rows. This new object has no metadata * and has the following default values: * <pre> * onInsertRow = false * insertRow = null * cursorPos = 0 * numRows = 0 * showDeleted = false * queryTimeout = 0 * maxRows = 0 * maxFieldSize = 0 * rowSetType = ResultSet.TYPE_SCROLL_INSENSITIVE * concurrency = ResultSet.CONCUR_UPDATABLE * readOnly = false * isolation = Connection.TRANSACTION_READ_COMMITTED * escapeProcessing = true * onInsertRow = false * insertRow = null * cursorPos = 0 * absolutePos = 0 * numRows = 0 * </pre> * A <code>CachedRowSetImpl</code> object is configured to use the default * <code>RIOptimisticProvider</code> implementation to provide connectivity * and synchronization capabilities to the set data source. * <P> * @throws SQLException if an error occurs */ public CachedRowSetImpl() throws SQLException { try { resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle(); } catch(IOException ioe) { throw new RuntimeException(ioe); } // set the Reader, this maybe overridden latter try { provider = AccessController.doPrivileged(new PrivilegedExceptionAction<>() { @Override public SyncProvider run() throws SyncFactoryException { return SyncFactory.getInstance(DEFAULT_SYNC_PROVIDER); } }, null, new RuntimePermission("accessClassInPackage.com.sun.rowset.providers")); } catch (PrivilegedActionException pae) { throw (SyncFactoryException) pae.getException(); } if (!(provider instanceof RIOptimisticProvider)) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidp").toString()); } rowSetReader = (CachedRowSetReader)provider.getRowSetReader(); rowSetWriter = (CachedRowSetWriter)provider.getRowSetWriter(); // allocate the parameters collection initParams(); initContainer(); // set up some default values initProperties(); // insert row setup onInsertRow = false; insertRow = null; // set the warninings sqlwarn = new SQLWarning(); rowsetWarning = new RowSetWarning(); } /** * Provides a <code>CachedRowSetImpl</code> instance with the same default properties as * as the zero parameter constructor. * <pre> * onInsertRow = false * insertRow = null * cursorPos = 0 * numRows = 0 * showDeleted = false * queryTimeout = 0 * maxRows = 0 * maxFieldSize = 0 * rowSetType = ResultSet.TYPE_SCROLL_INSENSITIVE * concurrency = ResultSet.CONCUR_UPDATABLE * readOnly = false * isolation = Connection.TRANSACTION_READ_COMMITTED * escapeProcessing = true * onInsertRow = false * insertRow = null * cursorPos = 0 * absolutePos = 0 * numRows = 0 * </pre> * * However, applications will have the means to specify at runtime the * desired <code>SyncProvider</code> object. * <p> * For example, creating a <code>CachedRowSetImpl</code> object as follows ensures * that a it is established with the <code>com.foo.provider.Impl</code> synchronization * implementation providing the synchronization mechanism for this disconnected * <code>RowSet</code> object. * <pre> * Hashtable env = new Hashtable(); * env.put(javax.sql.rowset.spi.SyncFactory.ROWSET_PROVIDER_NAME, * "com.foo.provider.Impl"); * CachedRowSetImpl crs = new CachedRowSet(env); * </pre> * <p> * Calling this constructor with a <code>null</code> parameter will * cause the <code>SyncFactory</code> to provide the reference * optimistic provider <code>com.sun.rowset.providers.RIOptimisticProvider</code>. * <p> * In addition, the following properties can be associated with the * provider to assist in determining the choice of the synchronizaton * provider such as: * <ul> * <li><code>ROWSET_SYNC_PROVIDER</code> - the property specifying the * <code>SyncProvider</code> class name to be instantiated by the * <code>SyncFacttory</code> * <li><code>ROWSET_SYNC_VENDOR</code> - the property specifying the software * vendor associated with a <code>SyncProvider</code> implementation. * <li><code>ROWSET_SYNC_PROVIDER_VER</code> - the property specifying the * version of the <code>SyncProvider</code> implementation provided by the * software vendor. * </ul> * More specific detailes are available in the <code>SyncFactory</code> * and <code>SyncProvider</code> specificiations later in this document. * <p> * @param env a <code>Hashtable</code> object with a list of desired * synchronization providers * @throws SQLException if the requested provider cannot be found by the * synchronization factory * @see SyncProvider */ public CachedRowSetImpl(@SuppressWarnings("rawtypes") Hashtable env) throws SQLException { try { resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle(); } catch(IOException ioe) { throw new RuntimeException(ioe); } if (env == null) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.nullhash").toString()); } String providerName = (String)env.get( javax.sql.rowset.spi.SyncFactory.ROWSET_SYNC_PROVIDER); // set the Reader, this maybe overridden latter provider = SyncFactory.getInstance(providerName); rowSetReader = provider.getRowSetReader(); rowSetWriter = provider.getRowSetWriter(); initParams(); // allocate the parameters collection initContainer(); initProperties(); // set up some default values } /** * Sets the <code>rvh</code> field to a new <code>Vector</code> * object with a capacity of 100 and sets the * <code>cursorPos</code> and <code>numRows</code> fields to zero. */ private void initContainer() { rvh = new Vector<Object>(100); cursorPos = 0; absolutePos = 0; numRows = 0; numDeleted = 0; } /** * Sets the properties for this <code>CachedRowSetImpl</code> object to * their default values. This method is called internally by the * default constructor. */ private void initProperties() throws SQLException { if(resBundle == null) { try { resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle(); } catch(IOException ioe) { throw new RuntimeException(ioe); } } setShowDeleted(false); setQueryTimeout(0); setMaxRows(0); setMaxFieldSize(0); setType(ResultSet.TYPE_SCROLL_INSENSITIVE); setConcurrency(ResultSet.CONCUR_UPDATABLE); if((rvh.size() > 0) && (isReadOnly() == false)) setReadOnly(false); else setReadOnly(true); setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED); setEscapeProcessing(true); //setTypeMap(null); checkTransactionalWriter(); //Instantiating the vector for MatchColumns iMatchColumns = new Vector<Integer>(10); for(int i = 0; i < 10 ; i++) { iMatchColumns.add(i, -1); } strMatchColumns = new Vector<String>(10); for(int j = 0; j < 10; j++) { strMatchColumns.add(j,null); } } /** * Determine whether the SyncProvider's writer implements the * <code>TransactionalWriter<code> interface */ private void checkTransactionalWriter() { if (rowSetWriter != null) { Class<?> c = rowSetWriter.getClass(); if (c != null) { Class<?>[] theInterfaces = c.getInterfaces(); for (int i = 0; i < theInterfaces.length; i++) { if ((theInterfaces[i].getName()).indexOf("TransactionalWriter") > 0) { tXWriter = true; establishTransactionalWriter(); } } } } } /** * Sets an private field to all transaction bounddaries to be set */ private void establishTransactionalWriter() { tWriter = (TransactionalWriter)provider.getRowSetWriter(); } //----------------------------------------------------------------------- // Properties //----------------------------------------------------------------------- /** * Sets this <code>CachedRowSetImpl</code> object's command property * to the given <code>String</code> object and clears the parameters, * if any, that were set for the previous command. * <P> * The command property may not be needed * if the rowset is produced by a data source, such as a spreadsheet, * that does not support commands. Thus, this property is optional * and may be <code>null</code>. * * @param cmd a <code>String</code> object containing an SQL query * that will be set as the command; may be <code>null</code> * @throws SQLException if an error occurs */ public void setCommand(String cmd) throws SQLException { super.setCommand(cmd); if(!buildTableName(cmd).equals("")) { this.setTableName(buildTableName(cmd)); } } //--------------------------------------------------------------------- // Reading and writing data //--------------------------------------------------------------------- /** * Populates this <code>CachedRowSetImpl</code> object with data from * the given <code>ResultSet</code> object. This * method is an alternative to the method <code>execute</code> * for filling the rowset with data. The method <code>populate</code> * does not require that the properties needed by the method * <code>execute</code>, such as the <code>command</code> property, * be set. This is true because the method <code>populate</code> * is given the <code>ResultSet</code> object from * which to get data and thus does not need to use the properties * required for setting up a connection and executing this * <code>CachedRowSetImpl</code> object's command. * <P> * After populating this rowset with data, the method * <code>populate</code> sets the rowset's metadata and * then sends a <code>RowSetChangedEvent</code> object * to all registered listeners prior to returning. * * @param data the <code>ResultSet</code> object containing the data * to be read into this <code>CachedRowSetImpl</code> object * @throws SQLException if an error occurs; or the max row setting is * violated while populating the RowSet * @see #execute */ public void populate(ResultSet data) throws SQLException { int rowsFetched; Row currentRow; int numCols; int i; Map<String, Class<?>> map = getTypeMap(); Object obj; int mRows; if (data == null) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.populate").toString()); } this.resultSet = data; // get the meta data for this ResultSet RSMD = data.getMetaData(); // set up the metadata RowSetMD = new RowSetMetaDataImpl(); initMetaData(RowSetMD, RSMD); // release the meta-data so that aren't tempted to use it. RSMD = null; numCols = RowSetMD.getColumnCount(); mRows = this.getMaxRows(); rowsFetched = 0; currentRow = null; while ( data.next()) { currentRow = new Row(numCols); if ( rowsFetched > mRows && mRows > 0) { rowsetWarning.setNextWarning(new RowSetWarning("Populating rows " + "setting has exceeded max row setting")); } for ( i = 1; i <= numCols; i++) { /* * check if the user has set a map. If no map * is set then use plain getObject. This lets * us work with drivers that do not support * getObject with a map in fairly sensible way */ if (map == null || map.isEmpty()) { obj = data.getObject(i); } else { obj = data.getObject(i, map); } /* * the following block checks for the various * types that we have to serialize in order to * store - right now only structs have been tested */ if (obj instanceof Struct) { obj = new SerialStruct((Struct)obj, map); } else if (obj instanceof SQLData) { obj = new SerialStruct((SQLData)obj, map); } else if (obj instanceof Blob) { obj = new SerialBlob((Blob)obj); } else if (obj instanceof Clob) { obj = new SerialClob((Clob)obj); } else if (obj instanceof java.sql.Array) { if(map != null) obj = new SerialArray((java.sql.Array)obj, map); else obj = new SerialArray((java.sql.Array)obj); } currentRow.initColumnObject(i, obj); } rowsFetched++; rvh.add(currentRow); } numRows = rowsFetched ; // Also rowsFetched should be equal to rvh.size() // notify any listeners that the rowset has changed notifyRowSetChanged(); } /** * Initializes the given <code>RowSetMetaData</code> object with the values * in the given <code>ResultSetMetaData</code> object. * * @param md the <code>RowSetMetaData</code> object for this * <code>CachedRowSetImpl</code> object, which will be set with * values from rsmd * @param rsmd the <code>ResultSetMetaData</code> object from which new * values for md will be read * @throws SQLException if an error occurs */ private void initMetaData(RowSetMetaDataImpl md, ResultSetMetaData rsmd) throws SQLException { int numCols = rsmd.getColumnCount(); md.setColumnCount(numCols); for (int col=1; col <= numCols; col++) { md.setAutoIncrement(col, rsmd.isAutoIncrement(col)); if(rsmd.isAutoIncrement(col)) updateOnInsert = true; md.setCaseSensitive(col, rsmd.isCaseSensitive(col)); md.setCurrency(col, rsmd.isCurrency(col)); md.setNullable(col, rsmd.isNullable(col)); md.setSigned(col, rsmd.isSigned(col)); md.setSearchable(col, rsmd.isSearchable(col)); /* * The PostgreSQL drivers sometimes return negative columnDisplaySize, * which causes an exception to be thrown. Check for it. */ int size = rsmd.getColumnDisplaySize(col); if (size < 0) { size = 0; } md.setColumnDisplaySize(col, size); md.setColumnLabel(col, rsmd.getColumnLabel(col)); md.setColumnName(col, rsmd.getColumnName(col)); md.setSchemaName(col, rsmd.getSchemaName(col)); /* * Drivers return some strange values for precision, for non-numeric data, including reports of * non-integer values; maybe we should check type, & set to 0 for non-numeric types. */ int precision = rsmd.getPrecision(col); if (precision < 0) { precision = 0; } md.setPrecision(col, precision); /* * It seems, from a bug report, that a driver can sometimes return a negative * value for scale. javax.sql.rowset.RowSetMetaDataImpl will throw an exception * if we attempt to set a negative value. As such, we'll check for this case. */ int scale = rsmd.getScale(col); if (scale < 0) { scale = 0; } md.setScale(col, scale); md.setTableName(col, rsmd.getTableName(col)); md.setCatalogName(col, rsmd.getCatalogName(col)); md.setColumnType(col, rsmd.getColumnType(col)); md.setColumnTypeName(col, rsmd.getColumnTypeName(col)); } if( conn != null){ // JDBC 4.0 mandates as does the Java EE spec that all DataBaseMetaData methods // must be implemented, therefore, the previous fix for 5055528 is being backed out dbmslocatorsUpdateCopy = conn.getMetaData().locatorsUpdateCopy(); } } /** * Populates this <code>CachedRowSetImpl</code> object with data, * using the given connection to produce the result set from * which data will be read. A second form of this method, * which takes no arguments, uses the values from this rowset's * user, password, and either url or data source properties to * create a new database connection. The form of <code>execute</code> * that is given a connection ignores these properties. * * @param conn A standard JDBC <code>Connection</code> object that this * <code>CachedRowSet</code> object can pass to a synchronization provider * to establish a connection to the data source * @throws SQLException if an invalid <code>Connection</code> is supplied * or an error occurs in establishing the connection to the * data source * @see #populate * @see java.sql.Connection */ public void execute(Connection conn) throws SQLException { // store the connection so the reader can find it. setConnection(conn); if(getPageSize() != 0){ crsReader = (CachedRowSetReader)provider.getRowSetReader(); crsReader.setStartPosition(1); callWithCon = true; crsReader.readData((RowSetInternal)this); } // Now call the current reader's readData method else { rowSetReader.readData((RowSetInternal)this); } RowSetMD = (RowSetMetaDataImpl)this.getMetaData(); if(conn != null){ // JDBC 4.0 mandates as does the Java EE spec that all DataBaseMetaData methods // must be implemented, therefore, the previous fix for 5055528 is being backed out dbmslocatorsUpdateCopy = conn.getMetaData().locatorsUpdateCopy(); } } /** * Sets this <code>CachedRowSetImpl</code> object's connection property * to the given <code>Connection</code> object. This method is called * internally by the version of the method <code>execute</code> that takes a * <code>Connection</code> object as an argument. The reader for this * <code>CachedRowSetImpl</code> object can retrieve the connection stored * in the rowset's connection property by calling its * <code>getConnection</code> method. * * @param connection the <code>Connection</code> object that was passed in * to the method <code>execute</code> and is to be stored * in this <code>CachedRowSetImpl</code> object's connection * property */ private void setConnection (Connection connection) { conn = connection; } /** * Propagates all row update, insert, and delete changes to the * underlying data source backing this <code>CachedRowSetImpl</code> * object. * <P> * <b>Note</b>In the reference implementation an optimistic concurrency implementation * is provided as a sample implementation of a the <code>SyncProvider</code> * abstract class. * <P> * This method fails if any of the updates cannot be propagated back * to the data source. When it fails, the caller can assume that * none of the updates are reflected in the data source. * When an exception is thrown, the current row * is set to the first "updated" row that resulted in an exception * unless the row that caused the exception is a "deleted" row. * In that case, when deleted rows are not shown, which is usually true, * the current row is not affected. * <P> * If no <code>SyncProvider</code> is configured, the reference implementation * leverages the <code>RIOptimisticProvider</code> available which provides the * default and reference synchronization capabilities for disconnected * <code>RowSets</code>. * * @throws SQLException if the cursor is on the insert row or the underlying * reference synchronization provider fails to commit the updates * to the datasource * @throws SyncProviderException if an internal error occurs within the * <code>SyncProvider</code> instance during either during the * process or at any time when the <code>SyncProvider</code> * instance touches the data source. * @see #acceptChanges(java.sql.Connection) * @see javax.sql.RowSetWriter * @see javax.sql.rowset.spi.SyncProvider */ public void acceptChanges() throws SyncProviderException { if (onInsertRow == true) { throw new SyncProviderException(resBundle.handleGetObject("cachedrowsetimpl.invalidop").toString()); } int saveCursorPos = cursorPos; boolean success = false; boolean conflict = false; try { if (rowSetWriter != null) { saveCursorPos = cursorPos; conflict = rowSetWriter.writeData((RowSetInternal)this); cursorPos = saveCursorPos; } if (tXWriter) { // do commit/rollback's here if (!conflict) { tWriter = (TransactionalWriter)rowSetWriter; tWriter.rollback(); success = false; } else { tWriter = (TransactionalWriter)rowSetWriter; if (tWriter instanceof CachedRowSetWriter) { ((CachedRowSetWriter)tWriter).commit(this, updateOnInsert); } else { tWriter.commit(); } success = true; } } if (success == true) { setOriginal(); } else if (!(success) ) { throw new SyncProviderException(resBundle.handleGetObject("cachedrowsetimpl.accfailed").toString()); } } catch (SyncProviderException spe) { throw spe; } catch (SQLException e) { e.printStackTrace(); throw new SyncProviderException(e.getMessage()); } catch (SecurityException e) { throw new SyncProviderException(e.getMessage()); } } /** * Propagates all row update, insert, and delete changes to the * data source backing this <code>CachedRowSetImpl</code> object * using the given <code>Connection</code> object. * <P> * The reference implementation <code>RIOptimisticProvider</code> * modifies its synchronization to a write back function given * the updated connection * The reference implementation modifies its synchronization behaviour * via the <code>SyncProvider</code> to ensure the synchronization * occurs according to the updated JDBC <code>Connection</code> * properties. * * @param con a standard JDBC <code>Connection</code> object * @throws SQLException if the cursor is on the insert row or the underlying * synchronization provider fails to commit the updates * back to the data source * @see #acceptChanges * @see javax.sql.RowSetWriter * @see javax.sql.rowset.spi.SyncFactory * @see javax.sql.rowset.spi.SyncProvider */ public void acceptChanges(Connection con) throws SyncProviderException{ setConnection(con); acceptChanges(); } /** * Restores this <code>CachedRowSetImpl</code> object to its original state, * that is, its state before the last set of changes. * <P> * Before returning, this method moves the cursor before the first row * and sends a <code>rowSetChanged</code> event to all registered * listeners. * @throws SQLException if an error is occurs rolling back the RowSet * state to the definied original value. * @see javax.sql.RowSetListener#rowSetChanged */ public void restoreOriginal() throws SQLException { Row currentRow; for (Iterator<?> i = rvh.iterator(); i.hasNext();) { currentRow = (Row)i.next(); if (currentRow.getInserted() == true) { i.remove(); --numRows; } else { if (currentRow.getDeleted() == true) { currentRow.clearDeleted(); } if (currentRow.getUpdated() == true) { currentRow.clearUpdated(); } } } // move to before the first cursorPos = 0; // notify any listeners notifyRowSetChanged(); } /** * Releases the current contents of this <code>CachedRowSetImpl</code> * object and sends a <code>rowSetChanged</code> event object to all * registered listeners. * * @throws SQLException if an error occurs flushing the contents of * RowSet. * @see javax.sql.RowSetListener#rowSetChanged */ public void release() throws SQLException { initContainer(); notifyRowSetChanged(); } /** * Cancels deletion of the current row and notifies listeners that * a row has changed. * <P> * Note: This method can be ignored if deleted rows are not being shown, * which is the normal case. * * @throws SQLException if the cursor is not on a valid row */ public void undoDelete() throws SQLException { if (getShowDeleted() == false) { return; } // make sure we are on a row checkCursor(); // don't want this to happen... if (onInsertRow == true) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcp").toString()); } Row currentRow = (Row)getCurrentRow(); if (currentRow.getDeleted() == true) { currentRow.clearDeleted(); --numDeleted; notifyRowChanged(); } } /** * Immediately removes the current row from this * <code>CachedRowSetImpl</code> object if the row has been inserted, and * also notifies listeners the a row has changed. An exception is thrown * if the row is not a row that has been inserted or the cursor is before * the first row, after the last row, or on the insert row. * <P> * This operation cannot be undone. * * @throws SQLException if an error occurs, * the cursor is not on a valid row, * or the row has not been inserted */ public void undoInsert() throws SQLException { // make sure we are on a row checkCursor(); // don't want this to happen... if (onInsertRow == true) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcp").toString()); } Row currentRow = (Row)getCurrentRow(); if (currentRow.getInserted() == true) { rvh.remove(cursorPos-1); --numRows; notifyRowChanged(); } else { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.illegalop").toString()); } } /** * Immediately reverses the last update operation if the * row has been modified. This method can be * called to reverse updates on a all columns until all updates in a row have * been rolled back to their originating state since the last synchronization * (<code>acceptChanges</code>) or population. This method may also be called * while performing updates to the insert row. * <P> * {@code undoUpdate} may be called at any time during the life-time of a * rowset, however after a synchronization has occurs this method has no * affect until further modification to the RowSet data occurs. * * @throws SQLException if cursor is before the first row, after the last * row in rowset. * @see #undoDelete * @see #undoInsert * @see java.sql.ResultSet#cancelRowUpdates */ public void undoUpdate() throws SQLException { // if on insert row, cancel the insert row // make the insert row flag, // cursorPos back to the current row moveToCurrentRow(); // else if not on insert row // call undoUpdate or undoInsert undoDelete(); undoInsert(); } //-------------------------------------------------------------------- // Views //-------------------------------------------------------------------- /** * Returns a new <code>RowSet</code> object backed by the same data as * that of this <code>CachedRowSetImpl</code> object and sharing a set of cursors * with it. This allows cursors to interate over a shared set of rows, providing * multiple views of the underlying data. * * @return a <code>RowSet</code> object that is a copy of this <code>CachedRowSetImpl</code> * object and shares a set of cursors with it * @throws SQLException if an error occurs or cloning is * not supported * @see javax.sql.RowSetEvent * @see javax.sql.RowSetListener */ public RowSet createShared() throws SQLException { RowSet clone; try { clone = (RowSet)clone(); } catch (CloneNotSupportedException ex) { throw new SQLException(ex.getMessage()); } return clone; } /** * Returns a new <code>RowSet</code> object containing by the same data * as this <code>CachedRowSetImpl</code> object. This method * differs from the method <code>createCopy</code> in that it throws a * <code>CloneNotSupportedException</code> object instead of an * <code>SQLException</code> object, as the method <code>createShared</code> * does. This <code>clone</code> * method is called internally by the method <code>createShared</code>, * which catches the <code>CloneNotSupportedException</code> object * and in turn throws a new <code>SQLException</code> object. * * @return a copy of this <code>CachedRowSetImpl</code> object * @throws CloneNotSupportedException if an error occurs when * attempting to clone this <code>CachedRowSetImpl</code> object * @see #createShared */ protected Object clone() throws CloneNotSupportedException { return (super.clone()); } /** * Creates a <code>RowSet</code> object that is a deep copy of * this <code>CachedRowSetImpl</code> object's data, including * constraints. Updates made * on a copy are not visible to the original rowset; * a copy of a rowset is completely independent from the original. * <P> * Making a copy saves the cost of creating an identical rowset * from first principles, which can be quite expensive. * For example, it can eliminate the need to query a * remote database server. * @return a new <code>CachedRowSet</code> object that is a deep copy * of this <code>CachedRowSet</code> object and is * completely independent from this <code>CachedRowSetImpl</code> * object. * @throws SQLException if an error occurs in generating the copy of this * of the <code>CachedRowSetImpl</code> * @see #createShared * @see javax.sql.RowSetEvent * @see javax.sql.RowSetListener */ public CachedRowSet createCopy() throws SQLException { ObjectOutputStream out; ByteArrayOutputStream bOut = new ByteArrayOutputStream(); try { out = new ObjectOutputStream(bOut); out.writeObject(this); } catch (IOException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.clonefail").toString() , ex.getMessage())); } ObjectInputStream in; try { ByteArrayInputStream bIn = new ByteArrayInputStream(bOut.toByteArray()); in = new ObjectInputStream(bIn); } catch (StreamCorruptedException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.clonefail").toString() , ex.getMessage())); } catch (IOException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.clonefail").toString() , ex.getMessage())); } try { //return ((CachedRowSet)(in.readObject())); CachedRowSetImpl crsTemp = (CachedRowSetImpl)in.readObject(); crsTemp.resBundle = this.resBundle; return ((CachedRowSet)crsTemp); } catch (ClassNotFoundException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.clonefail").toString() , ex.getMessage())); } catch (OptionalDataException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.clonefail").toString() , ex.getMessage())); } catch (IOException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.clonefail").toString() , ex.getMessage())); } } /** * Creates a <code>RowSet</code> object that is a copy of * this <code>CachedRowSetImpl</code> object's table structure * and the constraints only. * There will be no data in the object being returned. * Updates made on a copy are not visible to the original rowset. * <P> * This helps in getting the underlying XML schema which can * be used as the basis for populating a <code>WebRowSet</code>. * * @return a new <code>CachedRowSet</code> object that is a copy * of this <code>CachedRowSetImpl</code> object's schema and * retains all the constraints on the original rowset but contains * no data * @throws SQLException if an error occurs in generating the copy * of the <code>CachedRowSet</code> object * @see #createShared * @see #createCopy * @see #createCopyNoConstraints * @see javax.sql.RowSetEvent * @see javax.sql.RowSetListener */ public CachedRowSet createCopySchema() throws SQLException { // Copy everything except data i.e all constraints // Store the number of rows of "this" // and make numRows equals zero. // and make data also zero. int nRows = numRows; numRows = 0; CachedRowSet crs = this.createCopy(); // reset this object back to number of rows. numRows = nRows; return crs; } /** * Creates a <code>CachedRowSet</code> object that is a copy of * this <code>CachedRowSetImpl</code> object's data only. * All constraints set in this object will not be there * in the returning object. Updates made * on a copy are not visible to the original rowset. * * @return a new <code>CachedRowSet</code> object that is a deep copy * of this <code>CachedRowSetImpl</code> object and is * completely independent from this <code>CachedRowSetImpl</code> object * @throws SQLException if an error occurs in generating the copy of the * of the <code>CachedRowSet</code> * @see #createShared * @see #createCopy * @see #createCopySchema * @see javax.sql.RowSetEvent * @see javax.sql.RowSetListener */ public CachedRowSet createCopyNoConstraints() throws SQLException { // Copy the whole data ONLY without any constraints. CachedRowSetImpl crs; crs = (CachedRowSetImpl)this.createCopy(); crs.initProperties(); try { crs.unsetMatchColumn(crs.getMatchColumnIndexes()); } catch(SQLException sqle) { //do nothing, if the setMatchColumn is not set. } try { crs.unsetMatchColumn(crs.getMatchColumnNames()); } catch(SQLException sqle) { //do nothing, if the setMatchColumn is not set. } return crs; } /** * Converts this <code>CachedRowSetImpl</code> object to a collection * of tables. The sample implementation utilitizes the <code>TreeMap</code> * collection type. * This class guarantees that the map will be in ascending key order, * sorted according to the natural order for the key's class. * * @return a <code>Collection</code> object consisting of tables, * each of which is a copy of a row in this * <code>CachedRowSetImpl</code> object * @throws SQLException if an error occurs in generating the collection * @see #toCollection(int) * @see #toCollection(String) * @see java.util.TreeMap */ public Collection<?> toCollection() throws SQLException { TreeMap<Integer, Object> tMap = new TreeMap<>(); for (int i = 0; i<numRows; i++) { tMap.put(i, rvh.get(i)); } return (tMap.values()); } /** * Returns the specified column of this <code>CachedRowSetImpl</code> object * as a <code>Collection</code> object. This method makes a copy of the * column's data and utilitizes the <code>Vector</code> to establish the * collection. The <code>Vector</code> class implements a growable array * objects allowing the individual components to be accessed using an * an integer index similar to that of an array. * * @return a <code>Collection</code> object that contains the value(s) * stored in the specified column of this * <code>CachedRowSetImpl</code> * object * @throws SQLException if an error occurs generated the collection; or * an invalid column is provided. * @see #toCollection() * @see #toCollection(String) * @see java.util.Vector */ public Collection<?> toCollection(int column) throws SQLException { int nRows = numRows; Vector<Object> vec = new Vector<>(nRows); // create a copy CachedRowSetImpl crsTemp; crsTemp = (CachedRowSetImpl) this.createCopy(); while(nRows!=0) { crsTemp.next(); vec.add(crsTemp.getObject(column)); nRows--; } return (Collection)vec; } /** * Returns the specified column of this <code>CachedRowSetImpl</code> object * as a <code>Collection</code> object. This method makes a copy of the * column's data and utilitizes the <code>Vector</code> to establish the * collection. The <code>Vector</code> class implements a growable array * objects allowing the individual components to be accessed using an * an integer index similar to that of an array. * * @return a <code>Collection</code> object that contains the value(s) * stored in the specified column of this * <code>CachedRowSetImpl</code> * object * @throws SQLException if an error occurs generated the collection; or * an invalid column is provided. * @see #toCollection() * @see #toCollection(int) * @see java.util.Vector */ public Collection<?> toCollection(String column) throws SQLException { return toCollection(getColIdxByName(column)); } //-------------------------------------------------------------------- // Advanced features //-------------------------------------------------------------------- /** * Returns the <code>SyncProvider</code> implementation being used * with this <code>CachedRowSetImpl</code> implementation rowset. * * @return the SyncProvider used by the rowset. If not provider was * set when the rowset was instantiated, the reference * implementation (default) provider is returned. * @throws SQLException if error occurs while return the * <code>SyncProvider</code> instance. */ public SyncProvider getSyncProvider() throws SQLException { return provider; } /** * Sets the active <code>SyncProvider</code> and attempts to load * load the new provider using the <code>SyncFactory</code> SPI. * * @throws SQLException if an error occurs while resetting the * <code>SyncProvider</code>. */ public void setSyncProvider(String providerStr) throws SQLException { provider = SyncFactory.getInstance(providerStr); rowSetReader = provider.getRowSetReader(); rowSetWriter = provider.getRowSetWriter(); } //----------------- // methods inherited from RowSet //----------------- //--------------------------------------------------------------------- // Reading and writing data //--------------------------------------------------------------------- /** * Populates this <code>CachedRowSetImpl</code> object with data. * This form of the method uses the rowset's user, password, and url or * data source name properties to create a database * connection. If properties that are needed * have not been set, this method will throw an exception. * <P> * Another form of this method uses an existing JDBC <code>Connection</code> * object instead of creating a new one; therefore, it ignores the * properties used for establishing a new connection. * <P> * The query specified by the command property is executed to create a * <code>ResultSet</code> object from which to retrieve data. * The current contents of the rowset are discarded, and the * rowset's metadata is also (re)set. If there are outstanding updates, * they are also ignored. * <P> * The method <code>execute</code> closes any database connections that it * creates. * * @throws SQLException if an error occurs or the * necessary properties have not been set */ public void execute() throws SQLException { execute(null); } //----------------------------------- // Methods inherited from ResultSet //----------------------------------- /** * Moves the cursor down one row from its current position and * returns <code>true</code> if the new cursor position is a * valid row. * The cursor for a new <code>ResultSet</code> object is initially * positioned before the first row. The first call to the method * <code>next</code> moves the cursor to the first row, making it * the current row; the second call makes the second row the * current row, and so on. * * <P>If an input stream from the previous row is open, it is * implicitly closed. The <code>ResultSet</code> object's warning * chain is cleared when a new row is read. * * @return <code>true</code> if the new current row is valid; * <code>false</code> if there are no more rows * @throws SQLException if an error occurs or * the cursor is not positioned in the rowset, before * the first row, or after the last row */ public boolean next() throws SQLException { /* * make sure things look sane. The cursor must be * positioned in the rowset or before first (0) or * after last (numRows + 1) */ if (cursorPos < 0 || cursorPos >= numRows + 1) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcp").toString()); } // now move and notify boolean ret = this.internalNext(); notifyCursorMoved(); return ret; } /** * Moves this <code>CachedRowSetImpl</code> object's cursor to the next * row and returns <code>true</code> if the cursor is still in the rowset; * returns <code>false</code> if the cursor has moved to the position after * the last row. * <P> * This method handles the cases where the cursor moves to a row that * has been deleted. * If this rowset shows deleted rows and the cursor moves to a row * that has been deleted, this method moves the cursor to the next * row until the cursor is on a row that has not been deleted. * <P> * The method <code>internalNext</code> is called by methods such as * <code>next</code>, <code>absolute</code>, and <code>relative</code>, * and, as its name implies, is only called internally. * <p> * This is a implementation only method and is not required as a standard * implementation of the <code>CachedRowSet</code> interface. * * @return <code>true</code> if the cursor is on a valid row in this * rowset; <code>false</code> if it is after the last row * @throws SQLException if an error occurs */ protected boolean internalNext() throws SQLException { boolean ret = false; do { if (cursorPos < numRows) { ++cursorPos; ret = true; } else if (cursorPos == numRows) { // increment to after last ++cursorPos; ret = false; break; } } while ((getShowDeleted() == false) && (rowDeleted() == true)); /* each call to internalNext may increment cursorPos multiple * times however, the absolutePos only increments once per call. */ if (ret == true) absolutePos++; else absolutePos = 0; return ret; } /** * Closes this <code>CachedRowSetImpl</code> objecy and releases any resources * it was using. * * @throws SQLException if an error occurs when releasing any resources in use * by this <code>CachedRowSetImpl</code> object */ public void close() throws SQLException { // close all data structures holding // the disconnected rowset cursorPos = 0; absolutePos = 0; numRows = 0; numDeleted = 0; // set all insert(s), update(s) & delete(s), // if at all, to their initial values. initProperties(); // clear the vector of it's present contents rvh.clear(); // this will make it eligible for gc // rvh = null; } /** * Reports whether the last column read was SQL <code>NULL</code>. * Note that you must first call the method <code>getXXX</code> * on a column to try to read its value and then call the method * <code>wasNull</code> to determine whether the value was * SQL <code>NULL</code>. * * @return <code>true</code> if the value in the last column read * was SQL <code>NULL</code>; <code>false</code> otherwise * @throws SQLException if an error occurs */ public boolean wasNull() throws SQLException { return lastValueNull; } /** * Sets the field <code>lastValueNull</code> to the given * <code>boolean</code> value. * * @param value <code>true</code> to indicate that the value of * the last column read was SQL <code>NULL</code>; * <code>false</code> to indicate that it was not */ private void setLastValueNull(boolean value) { lastValueNull = value; } // Methods for accessing results by column index /** * Checks to see whether the given index is a valid column number * in this <code>CachedRowSetImpl</code> object and throws * an <code>SQLException</code> if it is not. The index is out of bounds * if it is less than <code>1</code> or greater than the number of * columns in this rowset. * <P> * This method is called internally by the <code>getXXX</code> and * <code>updateXXX</code> methods. * * @param idx the number of a column in this <code>CachedRowSetImpl</code> * object; must be between <code>1</code> and the number of * rows in this rowset * @throws SQLException if the given index is out of bounds */ private void checkIndex(int idx) throws SQLException { if (idx < 1 || idx > RowSetMD.getColumnCount()) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcol").toString()); } } /** * Checks to see whether the cursor for this <code>CachedRowSetImpl</code> * object is on a row in the rowset and throws an * <code>SQLException</code> if it is not. * <P> * This method is called internally by <code>getXXX</code> methods, by * <code>updateXXX</code> methods, and by methods that update, insert, * or delete a row or that cancel a row update, insert, or delete. * * @throws SQLException if the cursor for this <code>CachedRowSetImpl</code> * object is not on a valid row */ private void checkCursor() throws SQLException { if (isAfterLast() == true || isBeforeFirst() == true) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcp").toString()); } } /** * Returns the column number of the column with the given name in this * <code>CachedRowSetImpl</code> object. This method throws an * <code>SQLException</code> if the given name is not the name of * one of the columns in this rowset. * * @param name a <code>String</code> object that is the name of a column in * this <code>CachedRowSetImpl</code> object * @throws SQLException if the given name does not match the name of one of * the columns in this rowset */ private int getColIdxByName(String name) throws SQLException { RowSetMD = (RowSetMetaDataImpl)this.getMetaData(); int cols = RowSetMD.getColumnCount(); for (int i=1; i <= cols; ++i) { String colName = RowSetMD.getColumnName(i); if (colName != null) if (name.equalsIgnoreCase(colName)) return (i); else continue; } throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalcolnm").toString()); } /** * Returns the insert row or the current row of this * <code>CachedRowSetImpl</code>object. * * @return the <code>Row</code> object on which this <code>CachedRowSetImpl</code> * objects's cursor is positioned */ protected BaseRow getCurrentRow() { if (onInsertRow == true) { return (BaseRow)insertRow; } else { return (BaseRow)(rvh.get(cursorPos - 1)); } } /** * Removes the row on which the cursor is positioned. * <p> * This is a implementation only method and is not required as a standard * implementation of the <code>CachedRowSet</code> interface. * * @throws SQLException if the cursor is positioned on the insert * row */ protected void removeCurrentRow() { ((Row)getCurrentRow()).setDeleted(); rvh.remove(cursorPos - 1); --numRows; } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a * <code>String</code> object. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @return the column value; if the value is SQL <code>NULL</code>, the * result is <code>null</code> * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, REAL, * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, <b>CHAR</b>, <b>VARCHAR</b></code> * or <code>LONGVARCHAR</code> value. The bold SQL type designates the * recommended return type. */ public String getString(int columnIndex) throws SQLException { Object value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return null; } return value.toString(); } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a * <code>boolean</code> value. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @return the column value as a <code>boolean</code> in the Java progamming language; * if the value is SQL <code>NULL</code>, the result is <code>false</code> * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>BOOLEAN</code> value * @see #getBoolean(String) */ public boolean getBoolean(int columnIndex) throws SQLException { Object value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return false; } // check for Boolean... if (value instanceof Boolean) { return ((Boolean)value).booleanValue(); } // convert to a Double and compare to zero try { return Double.compare(Double.parseDouble(value.toString()), 0) != 0; } catch (NumberFormatException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.boolfail").toString(), new Object[] {value.toString().trim(), columnIndex})); } } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a * <code>byte</code> value. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @return the column value as a <code>byte</code> in the Java programming * language; if the value is SQL <code>NULL</code>, the result is <code>0</code> * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code><b>TINYINT</b>, SMALLINT, INTEGER, BIGINT, REAL, * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code> * or <code>LONGVARCHAR</code> value. The bold SQL type * designates the recommended return type. * @see #getByte(String) */ public byte getByte(int columnIndex) throws SQLException { Object value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return (byte)0; } try { return ((Byte.valueOf(value.toString())).byteValue()); } catch (NumberFormatException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.bytefail").toString(), new Object[] {value.toString().trim(), columnIndex})); } } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a * <code>short</code> value. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @return the column value; if the value is SQL <code>NULL</code>, the * result is <code>0</code> * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>TINYINT, <b>SMALLINT</b>, INTEGER, BIGINT, REAL * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code> * or <code>LONGVARCHAR</code> value. The bold SQL type designates the * recommended return type. * @see #getShort(String) */ public short getShort(int columnIndex) throws SQLException { Object value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return (short)0; } try { return ((Short.valueOf(value.toString().trim())).shortValue()); } catch (NumberFormatException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.shortfail").toString(), new Object[] {value.toString().trim(), columnIndex})); } } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as an * <code>int</code> value. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @return the column value; if the value is SQL <code>NULL</code>, the * result is <code>0</code> * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>TINYINT, SMALLINT, <b>INTEGER</b>, BIGINT, REAL * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code> * or <code>LONGVARCHAR</code> value. The bold SQL type designates the * recommended return type. */ public int getInt(int columnIndex) throws SQLException { Object value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return 0; } try { return ((Integer.valueOf(value.toString().trim())).intValue()); } catch (NumberFormatException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.intfail").toString(), new Object[] {value.toString().trim(), columnIndex})); } } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a * <code>long</code> value. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @return the column value; if the value is SQL <code>NULL</code>, the * result is <code>0</code> * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>TINYINT, SMALLINT, INTEGER, <b>BIGINT</b>, REAL * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code> * or <code>LONGVARCHAR</code> value. The bold SQL type designates the * recommended return type. * @see #getLong(String) */ public long getLong(int columnIndex) throws SQLException { Object value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return (long)0; } try { return ((Long.valueOf(value.toString().trim())).longValue()); } catch (NumberFormatException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.longfail").toString(), new Object[] {value.toString().trim(), columnIndex})); } } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a * <code>float</code> value. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @return the column value; if the value is SQL <code>NULL</code>, the * result is <code>0</code> * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, <b>REAL</b>, * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code> * or <code>LONGVARCHAR</code> value. The bold SQL type designates the * recommended return type. * @see #getFloat(String) */ public float getFloat(int columnIndex) throws SQLException { Object value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return (float)0; } try { return Float.parseFloat(value.toString()); } catch (NumberFormatException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.floatfail").toString(), new Object[] {value.toString().trim(), columnIndex})); } } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a * <code>double</code> value. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @return the column value; if the value is SQL <code>NULL</code>, the * result is <code>0</code> * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, REAL, * <b>FLOAT</b>, <b>DOUBLE</b>, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code> * or <code>LONGVARCHAR</code> value. The bold SQL type designates the * recommended return type. * @see #getDouble(String) * */ public double getDouble(int columnIndex) throws SQLException { Object value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return (double)0; } try { return Double.parseDouble(value.toString().trim()); } catch (NumberFormatException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.doublefail").toString(), new Object[] {value.toString().trim(), columnIndex})); } } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a * <code>java.math.BigDecimal</code> object. * <P> * This method is deprecated; use the version of <code>getBigDecimal</code> * that does not take a scale parameter and returns a value with full * precision. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @param scale the number of digits to the right of the decimal point in the * value returned * @return the column value with the specified number of digits to the right * of the decimal point; if the value is SQL <code>NULL</code>, the * result is <code>null</code> * @throws SQLException if the given column index is out of bounds, * the cursor is not on a valid row, or this method fails * @deprecated */ @Deprecated public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException { Object value; BigDecimal bDecimal, retVal; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return (new BigDecimal(0)); } bDecimal = this.getBigDecimal(columnIndex); retVal = bDecimal.setScale(scale); return retVal; } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a * <code>byte</code> array value. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @return the column value as a <code>byte</code> array in the Java programming * language; if the value is SQL <code>NULL</code>, the * result is <code>null</code> * * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code><b>BINARY</b>, <b>VARBINARY</b> or * LONGVARBINARY</code> value. * The bold SQL type designates the recommended return type. * @see #getBytes(String) */ public byte[] getBytes(int columnIndex) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); if (isBinary(RowSetMD.getColumnType(columnIndex)) == false) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } return (byte[])(getCurrentRow().getColumnObject(columnIndex)); } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a * <code>java.sql.Date</code> object. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @return the column value as a <code>java.sql.Data</code> object; if * the value is SQL <code>NULL</code>, the * result is <code>null</code> * @throws SQLException if the given column index is out of bounds, * the cursor is not on a valid row, or this method fails */ public java.sql.Date getDate(int columnIndex) throws SQLException { Object value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return null; } /* * The object coming back from the db could be * a date, a timestamp, or a char field variety. * If it's a date type return it, a timestamp * we turn into a long and then into a date, * char strings we try to parse. Yuck. */ switch (RowSetMD.getColumnType(columnIndex)) { case java.sql.Types.DATE: { long sec = ((java.sql.Date)value).getTime(); return new java.sql.Date(sec); } case java.sql.Types.TIMESTAMP: { long sec = ((java.sql.Timestamp)value).getTime(); return new java.sql.Date(sec); } case java.sql.Types.CHAR: case java.sql.Types.VARCHAR: case java.sql.Types.LONGVARCHAR: { try { DateFormat df = DateFormat.getDateInstance(); return ((java.sql.Date)(df.parse(value.toString()))); } catch (ParseException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.datefail").toString(), new Object[] {value.toString().trim(), columnIndex})); } } default: { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.datefail").toString(), new Object[] {value.toString().trim(), columnIndex})); } } } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a * <code>java.sql.Time</code> object. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @return the column value; if the value is SQL <code>NULL</code>, the * result is <code>null</code> * @throws SQLException if the given column index is out of bounds, * the cursor is not on a valid row, or this method fails */ public java.sql.Time getTime(int columnIndex) throws SQLException { Object value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return null; } /* * The object coming back from the db could be * a date, a timestamp, or a char field variety. * If it's a date type return it, a timestamp * we turn into a long and then into a date, * char strings we try to parse. Yuck. */ switch (RowSetMD.getColumnType(columnIndex)) { case java.sql.Types.TIME: { return (java.sql.Time)value; } case java.sql.Types.TIMESTAMP: { long sec = ((java.sql.Timestamp)value).getTime(); return new java.sql.Time(sec); } case java.sql.Types.CHAR: case java.sql.Types.VARCHAR: case java.sql.Types.LONGVARCHAR: { try { DateFormat tf = DateFormat.getTimeInstance(); return ((java.sql.Time)(tf.parse(value.toString()))); } catch (ParseException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.timefail").toString(), new Object[] {value.toString().trim(), columnIndex})); } } default: { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.timefail").toString(), new Object[] {value.toString().trim(), columnIndex})); } } } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a * <code>java.sql.Timestamp</code> object. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @return the column value; if the value is SQL <code>NULL</code>, the * result is <code>null</code> * @throws SQLException if the given column index is out of bounds, * the cursor is not on a valid row, or this method fails */ public java.sql.Timestamp getTimestamp(int columnIndex) throws SQLException { Object value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return null; } /* * The object coming back from the db could be * a date, a timestamp, or a char field variety. * If it's a date type return it; a timestamp * we turn into a long and then into a date; * char strings we try to parse. Yuck. */ switch (RowSetMD.getColumnType(columnIndex)) { case java.sql.Types.TIMESTAMP: { return (java.sql.Timestamp)value; } case java.sql.Types.TIME: { long sec = ((java.sql.Time)value).getTime(); return new java.sql.Timestamp(sec); } case java.sql.Types.DATE: { long sec = ((java.sql.Date)value).getTime(); return new java.sql.Timestamp(sec); } case java.sql.Types.CHAR: case java.sql.Types.VARCHAR: case java.sql.Types.LONGVARCHAR: { try { DateFormat tf = DateFormat.getTimeInstance(); return ((java.sql.Timestamp)(tf.parse(value.toString()))); } catch (ParseException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.timefail").toString(), new Object[] {value.toString().trim(), columnIndex})); } } default: { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.timefail").toString(), new Object[] {value.toString().trim(), columnIndex})); } } } /** * Retrieves the value of the designated column in the current row of this * <code>CachedRowSetImpl</code> object as a <code>java.io.InputStream</code> * object. * * A column value can be retrieved as a stream of ASCII characters * and then read in chunks from the stream. This method is particularly * suitable for retrieving large <code>LONGVARCHAR</code> values. The JDBC * driver will do any necessary conversion from the database format into ASCII. * * <P><B>Note:</B> All the data in the returned stream must be * read prior to getting the value of any other column. The next * call to a get method implicitly closes the stream. . Also, a * stream may return <code>0</code> for <code>CachedRowSetImpl.available()</code> * whether there is data available or not. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @return a Java input stream that delivers the database column value * as a stream of one-byte ASCII characters. If the value is SQL * <code>NULL</code>, the result is <code>null</code>. * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>CHAR, VARCHAR</code>, <code><b>LONGVARCHAR</b></code> * <code>BINARY, VARBINARY</code> or <code>LONGVARBINARY</code> value. The * bold SQL type designates the recommended return types that this method is * used to retrieve. * @see #getAsciiStream(String) */ public java.io.InputStream getAsciiStream(int columnIndex) throws SQLException { Object value; // always free an old stream asciiStream = null; // sanity check checkIndex(columnIndex); //make sure the cursor is on a vlid row checkCursor(); value = getCurrentRow().getColumnObject(columnIndex); if (value == null) { lastValueNull = true; return null; } try { if (isString(RowSetMD.getColumnType(columnIndex))) { asciiStream = new ByteArrayInputStream(((String)value).getBytes("ASCII")); } else { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } } catch (java.io.UnsupportedEncodingException ex) { throw new SQLException(ex.getMessage()); } return asciiStream; } /** * A column value can be retrieved as a stream of Unicode characters * and then read in chunks from the stream. This method is particularly * suitable for retrieving large LONGVARCHAR values. The JDBC driver will * do any necessary conversion from the database format into Unicode. * * <P><B>Note:</B> All the data in the returned stream must be * read prior to getting the value of any other column. The next * call to a get method implicitly closes the stream. . Also, a * stream may return 0 for available() whether there is data * available or not. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @return a Java input stream that delivers the database column value * as a stream of two byte Unicode characters. If the value is SQL NULL * then the result is null. * @throws SQLException if an error occurs * @deprecated */ @Deprecated public java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException { // always free an old stream unicodeStream = null; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); if (isBinary(RowSetMD.getColumnType(columnIndex)) == false && isString(RowSetMD.getColumnType(columnIndex)) == false) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } Object value = getCurrentRow().getColumnObject(columnIndex); if (value == null) { lastValueNull = true; return null; } unicodeStream = new StringBufferInputStream(value.toString()); return unicodeStream; } /** * Retrieves the value of the designated column in the current row of this * <code>CachedRowSetImpl</code> object as a <code>java.io.InputStream</code> * object. * <P> * A column value can be retrieved as a stream of uninterpreted bytes * and then read in chunks from the stream. This method is particularly * suitable for retrieving large <code>LONGVARBINARY</code> values. * * <P><B>Note:</B> All the data in the returned stream must be * read prior to getting the value of any other column. The next * call to a get method implicitly closes the stream. Also, a * stream may return <code>0</code> for * <code>CachedRowSetImpl.available()</code> whether there is data * available or not. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @return a Java input stream that delivers the database column value * as a stream of uninterpreted bytes. If the value is SQL <code>NULL</code> * then the result is <code>null</code>. * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>BINARY, VARBINARY</code> or <code><b>LONGVARBINARY</b></code> * The bold type indicates the SQL type that this method is recommened * to retrieve. * @see #getBinaryStream(String) */ public java.io.InputStream getBinaryStream(int columnIndex) throws SQLException { // always free an old stream binaryStream = null; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); if (isBinary(RowSetMD.getColumnType(columnIndex)) == false) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } Object value = getCurrentRow().getColumnObject(columnIndex); if (value == null) { lastValueNull = true; return null; } binaryStream = new ByteArrayInputStream((byte[])value); return binaryStream; } // Methods for accessing results by column name /** * Retrieves the value stored in the designated column * of the current row as a <code>String</code> object. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @return the column value; if the value is SQL <code>NULL</code>, * the result is <code>null</code> * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL {@code TINYINT, SMALLINT, INTEGER * BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, } * <b>{@code CHAR, VARCHAR}</b> or * <b>{@code LONGVARCHAR}</b> value. * The bold SQL type designates the recommended return type. */ public String getString(String columnName) throws SQLException { return getString(getColIdxByName(columnName)); } /** * Retrieves the value stored in the designated column * of the current row as a <code>boolean</code> value. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @return the column value as a <code>boolean</code> in the Java programming * language; if the value is SQL <code>NULL</code>, * the result is <code>false</code> * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>BOOLEAN</code> value * @see #getBoolean(int) */ public boolean getBoolean(String columnName) throws SQLException { return getBoolean(getColIdxByName(columnName)); } /** * Retrieves the value stored in the designated column * of the current row as a <code>byte</code> value. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @return the column value as a <code>byte</code> in the Java programming * language; if the value is SQL <code>NULL</code>, the result is <code>0</code> * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code><B>TINYINT</B>, SMALLINT, INTEGER, * BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, * VARCHAR</code> or <code>LONGVARCHAR</code> value. The * bold type designates the recommended return type */ public byte getByte(String columnName) throws SQLException { return getByte(getColIdxByName(columnName)); } /** * Retrieves the value stored in the designated column * of the current row as a <code>short</code> value. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @return the column value; if the value is SQL <code>NULL</code>, * the result is <code>0</code> * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>TINYINT, <b>SMALLINT</b>, INTEGER * BIGINT, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type * designates the recommended return type. * @see #getShort(int) */ public short getShort(String columnName) throws SQLException { return getShort(getColIdxByName(columnName)); } /** * Retrieves the value stored in the designated column * of the current row as an <code>int</code> value. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @return the column value; if the value is SQL <code>NULL</code>, * the result is <code>0</code> * @throws SQLException if (1) the given column name is not the name * of a column in this rowset, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>TINYINT, SMALLINT, <b>INTEGER</b>, BIGINT, REAL * FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, VARCHAR</code> * or <code>LONGVARCHAR</code> value. The bold SQL type designates the * recommended return type. */ public int getInt(String columnName) throws SQLException { return getInt(getColIdxByName(columnName)); } /** * Retrieves the value stored in the designated column * of the current row as a <code>long</code> value. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @return the column value; if the value is SQL <code>NULL</code>, * the result is <code>0</code> * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER * <b>BIGINT</b>, REAL, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type * designates the recommended return type. * @see #getLong(int) */ public long getLong(String columnName) throws SQLException { return getLong(getColIdxByName(columnName)); } /** * Retrieves the value stored in the designated column * of the current row as a <code>float</code> value. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @return the column value; if the value is SQL <code>NULL</code>, * the result is <code>0</code> * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER * BIGINT, <b>REAL</b>, FLOAT, DOUBLE, DECIMAL, NUMERIC, BIT, CHAR, * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type * designates the recommended return type. * @see #getFloat(String) */ public float getFloat(String columnName) throws SQLException { return getFloat(getColIdxByName(columnName)); } /** * Retrieves the value stored in the designated column * of the current row of this <code>CachedRowSetImpl</code> object * as a <code>double</code> value. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @return the column value; if the value is SQL <code>NULL</code>, * the result is <code>0</code> * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER * BIGINT, REAL, <b>FLOAT</b>, <b>DOUBLE</b>, DECIMAL, NUMERIC, BIT, CHAR, * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type * designates the recommended return types. * @see #getDouble(int) */ public double getDouble(String columnName) throws SQLException { return getDouble(getColIdxByName(columnName)); } /** * Retrieves the value stored in the designated column * of the current row as a <code>java.math.BigDecimal</code> object. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @param scale the number of digits to the right of the decimal point * @return a java.math.BugDecimal object with <code><i>scale</i></code> * number of digits to the right of the decimal point. * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER * BIGINT, REAL, FLOAT, DOUBLE, <b>DECIMAL</b>, <b>NUMERIC</b>, BIT CHAR, * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type * designates the recommended return type that this method is used to * retrieve. * @deprecated Use the <code>getBigDecimal(String columnName)</code> * method instead */ @Deprecated public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException { return getBigDecimal(getColIdxByName(columnName), scale); } /** * Retrieves the value stored in the designated column * of the current row as a <code>byte</code> array. * The bytes represent the raw values returned by the driver. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @return the column value as a <code>byte</code> array in the Java programming * language; if the value is SQL <code>NULL</code>, the result is <code>null</code> * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code><b>BINARY</b>, <b>VARBINARY</b> * </code> or <code>LONGVARBINARY</code> values * The bold SQL type designates the recommended return type. * @see #getBytes(int) */ public byte[] getBytes(String columnName) throws SQLException { return getBytes(getColIdxByName(columnName)); } /** * Retrieves the value stored in the designated column * of the current row as a <code>java.sql.Date</code> object. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @return the column value; if the value is SQL <code>NULL</code>, * the result is <code>null</code> * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>DATE</code> or * <code>TIMESTAMP</code> value */ public java.sql.Date getDate(String columnName) throws SQLException { return getDate(getColIdxByName(columnName)); } /** * Retrieves the value stored in the designated column * of the current row as a <code>java.sql.Time</code> object. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @return the column value; if the value is SQL <code>NULL</code>, * the result is <code>null</code> * @throws SQLException if the given column name does not match one of * this rowset's column names or the cursor is not on one of * this rowset's rows or its insert row */ public java.sql.Time getTime(String columnName) throws SQLException { return getTime(getColIdxByName(columnName)); } /** * Retrieves the value stored in the designated column * of the current row as a <code>java.sql.Timestamp</code> object. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @return the column value; if the value is SQL <code>NULL</code>, * the result is <code>null</code> * @throws SQLException if the given column name does not match one of * this rowset's column names or the cursor is not on one of * this rowset's rows or its insert row */ public java.sql.Timestamp getTimestamp(String columnName) throws SQLException { return getTimestamp(getColIdxByName(columnName)); } /** * Retrieves the value of the designated column in the current row of this * <code>CachedRowSetImpl</code> object as a <code>java.io.InputStream</code> * object. * * A column value can be retrieved as a stream of ASCII characters * and then read in chunks from the stream. This method is particularly * suitable for retrieving large <code>LONGVARCHAR</code> values. The * <code>SyncProvider</code> will rely on the JDBC driver to do any necessary * conversion from the database format into ASCII format. * * <P><B>Note:</B> All the data in the returned stream must * be read prior to getting the value of any other column. The * next call to a <code>getXXX</code> method implicitly closes the stream. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @return a Java input stream that delivers the database column value * as a stream of one-byte ASCII characters. If the value is SQL * <code>NULL</code>, the result is <code>null</code>. * @throws SQLException if (1) the given column name is not the name of * a column in this rowset * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>CHAR, VARCHAR</code>, <code><b>LONGVARCHAR</b></code> * <code>BINARY, VARBINARY</code> or <code>LONGVARBINARY</code> value. The * bold SQL type designates the recommended return types that this method is * used to retrieve. * @see #getAsciiStream(int) */ public java.io.InputStream getAsciiStream(String columnName) throws SQLException { return getAsciiStream(getColIdxByName(columnName)); } /** * A column value can be retrieved as a stream of Unicode characters * and then read in chunks from the stream. This method is particularly * suitable for retrieving large <code>LONGVARCHAR</code> values. * The JDBC driver will do any necessary conversion from the database * format into Unicode. * * <P><B>Note:</B> All the data in the returned stream must * be read prior to getting the value of any other column. The * next call to a <code>getXXX</code> method implicitly closes the stream. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @return a Java input stream that delivers the database column value * as a stream of two-byte Unicode characters. If the value is * SQL <code>NULL</code>, the result is <code>null</code>. * @throws SQLException if the given column name does not match one of * this rowset's column names or the cursor is not on one of * this rowset's rows or its insert row * @deprecated use the method <code>getCharacterStream</code> instead */ @Deprecated public java.io.InputStream getUnicodeStream(String columnName) throws SQLException { return getUnicodeStream(getColIdxByName(columnName)); } /** * Retrieves the value of the designated column in the current row of this * <code>CachedRowSetImpl</code> object as a <code>java.io.InputStream</code> * object. * <P> * A column value can be retrieved as a stream of uninterpreted bytes * and then read in chunks from the stream. This method is particularly * suitable for retrieving large <code>LONGVARBINARY</code> values. * * <P><B>Note:</B> All the data in the returned stream must be * read prior to getting the value of any other column. The next * call to a get method implicitly closes the stream. Also, a * stream may return <code>0</code> for <code>CachedRowSetImpl.available()</code> * whether there is data available or not. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @return a Java input stream that delivers the database column value * as a stream of uninterpreted bytes. If the value is SQL * <code>NULL</code>, the result is <code>null</code>. * @throws SQLException if (1) the given column name is unknown, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>BINARY, VARBINARY</code> or <code><b>LONGVARBINARY</b></code> * The bold type indicates the SQL type that this method is recommened * to retrieve. * @see #getBinaryStream(int) * */ public java.io.InputStream getBinaryStream(String columnName) throws SQLException { return getBinaryStream(getColIdxByName(columnName)); } // Advanced features: /** * The first warning reported by calls on this <code>CachedRowSetImpl</code> * object is returned. Subsequent <code>CachedRowSetImpl</code> warnings will * be chained to this <code>SQLWarning</code>. * * <P>The warning chain is automatically cleared each time a new * row is read. * * <P><B>Note:</B> This warning chain only covers warnings caused * by <code>ResultSet</code> methods. Any warning caused by statement * methods (such as reading OUT parameters) will be chained on the * <code>Statement</code> object. * * @return the first SQLWarning or null */ public SQLWarning getWarnings() { return sqlwarn; } /** * Clears all the warnings reporeted for the <code>CachedRowSetImpl</code> * object. After a call to this method, the <code>getWarnings</code> method * returns <code>null</code> until a new warning is reported for this * <code>CachedRowSetImpl</code> object. */ public void clearWarnings() { sqlwarn = null; } /** * Retrieves the name of the SQL cursor used by this * <code>CachedRowSetImpl</code> object. * * <P>In SQL, a result table is retrieved through a cursor that is * named. The current row of a <code>ResultSet</code> can be updated or deleted * using a positioned update/delete statement that references the * cursor name. To ensure that the cursor has the proper isolation * level to support an update operation, the cursor's <code>SELECT</code> * statement should be of the form <code>select for update</code>. * If the <code>for update</code> clause * is omitted, positioned updates may fail. * * <P>JDBC supports this SQL feature by providing the name of the * SQL cursor used by a <code>ResultSet</code> object. The current row * of a result set is also the current row of this SQL cursor. * * <P><B>Note:</B> If positioned updates are not supported, an * <code>SQLException</code> is thrown. * * @return the SQL cursor name for this <code>CachedRowSetImpl</code> object's * cursor * @throws SQLException if an error occurs */ public String getCursorName() throws SQLException { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.posupdate").toString()); } /** * Retrieves a <code>ResultSetMetaData</code> object instance that * contains information about the <code>CachedRowSet</code> object. * However, applications should cast the returned object to a * <code>RowSetMetaData</code> interface implementation. In the * reference implementation, this cast can be done on the * <code>RowSetMetaDataImpl</code> class. * <P> * For example: * <pre> * CachedRowSet crs = new CachedRowSetImpl(); * RowSetMetaDataImpl metaData = * (RowSetMetaDataImpl)crs.getMetaData(); * // Set the number of columns in the RowSet object for * // which this RowSetMetaDataImpl object was created to the * // given number. * metaData.setColumnCount(3); * crs.setMetaData(metaData); * </pre> * * @return the <code>ResultSetMetaData</code> object that describes this * <code>CachedRowSetImpl</code> object's columns * @throws SQLException if an error occurs in generating the RowSet * meta data; or if the <code>CachedRowSetImpl</code> is empty. * @see javax.sql.RowSetMetaData */ public ResultSetMetaData getMetaData() throws SQLException { return (ResultSetMetaData)RowSetMD; } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as an * <code>Object</code> value. * <P> * The type of the <code>Object</code> will be the default * Java object type corresponding to the column's SQL type, * following the mapping for built-in types specified in the JDBC 3.0 * specification. * <P> * This method may also be used to read datatabase-specific * abstract data types. * <P> * This implementation of the method <code>getObject</code> extends its * behavior so that it gets the attributes of an SQL structured type * as an array of <code>Object</code> values. This method also custom * maps SQL user-defined types to classes in the Java programming language. * When the specified column contains * a structured or distinct value, the behavior of this method is as * if it were a call to the method <code>getObject(columnIndex, * this.getStatement().getConnection().getTypeMap())</code>. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @return a <code>java.lang.Object</code> holding the column value; * if the value is SQL <code>NULL</code>, the result is <code>null</code> * @throws SQLException if the given column index is out of bounds, * the cursor is not on a valid row, or there is a problem getting * the <code>Class</code> object for a custom mapping * @see #getObject(String) */ public Object getObject(int columnIndex) throws SQLException { Object value; Map<String, Class<?>> map; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return null; } if (value instanceof Struct) { Struct s = (Struct)value; map = getTypeMap(); // look up the class in the map Class<?> c = map.get(s.getSQLTypeName()); if (c != null) { // create new instance of the class SQLData obj = null; try { ReflectUtil.checkPackageAccess(c); @SuppressWarnings("deprecation") Object tmp = c.newInstance(); obj = (SQLData) tmp; } catch(Exception ex) { throw new SQLException("Unable to Instantiate: ", ex); } // get the attributes from the struct Object attribs[] = s.getAttributes(map); // create the SQLInput "stream" SQLInputImpl sqlInput = new SQLInputImpl(attribs, map); // read the values... obj.readSQL(sqlInput, s.getSQLTypeName()); return (Object)obj; } } return value; } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as an * <code>Object</code> value. * <P> * The type of the <code>Object</code> will be the default * Java object type corresponding to the column's SQL type, * following the mapping for built-in types specified in the JDBC 3.0 * specification. * <P> * This method may also be used to read datatabase-specific * abstract data types. * <P> * This implementation of the method <code>getObject</code> extends its * behavior so that it gets the attributes of an SQL structured type * as an array of <code>Object</code> values. This method also custom * maps SQL user-defined types to classes * in the Java programming language. When the specified column contains * a structured or distinct value, the behavior of this method is as * if it were a call to the method <code>getObject(columnIndex, * this.getStatement().getConnection().getTypeMap())</code>. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @return a <code>java.lang.Object</code> holding the column value; * if the value is SQL <code>NULL</code>, the result is <code>null</code> * @throws SQLException if (1) the given column name does not match one of * this rowset's column names, (2) the cursor is not * on a valid row, or (3) there is a problem getting * the <code>Class</code> object for a custom mapping * @see #getObject(int) */ public Object getObject(String columnName) throws SQLException { return getObject(getColIdxByName(columnName)); } //---------------------------------------------------------------- /** * Maps the given column name for one of this <code>CachedRowSetImpl</code> * object's columns to its column number. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @return the column index of the given column name * @throws SQLException if the given column name does not match one * of this rowset's column names */ public int findColumn(String columnName) throws SQLException { return getColIdxByName(columnName); } //--------------------------JDBC 2.0----------------------------------- //--------------------------------------------------------------------- // Getter's and Setter's //--------------------------------------------------------------------- /** * Retrieves the value stored in the designated column * of the current row as a <code>java.io.Reader</code> object. * * <P><B>Note:</B> All the data in the returned stream must * be read prior to getting the value of any other column. The * next call to a <code>getXXX</code> method implicitly closes the stream. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @return a Java character stream that delivers the database column value * as a stream of two-byte unicode characters in a * <code>java.io.Reader</code> object. If the value is * SQL <code>NULL</code>, the result is <code>null</code>. * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>CHAR, VARCHAR, <b>LONGVARCHAR</b>, BINARY, VARBINARY</code> or * <code>LONGVARBINARY</code> value. * The bold SQL type designates the recommended return type. * @see #getCharacterStream(String) */ public java.io.Reader getCharacterStream(int columnIndex) throws SQLException{ // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); if (isBinary(RowSetMD.getColumnType(columnIndex))) { Object value = getCurrentRow().getColumnObject(columnIndex); if (value == null) { lastValueNull = true; return null; } charStream = new InputStreamReader (new ByteArrayInputStream((byte[])value)); } else if (isString(RowSetMD.getColumnType(columnIndex))) { Object value = getCurrentRow().getColumnObject(columnIndex); if (value == null) { lastValueNull = true; return null; } charStream = new StringReader(value.toString()); } else { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } return charStream; } /** * Retrieves the value stored in the designated column * of the current row as a <code>java.io.Reader</code> object. * * <P><B>Note:</B> All the data in the returned stream must * be read prior to getting the value of any other column. The * next call to a <code>getXXX</code> method implicitly closes the stream. * * @param columnName a <code>String</code> object giving the SQL name of * a column in this <code>CachedRowSetImpl</code> object * @return a Java input stream that delivers the database column value * as a stream of two-byte Unicode characters. If the value is * SQL <code>NULL</code>, the result is <code>null</code>. * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>CHAR, VARCHAR, <b>LONGVARCHAR</b>, * BINARY, VARYBINARY</code> or <code>LONGVARBINARY</code> value. * The bold SQL type designates the recommended return type. */ public java.io.Reader getCharacterStream(String columnName) throws SQLException { return getCharacterStream(getColIdxByName(columnName)); } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a * <code>java.math.BigDecimal</code> object. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @return a <code>java.math.BigDecimal</code> value with full precision; * if the value is SQL <code>NULL</code>, the result is <code>null</code> * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>TINYINT, SMALLINT, INTEGER, BIGINT, REAL, * FLOAT, DOUBLE, <b>DECIMAL</b>, <b>NUMERIC</b>, BIT, CHAR, VARCHAR</code> * or <code>LONGVARCHAR</code> value. The bold SQL type designates the * recommended return types that this method is used to retrieve. * @see #getBigDecimal(String) */ public BigDecimal getBigDecimal(int columnIndex) throws SQLException { Object value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return null; } try { return (new BigDecimal(value.toString().trim())); } catch (NumberFormatException ex) { throw new SQLException(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.doublefail").toString(), new Object[] {value.toString().trim(), columnIndex})); } } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a * <code>java.math.BigDecimal</code> object. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @return a <code>java.math.BigDecimal</code> value with full precision; * if the value is SQL <code>NULL</code>, the result is <code>null</code> * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>TINYINT, SMALLINT, INTEGER * BIGINT, REAL, FLOAT, DOUBLE, <b>DECIMAL</b>, <b>NUMERIC</b>, BIT CHAR, * VARCHAR</code> or <code>LONGVARCHAR</code> value. The bold SQL type * designates the recommended return type that this method is used to * retrieve * @see #getBigDecimal(int) */ public BigDecimal getBigDecimal(String columnName) throws SQLException { return getBigDecimal(getColIdxByName(columnName)); } //--------------------------------------------------------------------- // Traversal/Positioning //--------------------------------------------------------------------- /** * Returns the number of rows in this <code>CachedRowSetImpl</code> object. * * @return number of rows in the rowset */ public int size() { return numRows; } /** * Indicates whether the cursor is before the first row in this * <code>CachedRowSetImpl</code> object. * * @return <code>true</code> if the cursor is before the first row; * <code>false</code> otherwise or if the rowset contains no rows * @throws SQLException if an error occurs */ public boolean isBeforeFirst() throws SQLException { if (cursorPos == 0 && numRows > 0) { return true; } else { return false; } } /** * Indicates whether the cursor is after the last row in this * <code>CachedRowSetImpl</code> object. * * @return <code>true</code> if the cursor is after the last row; * <code>false</code> otherwise or if the rowset contains no rows * @throws SQLException if an error occurs */ public boolean isAfterLast() throws SQLException { if (cursorPos == numRows+1 && numRows > 0) { return true; } else { return false; } } /** * Indicates whether the cursor is on the first row in this * <code>CachedRowSetImpl</code> object. * * @return <code>true</code> if the cursor is on the first row; * <code>false</code> otherwise or if the rowset contains no rows * @throws SQLException if an error occurs */ public boolean isFirst() throws SQLException { // this becomes nasty because of deletes. int saveCursorPos = cursorPos; int saveAbsoluteCursorPos = absolutePos; internalFirst(); if (cursorPos == saveCursorPos) { return true; } else { cursorPos = saveCursorPos; absolutePos = saveAbsoluteCursorPos; return false; } } /** * Indicates whether the cursor is on the last row in this * <code>CachedRowSetImpl</code> object. * <P> * Note: Calling the method <code>isLast</code> may be expensive * because the JDBC driver might need to fetch ahead one row in order * to determine whether the current row is the last row in this rowset. * * @return <code>true</code> if the cursor is on the last row; * <code>false</code> otherwise or if this rowset contains no rows * @throws SQLException if an error occurs */ public boolean isLast() throws SQLException { int saveCursorPos = cursorPos; int saveAbsoluteCursorPos = absolutePos; boolean saveShowDeleted = getShowDeleted(); setShowDeleted(true); internalLast(); if (cursorPos == saveCursorPos) { setShowDeleted(saveShowDeleted); return true; } else { setShowDeleted(saveShowDeleted); cursorPos = saveCursorPos; absolutePos = saveAbsoluteCursorPos; return false; } } /** * Moves this <code>CachedRowSetImpl</code> object's cursor to the front of * the rowset, just before the first row. This method has no effect if * this rowset contains no rows. * * @throws SQLException if an error occurs or the type of this rowset * is <code>ResultSet.TYPE_FORWARD_ONLY</code> */ public void beforeFirst() throws SQLException { if (getType() == ResultSet.TYPE_FORWARD_ONLY) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.beforefirst").toString()); } cursorPos = 0; absolutePos = 0; notifyCursorMoved(); } /** * Moves this <code>CachedRowSetImpl</code> object's cursor to the end of * the rowset, just after the last row. This method has no effect if * this rowset contains no rows. * * @throws SQLException if an error occurs */ public void afterLast() throws SQLException { if (numRows > 0) { cursorPos = numRows + 1; absolutePos = 0; notifyCursorMoved(); } } /** * Moves this <code>CachedRowSetImpl</code> object's cursor to the first row * and returns <code>true</code> if the operation was successful. This * method also notifies registered listeners that the cursor has moved. * * @return <code>true</code> if the cursor is on a valid row; * <code>false</code> otherwise or if there are no rows in this * <code>CachedRowSetImpl</code> object * @throws SQLException if the type of this rowset * is <code>ResultSet.TYPE_FORWARD_ONLY</code> */ public boolean first() throws SQLException { if(getType() == ResultSet.TYPE_FORWARD_ONLY) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.first").toString()); } // move and notify boolean ret = this.internalFirst(); notifyCursorMoved(); return ret; } /** * Moves this <code>CachedRowSetImpl</code> object's cursor to the first * row and returns <code>true</code> if the operation is successful. * <P> * This method is called internally by the methods <code>first</code>, * <code>isFirst</code>, and <code>absolute</code>. * It in turn calls the method <code>internalNext</code> in order to * handle the case where the first row is a deleted row that is not visible. * <p> * This is a implementation only method and is not required as a standard * implementation of the <code>CachedRowSet</code> interface. * * @return <code>true</code> if the cursor moved to the first row; * <code>false</code> otherwise * @throws SQLException if an error occurs */ protected boolean internalFirst() throws SQLException { boolean ret = false; if (numRows > 0) { cursorPos = 1; if ((getShowDeleted() == false) && (rowDeleted() == true)) { ret = internalNext(); } else { ret = true; } } if (ret == true) absolutePos = 1; else absolutePos = 0; return ret; } /** * Moves this <code>CachedRowSetImpl</code> object's cursor to the last row * and returns <code>true</code> if the operation was successful. This * method also notifies registered listeners that the cursor has moved. * * @return <code>true</code> if the cursor is on a valid row; * <code>false</code> otherwise or if there are no rows in this * <code>CachedRowSetImpl</code> object * @throws SQLException if the type of this rowset * is <code>ResultSet.TYPE_FORWARD_ONLY</code> */ public boolean last() throws SQLException { if (getType() == ResultSet.TYPE_FORWARD_ONLY) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.last").toString()); } // move and notify boolean ret = this.internalLast(); notifyCursorMoved(); return ret; } /** * Moves this <code>CachedRowSetImpl</code> object's cursor to the last * row and returns <code>true</code> if the operation is successful. * <P> * This method is called internally by the method <code>last</code> * when rows have been deleted and the deletions are not visible. * The method <code>internalLast</code> handles the case where the * last row is a deleted row that is not visible by in turn calling * the method <code>internalPrevious</code>. * <p> * This is a implementation only method and is not required as a standard * implementation of the <code>CachedRowSet</code> interface. * * @return <code>true</code> if the cursor moved to the last row; * <code>false</code> otherwise * @throws SQLException if an error occurs */ protected boolean internalLast() throws SQLException { boolean ret = false; if (numRows > 0) { cursorPos = numRows; if ((getShowDeleted() == false) && (rowDeleted() == true)) { ret = internalPrevious(); } else { ret = true; } } if (ret == true) absolutePos = numRows - numDeleted; else absolutePos = 0; return ret; } /** * Returns the number of the current row in this <code>CachedRowSetImpl</code> * object. The first row is number 1, the second number 2, and so on. * * @return the number of the current row; <code>0</code> if there is no * current row * @throws SQLException if an error occurs; or if the <code>CacheRowSetImpl</code> * is empty */ public int getRow() throws SQLException { // are we on a valid row? Valid rows are between first and last if (numRows > 0 && cursorPos > 0 && cursorPos < (numRows + 1) && (getShowDeleted() == false && rowDeleted() == false)) { return absolutePos; } else if (getShowDeleted() == true) { return cursorPos; } else { return 0; } } /** * Moves this <code>CachedRowSetImpl</code> object's cursor to the row number * specified. * * <p>If the number is positive, the cursor moves to an absolute row with * respect to the beginning of the rowset. The first row is row 1, the second * is row 2, and so on. For example, the following command, in which * <code>crs</code> is a <code>CachedRowSetImpl</code> object, moves the cursor * to the fourth row, starting from the beginning of the rowset. * <PRE><code> * * crs.absolute(4); * * </code> </PRE> * <P> * If the number is negative, the cursor moves to an absolute row position * with respect to the end of the rowset. For example, calling * <code>absolute(-1)</code> positions the cursor on the last row, * <code>absolute(-2)</code> moves it on the next-to-last row, and so on. * If the <code>CachedRowSetImpl</code> object <code>crs</code> has five rows, * the following command moves the cursor to the fourth-to-last row, which * in the case of a rowset with five rows, is also the second row, counting * from the beginning. * <PRE><code> * * crs.absolute(-4); * * </code> </PRE> * * If the number specified is larger than the number of rows, the cursor * will move to the position after the last row. If the number specified * would move the cursor one or more rows before the first row, the cursor * moves to the position before the first row. * <P> * Note: Calling <code>absolute(1)</code> is the same as calling the * method <code>first()</code>. Calling <code>absolute(-1)</code> is the * same as calling <code>last()</code>. * * @param row a positive number to indicate the row, starting row numbering from * the first row, which is <code>1</code>; a negative number to indicate * the row, starting row numbering from the last row, which is * <code>-1</code>; it must not be <code>0</code> * @return <code>true</code> if the cursor is on the rowset; <code>false</code> * otherwise * @throws SQLException if the given cursor position is <code>0</code> or the * type of this rowset is <code>ResultSet.TYPE_FORWARD_ONLY</code> */ public boolean absolute( int row ) throws SQLException { if (row == 0 || getType() == ResultSet.TYPE_FORWARD_ONLY) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.absolute").toString()); } if (row > 0) { // we are moving foward if (row > numRows) { // fell off the end afterLast(); return false; } else { if (absolutePos <= 0) internalFirst(); } } else { // we are moving backward if (cursorPos + row < 0) { // fell off the front beforeFirst(); return false; } else { if (absolutePos >= 0) internalLast(); } } // Now move towards the absolute row that we're looking for while (absolutePos != row) { if (absolutePos < row) { if (!internalNext()) break; } else { if (!internalPrevious()) break; } } notifyCursorMoved(); if (isAfterLast() || isBeforeFirst()) { return false; } else { return true; } } /** * Moves the cursor the specified number of rows from the current * position, with a positive number moving it forward and a * negative number moving it backward. * <P> * If the number is positive, the cursor moves the specified number of * rows toward the end of the rowset, starting at the current row. * For example, the following command, in which * <code>crs</code> is a <code>CachedRowSetImpl</code> object with 100 rows, * moves the cursor forward four rows from the current row. If the * current row is 50, the cursor would move to row 54. * <PRE><code> * * crs.relative(4); * * </code> </PRE> * <P> * If the number is negative, the cursor moves back toward the beginning * the specified number of rows, starting at the current row. * For example, calling the method * <code>absolute(-1)</code> positions the cursor on the last row, * <code>absolute(-2)</code> moves it on the next-to-last row, and so on. * If the <code>CachedRowSetImpl</code> object <code>crs</code> has five rows, * the following command moves the cursor to the fourth-to-last row, which * in the case of a rowset with five rows, is also the second row * from the beginning. * <PRE><code> * * crs.absolute(-4); * * </code> </PRE> * * If the number specified is larger than the number of rows, the cursor * will move to the position after the last row. If the number specified * would move the cursor one or more rows before the first row, the cursor * moves to the position before the first row. In both cases, this method * throws an <code>SQLException</code>. * <P> * Note: Calling <code>absolute(1)</code> is the same as calling the * method <code>first()</code>. Calling <code>absolute(-1)</code> is the * same as calling <code>last()</code>. Calling <code>relative(0)</code> * is valid, but it does not change the cursor position. * * @param rows an <code>int</code> indicating the number of rows to move * the cursor, starting at the current row; a positive number * moves the cursor forward; a negative number moves the cursor * backward; must not move the cursor past the valid * rows * @return <code>true</code> if the cursor is on a row in this * <code>CachedRowSetImpl</code> object; <code>false</code> * otherwise * @throws SQLException if there are no rows in this rowset, the cursor is * positioned either before the first row or after the last row, or * the rowset is type <code>ResultSet.TYPE_FORWARD_ONLY</code> */ public boolean relative(int rows) throws SQLException { if (numRows == 0 || isBeforeFirst() || isAfterLast() || getType() == ResultSet.TYPE_FORWARD_ONLY) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.relative").toString()); } if (rows == 0) { return true; } if (rows > 0) { // we are moving forward if (cursorPos + rows > numRows) { // fell off the end afterLast(); } else { for (int i=0; i < rows; i++) { if (!internalNext()) break; } } } else { // we are moving backward if (cursorPos + rows < 0) { // fell off the front beforeFirst(); } else { for (int i=rows; i < 0; i++) { if (!internalPrevious()) break; } } } notifyCursorMoved(); if (isAfterLast() || isBeforeFirst()) { return false; } else { return true; } } /** * Moves this <code>CachedRowSetImpl</code> object's cursor to the * previous row and returns <code>true</code> if the cursor is on * a valid row or <code>false</code> if it is not. * This method also notifies all listeners registered with this * <code>CachedRowSetImpl</code> object that its cursor has moved. * <P> * Note: calling the method <code>previous()</code> is not the same * as calling the method <code>relative(-1)</code>. This is true * because it is possible to call <code>previous()</code> from the insert * row, from after the last row, or from the current row, whereas * <code>relative</code> may only be called from the current row. * <P> * The method <code>previous</code> may used in a <code>while</code> * loop to iterate through a rowset starting after the last row * and moving toward the beginning. The loop ends when <code>previous</code> * returns <code>false</code>, meaning that there are no more rows. * For example, the following code fragment retrieves all the data in * the <code>CachedRowSetImpl</code> object <code>crs</code>, which has * three columns. Note that the cursor must initially be positioned * after the last row so that the first call to the method * <code>previous</code> places the cursor on the last line. * <PRE> <code> * * crs.afterLast(); * while (previous()) { * String name = crs.getString(1); * int age = crs.getInt(2); * short ssn = crs.getShort(3); * System.out.println(name + " " + age + " " + ssn); * } * * </code> </PRE> * This method throws an <code>SQLException</code> if the cursor is not * on a row in the rowset, before the first row, or after the last row. * * @return <code>true</code> if the cursor is on a valid row; * <code>false</code> if it is before the first row or after the * last row * @throws SQLException if the cursor is not on a valid position or the * type of this rowset is <code>ResultSet.TYPE_FORWARD_ONLY</code> */ public boolean previous() throws SQLException { if (getType() == ResultSet.TYPE_FORWARD_ONLY) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.last").toString()); } /* * make sure things look sane. The cursor must be * positioned in the rowset or before first (0) or * after last (numRows + 1) */ if (cursorPos < 0 || cursorPos > numRows + 1) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcp").toString()); } // move and notify boolean ret = this.internalPrevious(); notifyCursorMoved(); return ret; } /** * Moves the cursor to the previous row in this <code>CachedRowSetImpl</code> * object, skipping past deleted rows that are not visible; returns * <code>true</code> if the cursor is on a row in this rowset and * <code>false</code> when the cursor goes before the first row. * <P> * This method is called internally by the method <code>previous</code>. * <P> * This is a implementation only method and is not required as a standard * implementation of the <code>CachedRowSet</code> interface. * * @return <code>true</code> if the cursor is on a row in this rowset; * <code>false</code> when the cursor reaches the position before * the first row * @throws SQLException if an error occurs */ protected boolean internalPrevious() throws SQLException { boolean ret = false; do { if (cursorPos > 1) { --cursorPos; ret = true; } else if (cursorPos == 1) { // decrement to before first --cursorPos; ret = false; break; } } while ((getShowDeleted() == false) && (rowDeleted() == true)); /* * Each call to internalPrevious may move the cursor * over multiple rows, the absolute position moves one row */ if (ret == true) --absolutePos; else absolutePos = 0; return ret; } //--------------------------------------------------------------------- // Updates //--------------------------------------------------------------------- /** * Indicates whether the current row of this <code>CachedRowSetImpl</code> * object has been updated. The value returned * depends on whether this rowset can detect updates: <code>false</code> * will always be returned if it does not detect updates. * * @return <code>true</code> if the row has been visibly updated * by the owner or another and updates are detected; * <code>false</code> otherwise * @throws SQLException if the cursor is on the insert row or not * not on a valid row * * @see DatabaseMetaData#updatesAreDetected */ public boolean rowUpdated() throws SQLException { // make sure the cursor is on a valid row checkCursor(); if (onInsertRow == true) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidop").toString()); } return(((Row)getCurrentRow()).getUpdated()); } /** * Indicates whether the designated column of the current row of * this <code>CachedRowSetImpl</code> object has been updated. The * value returned depends on whether this rowset can detcted updates: * <code>false</code> will always be returned if it does not detect updates. * * @param idx the index identifier of the column that may be have been updated. * @return <code>true</code> is the designated column has been updated * and the rowset detects updates; <code>false</code> if the rowset has not * been updated or the rowset does not detect updates * @throws SQLException if the cursor is on the insert row or not * on a valid row * @see DatabaseMetaData#updatesAreDetected */ public boolean columnUpdated(int idx) throws SQLException { // make sure the cursor is on a valid row checkCursor(); if (onInsertRow == true) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidop").toString()); } return (((Row)getCurrentRow()).getColUpdated(idx - 1)); } /** * Indicates whether the designated column of the current row of * this <code>CachedRowSetImpl</code> object has been updated. The * value returned depends on whether this rowset can detcted updates: * <code>false</code> will always be returned if it does not detect updates. * * @param columnName the <code>String</code> column name column that may be have * been updated. * @return <code>true</code> is the designated column has been updated * and the rowset detects updates; <code>false</code> if the rowset has not * been updated or the rowset does not detect updates * @throws SQLException if the cursor is on the insert row or not * on a valid row * @see DatabaseMetaData#updatesAreDetected */ public boolean columnUpdated(String columnName) throws SQLException { return columnUpdated(getColIdxByName(columnName)); } /** * Indicates whether the current row has been inserted. The value returned * depends on whether or not the rowset can detect visible inserts. * * @return <code>true</code> if a row has been inserted and inserts are detected; * <code>false</code> otherwise * @throws SQLException if the cursor is on the insert row or not * not on a valid row * * @see DatabaseMetaData#insertsAreDetected */ public boolean rowInserted() throws SQLException { // make sure the cursor is on a valid row checkCursor(); if (onInsertRow == true) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidop").toString()); } return(((Row)getCurrentRow()).getInserted()); } /** * Indicates whether the current row has been deleted. A deleted row * may leave a visible "hole" in a rowset. This method can be used to * detect such holes if the rowset can detect deletions. This method * will always return <code>false</code> if this rowset cannot detect * deletions. * * @return <code>true</code> if (1)the current row is blank, indicating that * the row has been deleted, and (2)deletions are detected; * <code>false</code> otherwise * @throws SQLException if the cursor is on a valid row in this rowset * @see DatabaseMetaData#deletesAreDetected */ public boolean rowDeleted() throws SQLException { // make sure the cursor is on a valid row if (isAfterLast() == true || isBeforeFirst() == true || onInsertRow == true) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcp").toString()); } return(((Row)getCurrentRow()).getDeleted()); } /** * Indicates whether the given SQL data type is a numberic type. * * @param type one of the constants from <code>java.sql.Types</code> * @return <code>true</code> if the given type is <code>NUMERIC</code>,' * <code>DECIMAL</code>, <code>BIT</code>, <code>TINYINT</code>, * <code>SMALLINT</code>, <code>INTEGER</code>, <code>BIGINT</code>, * <code>REAL</code>, <code>DOUBLE</code>, or <code>FLOAT</code>; * <code>false</code> otherwise */ private boolean isNumeric(int type) { switch (type) { case java.sql.Types.NUMERIC: case java.sql.Types.DECIMAL: case java.sql.Types.BIT: case java.sql.Types.TINYINT: case java.sql.Types.SMALLINT: case java.sql.Types.INTEGER: case java.sql.Types.BIGINT: case java.sql.Types.REAL: case java.sql.Types.DOUBLE: case java.sql.Types.FLOAT: return true; default: return false; } } /** * Indicates whether the given SQL data type is a string type. * * @param type one of the constants from <code>java.sql.Types</code> * @return <code>true</code> if the given type is <code>CHAR</code>,' * <code>VARCHAR</code>, or <code>LONGVARCHAR</code>; * <code>false</code> otherwise */ private boolean isString(int type) { switch (type) { case java.sql.Types.CHAR: case java.sql.Types.VARCHAR: case java.sql.Types.LONGVARCHAR: return true; default: return false; } } /** * Indicates whether the given SQL data type is a binary type. * * @param type one of the constants from <code>java.sql.Types</code> * @return <code>true</code> if the given type is <code>BINARY</code>,' * <code>VARBINARY</code>, or <code>LONGVARBINARY</code>; * <code>false</code> otherwise */ private boolean isBinary(int type) { switch (type) { case java.sql.Types.BINARY: case java.sql.Types.VARBINARY: case java.sql.Types.LONGVARBINARY: return true; default: return false; } } /** * Indicates whether the given SQL data type is a temporal type. * This method is called internally by the conversion methods * <code>convertNumeric</code> and <code>convertTemporal</code>. * * @param type one of the constants from <code>java.sql.Types</code> * @return <code>true</code> if the given type is <code>DATE</code>, * <code>TIME</code>, or <code>TIMESTAMP</code>; * <code>false</code> otherwise */ private boolean isTemporal(int type) { switch (type) { case java.sql.Types.DATE: case java.sql.Types.TIME: case java.sql.Types.TIMESTAMP: return true; default: return false; } } /** * Indicates whether the given SQL data type is a boolean type. * This method is called internally by the conversion methods * <code>convertNumeric</code> and <code>convertBoolean</code>. * * @param type one of the constants from <code>java.sql.Types</code> * @return <code>true</code> if the given type is <code>BIT</code>, * , or <code>BOOLEAN</code>; * <code>false</code> otherwise */ private boolean isBoolean(int type) { switch (type) { case java.sql.Types.BIT: case java.sql.Types.BOOLEAN: return true; default: return false; } } /** * Converts the given <code>Object</code> in the Java programming language * to the standard mapping for the specified SQL target data type. * The conversion must be to a string or numeric type, but there are no * restrictions on the type to be converted. If the source type and target * type are the same, the given object is simply returned. * * @param srcObj the <code>Object</code> in the Java programming language * that is to be converted to the target type * @param srcType the data type that is the standard mapping in SQL of the * object to be converted; must be one of the constants in * <code>java.sql.Types</code> * @param trgType the SQL data type to which to convert the given object; * must be one of the following constants in * <code>java.sql.Types</code>: <code>NUMERIC</code>, * <code>DECIMAL</code>, <code>BIT</code>, <code>TINYINT</code>, * <code>SMALLINT</code>, <code>INTEGER</code>, <code>BIGINT</code>, * <code>REAL</code>, <code>DOUBLE</code>, <code>FLOAT</code>, * <code>VARCHAR</code>, <code>LONGVARCHAR</code>, or <code>CHAR</code> * @return an <code>Object</code> value.that is * the standard object mapping for the target SQL type * @throws SQLException if the given target type is not one of the string or * numeric types in <code>java.sql.Types</code> */ private Object convertNumeric(Object srcObj, int srcType, int trgType) throws SQLException { if (srcType == trgType) { return srcObj; } if (isNumeric(trgType) == false && isString(trgType) == false) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString() + trgType); } try { switch (trgType) { case java.sql.Types.BIT: Integer i = Integer.valueOf(srcObj.toString().trim()); return i.equals(0) ? Boolean.valueOf(false) : Boolean.valueOf(true); case java.sql.Types.TINYINT: return Byte.valueOf(srcObj.toString().trim()); case java.sql.Types.SMALLINT: return Short.valueOf(srcObj.toString().trim()); case java.sql.Types.INTEGER: return Integer.valueOf(srcObj.toString().trim()); case java.sql.Types.BIGINT: return Long.valueOf(srcObj.toString().trim()); case java.sql.Types.NUMERIC: case java.sql.Types.DECIMAL: return new BigDecimal(srcObj.toString().trim()); case java.sql.Types.REAL: case java.sql.Types.FLOAT: return Float.valueOf(srcObj.toString().trim()); case java.sql.Types.DOUBLE: return Double.valueOf(srcObj.toString().trim()); case java.sql.Types.CHAR: case java.sql.Types.VARCHAR: case java.sql.Types.LONGVARCHAR: return srcObj.toString(); default: throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()+ trgType); } } catch (NumberFormatException ex) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString() + trgType); } } /** * Converts the given <code>Object</code> in the Java programming language * to the standard object mapping for the specified SQL target data type. * The conversion must be to a string or temporal type, and there are also * restrictions on the type to be converted. * <P> * <TABLE ALIGN="CENTER" BORDER CELLPADDING=10 BORDERCOLOR="#0000FF" * <CAPTION ALIGN="CENTER"><B>Parameters and Return Values</B></CAPTION> * <TR> * <TD><B>Source SQL Type</B> * <TD><B>Target SQL Type</B> * <TD><B>Object Returned</B> * </TR> * <TR> * <TD><code>TIMESTAMP</code> * <TD><code>DATE</code> * <TD><code>java.sql.Date</code> * </TR> * <TR> * <TD><code>TIMESTAMP</code> * <TD><code>TIME</code> * <TD><code>java.sql.Time</code> * </TR> * <TR> * <TD><code>TIME</code> * <TD><code>TIMESTAMP</code> * <TD><code>java.sql.Timestamp</code> * </TR> * <TR> * <TD><code>DATE</code>, <code>TIME</code>, or <code>TIMESTAMP</code> * <TD><code>CHAR</code>, <code>VARCHAR</code>, or <code>LONGVARCHAR</code> * <TD><code>java.lang.String</code> * </TR> * </TABLE> * <P> * If the source type and target type are the same, * the given object is simply returned. * * @param srcObj the <code>Object</code> in the Java programming language * that is to be converted to the target type * @param srcType the data type that is the standard mapping in SQL of the * object to be converted; must be one of the constants in * <code>java.sql.Types</code> * @param trgType the SQL data type to which to convert the given object; * must be one of the following constants in * <code>java.sql.Types</code>: <code>DATE</code>, * <code>TIME</code>, <code>TIMESTAMP</code>, <code>CHAR</code>, * <code>VARCHAR</code>, or <code>LONGVARCHAR</code> * @return an <code>Object</code> value.that is * the standard object mapping for the target SQL type * @throws SQLException if the given target type is not one of the string or * temporal types in <code>java.sql.Types</code> */ private Object convertTemporal(Object srcObj, int srcType, int trgType) throws SQLException { if (srcType == trgType) { return srcObj; } if (isNumeric(trgType) == true || (isString(trgType) == false && isTemporal(trgType) == false)) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } try { switch (trgType) { case java.sql.Types.DATE: if (srcType == java.sql.Types.TIMESTAMP) { return new java.sql.Date(((java.sql.Timestamp)srcObj).getTime()); } else { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } case java.sql.Types.TIMESTAMP: if (srcType == java.sql.Types.TIME) { return new Timestamp(((java.sql.Time)srcObj).getTime()); } else { return new Timestamp(((java.sql.Date)srcObj).getTime()); } case java.sql.Types.TIME: if (srcType == java.sql.Types.TIMESTAMP) { return new Time(((java.sql.Timestamp)srcObj).getTime()); } else { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } case java.sql.Types.CHAR: case java.sql.Types.VARCHAR: case java.sql.Types.LONGVARCHAR: return srcObj.toString(); default: throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } } catch (NumberFormatException ex) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } } /** * Converts the given <code>Object</code> in the Java programming language * to the standard mapping for the specified SQL target data type. * The conversion must be to a string or numeric type, but there are no * restrictions on the type to be converted. If the source type and target * type are the same, the given object is simply returned. * * @param srcObj the <code>Object</code> in the Java programming language * that is to be converted to the target type * @param srcType the data type that is the standard mapping in SQL of the * object to be converted; must be one of the constants in * <code>java.sql.Types</code> * @param trgType the SQL data type to which to convert the given object; * must be one of the following constants in * <code>java.sql.Types</code>: <code>BIT</code>, * or <code>BOOLEAN</code> * @return an <code>Object</code> value.that is * the standard object mapping for the target SQL type * @throws SQLException if the given target type is not one of the Boolean * types in <code>java.sql.Types</code> */ private Object convertBoolean(Object srcObj, int srcType, int trgType) throws SQLException { if (srcType == trgType) { return srcObj; } if (isNumeric(trgType) == true || (isString(trgType) == false && isBoolean(trgType) == false)) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } try { switch (trgType) { case java.sql.Types.BIT: Integer i = Integer.valueOf(srcObj.toString().trim()); return i.equals(0) ? Boolean.valueOf(false) : Boolean.valueOf(true); case java.sql.Types.BOOLEAN: return Boolean.valueOf(srcObj.toString().trim()); default: throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()+ trgType); } } catch (NumberFormatException ex) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString() + trgType); } } /** * Sets the designated nullable column in the current row or the * insert row of this <code>CachedRowSetImpl</code> object with * <code>null</code> value. * <P> * This method updates a column value in the current row or the insert * row of this rowset; however, another method must be called to complete * the update process. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to mark the row as updated * and to notify listeners that the row has changed. * If the cursor is on the insert row, the method {@link #insertRow} * must be called to insert the new row into this rowset and to notify * listeners that a row has changed. * <P> * In order to propagate updates in this rowset to the underlying * data source, an application must call the method {@link #acceptChanges} * after it calls either <code>updateRow</code> or <code>insertRow</code>. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateNull(int columnIndex) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); BaseRow row = getCurrentRow(); row.setColumnObject(columnIndex, null); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>boolean</code> value. * <P> * This method updates a column value in the current row or the insert * row of this rowset, but it does not update the database. * If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateBoolean(int columnIndex, boolean x) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); Object obj = convertBoolean(Boolean.valueOf(x), java.sql.Types.BIT, RowSetMD.getColumnType(columnIndex)); getCurrentRow().setColumnObject(columnIndex, obj); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>byte</code> value. * <P> * This method updates a column value in the current row or the insert * row of this rowset, but it does not update the database. * If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateByte(int columnIndex, byte x) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); Object obj = convertNumeric(Byte.valueOf(x), java.sql.Types.TINYINT, RowSetMD.getColumnType(columnIndex)); getCurrentRow().setColumnObject(columnIndex, obj); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>short</code> value. * <P> * This method updates a column value in the current row or the insert * row of this rowset, but it does not update the database. * If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateShort(int columnIndex, short x) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); Object obj = convertNumeric(Short.valueOf(x), java.sql.Types.SMALLINT, RowSetMD.getColumnType(columnIndex)); getCurrentRow().setColumnObject(columnIndex, obj); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>int</code> value. * <P> * This method updates a column value in the current row or the insert * row of this rowset, but it does not update the database. * If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateInt(int columnIndex, int x) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); Object obj = convertNumeric(x, java.sql.Types.INTEGER, RowSetMD.getColumnType(columnIndex)); getCurrentRow().setColumnObject(columnIndex, obj); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>long</code> value. * <P> * This method updates a column value in the current row or the insert * row of this rowset, but it does not update the database. * If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateLong(int columnIndex, long x) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); Object obj = convertNumeric(Long.valueOf(x), java.sql.Types.BIGINT, RowSetMD.getColumnType(columnIndex)); getCurrentRow().setColumnObject(columnIndex, obj); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>float</code> value. * <P> * This method updates a column value in the current row or the insert * row of this rowset, but it does not update the database. * If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateFloat(int columnIndex, float x) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); Object obj = convertNumeric(Float.valueOf(x), java.sql.Types.REAL, RowSetMD.getColumnType(columnIndex)); getCurrentRow().setColumnObject(columnIndex, obj); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>double</code> value. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateDouble(int columnIndex, double x) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); Object obj = convertNumeric(Double.valueOf(x), java.sql.Types.DOUBLE, RowSetMD.getColumnType(columnIndex)); getCurrentRow().setColumnObject(columnIndex, obj); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>java.math.BigDecimal</code> object. * <P> * This method updates a column value in the current row or the insert * row of this rowset, but it does not update the database. * If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); Object obj = convertNumeric(x, java.sql.Types.NUMERIC, RowSetMD.getColumnType(columnIndex)); getCurrentRow().setColumnObject(columnIndex, obj); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>String</code> object. * <P> * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to mark the row as updated. * If the cursor is on the insert row, the method {@link #insertRow} * must be called to insert the new row into this rowset and mark it * as inserted. Both of these methods must be called before the * cursor moves to another row. * <P> * The method <code>acceptChanges</code> must be called if the * updated values are to be written back to the underlying database. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateString(int columnIndex, String x) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); getCurrentRow().setColumnObject(columnIndex, x); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>byte</code> array. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateBytes(int columnIndex, byte x[]) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); if (isBinary(RowSetMD.getColumnType(columnIndex)) == false) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } getCurrentRow().setColumnObject(columnIndex, x); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>Date</code> object. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, (3) the type of the designated column is not * an SQL <code>DATE</code> or <code>TIMESTAMP</code>, or * (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateDate(int columnIndex, java.sql.Date x) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); Object obj = convertTemporal(x, java.sql.Types.DATE, RowSetMD.getColumnType(columnIndex)); getCurrentRow().setColumnObject(columnIndex, obj); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>Time</code> object. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, (3) the type of the designated column is not * an SQL <code>TIME</code> or <code>TIMESTAMP</code>, or * (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateTime(int columnIndex, java.sql.Time x) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); Object obj = convertTemporal(x, java.sql.Types.TIME, RowSetMD.getColumnType(columnIndex)); getCurrentRow().setColumnObject(columnIndex, obj); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>Timestamp</code> object. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, (3) the type of the designated column is not * an SQL <code>DATE</code>, <code>TIME</code>, or * <code>TIMESTAMP</code>, or (4) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateTimestamp(int columnIndex, java.sql.Timestamp x) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); Object obj = convertTemporal(x, java.sql.Types.TIMESTAMP, RowSetMD.getColumnType(columnIndex)); getCurrentRow().setColumnObject(columnIndex, obj); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * ASCII stream value. * <P> * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value * @param length the number of one-byte ASCII characters in the stream * @throws SQLException if this method is invoked */ public void updateAsciiStream(int columnIndex, java.io.InputStream x, int length) throws SQLException { // sanity Check checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); if (isString(RowSetMD.getColumnType(columnIndex)) == false && isBinary(RowSetMD.getColumnType(columnIndex)) == false) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } byte buf[] = new byte[length]; try { int charsRead = 0; do { charsRead += x.read(buf, charsRead, length - charsRead); } while (charsRead != length); //Changed the condition check to check for length instead of -1 } catch (java.io.IOException ex) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.asciistream").toString()); } String str = new String(buf); getCurrentRow().setColumnObject(columnIndex, str); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>java.io.InputStream</code> object. * <P> * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value; must be a <code>java.io.InputStream</code> * containing <code>BINARY</code>, <code>VARBINARY</code>, or * <code>LONGVARBINARY</code> data * @param length the length of the stream in bytes * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, (3) the data in the stream is not binary, or * (4) this rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateBinaryStream(int columnIndex, java.io.InputStream x,int length) throws SQLException { // sanity Check checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); if (isBinary(RowSetMD.getColumnType(columnIndex)) == false) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } byte buf[] = new byte[length]; try { int bytesRead = 0; do { bytesRead += x.read(buf, bytesRead, length - bytesRead); } while (bytesRead != -1); } catch (java.io.IOException ex) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.binstream").toString()); } getCurrentRow().setColumnObject(columnIndex, buf); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>java.io.Reader</code> object. * <P> * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value; must be a <code>java.io.Reader</code> * containing <code>BINARY</code>, <code>VARBINARY</code>, * <code>LONGVARBINARY</code>, <code>CHAR</code>, <code>VARCHAR</code>, * or <code>LONGVARCHAR</code> data * @param length the length of the stream in characters * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, (3) the data in the stream is not a binary or * character type, or (4) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateCharacterStream(int columnIndex, java.io.Reader x, int length) throws SQLException { // sanity Check checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); if (isString(RowSetMD.getColumnType(columnIndex)) == false && isBinary(RowSetMD.getColumnType(columnIndex)) == false) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } char buf[] = new char[length]; try { int charsRead = 0; do { charsRead += x.read(buf, charsRead, length - charsRead); } while (charsRead != length); //Changed the condition checking to check for length instead of -1 } catch (java.io.IOException ex) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.binstream").toString()); } String str = new String(buf); getCurrentRow().setColumnObject(columnIndex, str); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>Object</code> value. The <code>scale</code> parameter indicates * the number of digits to the right of the decimal point and is ignored * if the new column value is not a type that will be mapped to an SQL * <code>DECIMAL</code> or <code>NUMERIC</code> value. * <P> * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value * @param scale the number of digits to the right of the decimal point (for * <code>DECIMAL</code> and <code>NUMERIC</code> types only) * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateObject(int columnIndex, Object x, int scale) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); int type = RowSetMD.getColumnType(columnIndex); if (type == Types.DECIMAL || type == Types.NUMERIC) { ((java.math.BigDecimal)x).setScale(scale); } getCurrentRow().setColumnObject(columnIndex, x); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>Object</code> value. * <P> * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param x the new column value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateObject(int columnIndex, Object x) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); getCurrentRow().setColumnObject(columnIndex, x); } /** * Sets the designated nullable column in the current row or the * insert row of this <code>CachedRowSetImpl</code> object with * <code>null</code> value. * <P> * This method updates a column value in the current row or the insert * row of this rowset, but it does not update the database. * If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateNull(String columnName) throws SQLException { updateNull(getColIdxByName(columnName)); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>boolean</code> value. * <P> * This method updates a column value in the current row or the insert * row of this rowset, but it does not update the database. * If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateBoolean(String columnName, boolean x) throws SQLException { updateBoolean(getColIdxByName(columnName), x); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>byte</code> value. * <P> * This method updates a column value in the current row or the insert * row of this rowset, but it does not update the database. * If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateByte(String columnName, byte x) throws SQLException { updateByte(getColIdxByName(columnName), x); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>short</code> value. * <P> * This method updates a column value in the current row or the insert * row of this rowset, but it does not update the database. * If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateShort(String columnName, short x) throws SQLException { updateShort(getColIdxByName(columnName), x); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>int</code> value. * <P> * This method updates a column value in the current row or the insert * row of this rowset, but it does not update the database. * If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateInt(String columnName, int x) throws SQLException { updateInt(getColIdxByName(columnName), x); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>long</code> value. * <P> * This method updates a column value in the current row or the insert * row of this rowset, but it does not update the database. * If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateLong(String columnName, long x) throws SQLException { updateLong(getColIdxByName(columnName), x); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>float</code> value. * <P> * This method updates a column value in the current row or the insert * row of this rowset, but it does not update the database. * If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateFloat(String columnName, float x) throws SQLException { updateFloat(getColIdxByName(columnName), x); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>double</code> value. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateDouble(String columnName, double x) throws SQLException { updateDouble(getColIdxByName(columnName), x); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>java.math.BigDecimal</code> object. * <P> * This method updates a column value in the current row or the insert * row of this rowset, but it does not update the database. * If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException { updateBigDecimal(getColIdxByName(columnName), x); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>String</code> object. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateString(String columnName, String x) throws SQLException { updateString(getColIdxByName(columnName), x); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>byte</code> array. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateBytes(String columnName, byte x[]) throws SQLException { updateBytes(getColIdxByName(columnName), x); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>Date</code> object. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, (3) the type * of the designated column is not an SQL <code>DATE</code> or * <code>TIMESTAMP</code>, or (4) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateDate(String columnName, java.sql.Date x) throws SQLException { updateDate(getColIdxByName(columnName), x); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>Time</code> object. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, (3) the type * of the designated column is not an SQL <code>TIME</code> or * <code>TIMESTAMP</code>, or (4) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateTime(String columnName, java.sql.Time x) throws SQLException { updateTime(getColIdxByName(columnName), x); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>Timestamp</code> object. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value * @throws SQLException if the given column index is out of bounds or * the cursor is not on one of this rowset's rows or its * insert row * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, (3) the type * of the designated column is not an SQL <code>DATE</code>, * <code>TIME</code>, or <code>TIMESTAMP</code>, or (4) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateTimestamp(String columnName, java.sql.Timestamp x) throws SQLException { updateTimestamp(getColIdxByName(columnName), x); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * ASCII stream value. * <P> * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value * @param length the number of one-byte ASCII characters in the stream */ public void updateAsciiStream(String columnName, java.io.InputStream x, int length) throws SQLException { updateAsciiStream(getColIdxByName(columnName), x, length); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>java.io.InputStream</code> object. * <P> * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value; must be a <code>java.io.InputStream</code> * containing <code>BINARY</code>, <code>VARBINARY</code>, or * <code>LONGVARBINARY</code> data * @param length the length of the stream in bytes * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, (3) the data * in the stream is not binary, or (4) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateBinaryStream(String columnName, java.io.InputStream x, int length) throws SQLException { updateBinaryStream(getColIdxByName(columnName), x, length); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>java.io.Reader</code> object. * <P> * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param reader the new column value; must be a * <code>java.io.Reader</code> containing <code>BINARY</code>, * <code>VARBINARY</code>, <code>LONGVARBINARY</code>, <code>CHAR</code>, * <code>VARCHAR</code>, or <code>LONGVARCHAR</code> data * @param length the length of the stream in characters * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, (3) the data * in the stream is not a binary or character type, or (4) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateCharacterStream(String columnName, java.io.Reader reader, int length) throws SQLException { updateCharacterStream(getColIdxByName(columnName), reader, length); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>Object</code> value. The <code>scale</code> parameter * indicates the number of digits to the right of the decimal point * and is ignored if the new column value is not a type that will be * mapped to an SQL <code>DECIMAL</code> or <code>NUMERIC</code> value. * <P> * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value * @param scale the number of digits to the right of the decimal point (for * <code>DECIMAL</code> and <code>NUMERIC</code> types only) * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateObject(String columnName, Object x, int scale) throws SQLException { updateObject(getColIdxByName(columnName), x, scale); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>Object</code> value. * <P> * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param x the new column value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateObject(String columnName, Object x) throws SQLException { updateObject(getColIdxByName(columnName), x); } /** * Inserts the contents of this <code>CachedRowSetImpl</code> object's insert * row into this rowset immediately following the current row. * If the current row is the * position after the last row or before the first row, the new row will * be inserted at the end of the rowset. This method also notifies * listeners registered with this rowset that the row has changed. * <P> * The cursor must be on the insert row when this method is called. * * @throws SQLException if (1) the cursor is not on the insert row, * (2) one or more of the non-nullable columns in the insert * row has not been given a value, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void insertRow() throws SQLException { int pos; if (onInsertRow == false || insertRow.isCompleteRow(RowSetMD) == false) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.failedins").toString()); } // Added the setting of parameters that are passed // to setXXX methods after an empty CRS Object is // created through RowSetMetaData object Object [] toInsert = getParams(); for(int i = 0;i < toInsert.length; i++) { insertRow.setColumnObject(i+1,toInsert[i]); } Row insRow = new Row(RowSetMD.getColumnCount(), insertRow.getOrigRow()); insRow.setInserted(); /* * The new row is inserted into the RowSet * immediately following the current row. * * If we are afterlast then the rows are * inserted at the end. */ if (currentRow >= numRows || currentRow < 0) { pos = numRows; } else { pos = currentRow; } rvh.add(pos, insRow); ++numRows; // notify the listeners that the row changed. notifyRowChanged(); } /** * Marks the current row of this <code>CachedRowSetImpl</code> object as * updated and notifies listeners registered with this rowset that the * row has changed. * <P> * This method cannot be called when the cursor is on the insert row, and * it should be called before the cursor moves to another row. If it is * called after the cursor moves to another row, this method has no effect, * and the updates made before the cursor moved will be lost. * * @throws SQLException if the cursor is on the insert row or this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateRow() throws SQLException { // make sure we aren't on the insert row if (onInsertRow == true) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.updateins").toString()); } ((Row)getCurrentRow()).setUpdated(); // notify the listeners that the row changed. notifyRowChanged(); } /** * Deletes the current row from this <code>CachedRowSetImpl</code> object and * notifies listeners registered with this rowset that a row has changed. * This method cannot be called when the cursor is on the insert row. * <P> * This method marks the current row as deleted, but it does not delete * the row from the underlying data source. The method * <code>acceptChanges</code> must be called to delete the row in * the data source. * * @throws SQLException if (1) this method is called when the cursor * is on the insert row, before the first row, or after the * last row or (2) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void deleteRow() throws SQLException { // make sure the cursor is on a valid row checkCursor(); ((Row)getCurrentRow()).setDeleted(); ++numDeleted; // notify the listeners that the row changed. notifyRowChanged(); } /** * Sets the current row with its original value and marks the row as * not updated, thus undoing any changes made to the row since the * last call to the methods <code>updateRow</code> or <code>deleteRow</code>. * This method should be called only when the cursor is on a row in * this rowset. * * @throws SQLException if the cursor is on the insert row, before the * first row, or after the last row */ public void refreshRow() throws SQLException { // make sure we are on a row checkCursor(); // don't want this to happen... if (onInsertRow == true) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcp").toString()); } Row currentRow = (Row)getCurrentRow(); // just undo any changes made to this row. currentRow.clearUpdated(); } /** * Rolls back any updates made to the current row of this * <code>CachedRowSetImpl</code> object and notifies listeners that * a row has changed. To have an effect, this method * must be called after an <code>updateXXX</code> method has been * called and before the method <code>updateRow</code> has been called. * If no updates have been made or the method <code>updateRow</code> * has already been called, this method has no effect. * * @throws SQLException if the cursor is on the insert row, before the * first row, or after the last row */ public void cancelRowUpdates() throws SQLException { // make sure we are on a row checkCursor(); // don't want this to happen... if (onInsertRow == true) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcp").toString()); } Row currentRow = (Row)getCurrentRow(); if (currentRow.getUpdated() == true) { currentRow.clearUpdated(); notifyRowChanged(); } } /** * Moves the cursor for this <code>CachedRowSetImpl</code> object * to the insert row. The current row in the rowset is remembered * while the cursor is on the insert row. * <P> * The insert row is a special row associated with an updatable * rowset. It is essentially a buffer where a new row may * be constructed by calling the appropriate <code>updateXXX</code> * methods to assign a value to each column in the row. A complete * row must be constructed; that is, every column that is not nullable * must be assigned a value. In order for the new row to become part * of this rowset, the method <code>insertRow</code> must be called * before the cursor is moved back to the rowset. * <P> * Only certain methods may be invoked while the cursor is on the insert * row; many methods throw an exception if they are called while the * cursor is there. In addition to the <code>updateXXX</code> * and <code>insertRow</code> methods, only the <code>getXXX</code> methods * may be called when the cursor is on the insert row. A <code>getXXX</code> * method should be called on a column only after an <code>updateXXX</code> * method has been called on that column; otherwise, the value returned is * undetermined. * * @throws SQLException if this <code>CachedRowSetImpl</code> object is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void moveToInsertRow() throws SQLException { if (getConcurrency() == ResultSet.CONCUR_READ_ONLY) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.movetoins").toString()); } if (insertRow == null) { if (RowSetMD == null) throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.movetoins1").toString()); int numCols = RowSetMD.getColumnCount(); if (numCols > 0) { insertRow = new InsertRow(numCols); } else { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.movetoins2").toString()); } } onInsertRow = true; // %%% setCurrentRow called in BaseRow currentRow = cursorPos; cursorPos = -1; insertRow.initInsertRow(); } /** * Moves the cursor for this <code>CachedRowSetImpl</code> object to * the current row. The current row is the row the cursor was on * when the method <code>moveToInsertRow</code> was called. * <P> * Calling this method has no effect unless it is called while the * cursor is on the insert row. * * @throws SQLException if an error occurs */ public void moveToCurrentRow() throws SQLException { if (onInsertRow == false) { return; } else { cursorPos = currentRow; onInsertRow = false; } } /** * Returns <code>null</code>. * * @return <code>null</code> * @throws SQLException if an error occurs */ public Statement getStatement() throws SQLException { return null; } /** * Retrieves the value of the designated column in this * <code>CachedRowSetImpl</code> object as an <code>Object</code> in * the Java programming language, using the given * <code>java.util.Map</code> object to custom map the value if * appropriate. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param map a <code>java.util.Map</code> object showing the mapping * from SQL type names to classes in the Java programming * language * @return an <code>Object</code> representing the SQL value * @throws SQLException if the given column index is out of bounds or * the cursor is not on one of this rowset's rows or its * insert row */ public Object getObject(int columnIndex, java.util.Map<String,Class<?>> map) throws SQLException { Object value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return null; } if (value instanceof Struct) { Struct s = (Struct)value; // look up the class in the map Class<?> c = map.get(s.getSQLTypeName()); if (c != null) { // create new instance of the class SQLData obj = null; try { ReflectUtil.checkPackageAccess(c); @SuppressWarnings("deprecation") Object tmp = c.newInstance(); obj = (SQLData) tmp; } catch(Exception ex) { throw new SQLException("Unable to Instantiate: ", ex); } // get the attributes from the struct Object attribs[] = s.getAttributes(map); // create the SQLInput "stream" SQLInputImpl sqlInput = new SQLInputImpl(attribs, map); // read the values... obj.readSQL(sqlInput, s.getSQLTypeName()); return (Object)obj; } } return value; } /** * Retrieves the value of the designated column in this * <code>CachedRowSetImpl</code> object as a <code>Ref</code> object * in the Java programming language. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @return a <code>Ref</code> object representing an SQL<code> REF</code> value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>REF</code> value * @see #getRef(String) */ public Ref getRef(int columnIndex) throws SQLException { Ref value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); if (RowSetMD.getColumnType(columnIndex) != java.sql.Types.REF) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } setLastValueNull(false); value = (Ref)(getCurrentRow().getColumnObject(columnIndex)); // check for SQL NULL if (value == null) { setLastValueNull(true); return null; } return value; } /** * Retrieves the value of the designated column in this * <code>CachedRowSetImpl</code> object as a <code>Blob</code> object * in the Java programming language. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @return a <code>Blob</code> object representing an SQL <code>BLOB</code> value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>BLOB</code> value * @see #getBlob(String) */ public Blob getBlob(int columnIndex) throws SQLException { Blob value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); if (RowSetMD.getColumnType(columnIndex) != java.sql.Types.BLOB) { System.out.println(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.type").toString(), RowSetMD.getColumnType(columnIndex))); throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } setLastValueNull(false); value = (Blob)(getCurrentRow().getColumnObject(columnIndex)); // check for SQL NULL if (value == null) { setLastValueNull(true); return null; } return value; } /** * Retrieves the value of the designated column in this * <code>CachedRowSetImpl</code> object as a <code>Clob</code> object * in the Java programming language. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @return a <code>Clob</code> object representing an SQL <code>CLOB</code> value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>CLOB</code> value * @see #getClob(String) */ public Clob getClob(int columnIndex) throws SQLException { Clob value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); if (RowSetMD.getColumnType(columnIndex) != java.sql.Types.CLOB) { System.out.println(MessageFormat.format(resBundle.handleGetObject("cachedrowsetimpl.type").toString(), RowSetMD.getColumnType(columnIndex))); throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } setLastValueNull(false); value = (Clob)(getCurrentRow().getColumnObject(columnIndex)); // check for SQL NULL if (value == null) { setLastValueNull(true); return null; } return value; } /** * Retrieves the value of the designated column in this * <code>CachedRowSetImpl</code> object as an <code>Array</code> object * in the Java programming language. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @return an <code>Array</code> object representing an SQL * <code>ARRAY</code> value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>ARRAY</code> value * @see #getArray(String) */ public Array getArray(int columnIndex) throws SQLException { java.sql.Array value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); if (RowSetMD.getColumnType(columnIndex) != java.sql.Types.ARRAY) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } setLastValueNull(false); value = (java.sql.Array)(getCurrentRow().getColumnObject(columnIndex)); // check for SQL NULL if (value == null) { setLastValueNull(true); return null; } return value; } /** * Retrieves the value of the designated column in this * <code>CachedRowSetImpl</code> object as an <code>Object</code> in * the Java programming language, using the given * <code>java.util.Map</code> object to custom map the value if * appropriate. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param map a <code>java.util.Map</code> object showing the mapping * from SQL type names to classes in the Java programming * language * @return an <code>Object</code> representing the SQL value * @throws SQLException if the given column name is not the name of * a column in this rowset or the cursor is not on one of * this rowset's rows or its insert row */ public Object getObject(String columnName, java.util.Map<String,Class<?>> map) throws SQLException { return getObject(getColIdxByName(columnName), map); } /** * Retrieves the value of the designated column in this * <code>CachedRowSetImpl</code> object as a <code>Ref</code> object * in the Java programming language. * * @param colName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @return a <code>Ref</code> object representing an SQL<code> REF</code> value * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the column value * is not an SQL <code>REF</code> value * @see #getRef(int) */ public Ref getRef(String colName) throws SQLException { return getRef(getColIdxByName(colName)); } /** * Retrieves the value of the designated column in this * <code>CachedRowSetImpl</code> object as a <code>Blob</code> object * in the Java programming language. * * @param colName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @return a <code>Blob</code> object representing an SQL <code>BLOB</code> value * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>BLOB</code> value * @see #getBlob(int) */ public Blob getBlob(String colName) throws SQLException { return getBlob(getColIdxByName(colName)); } /** * Retrieves the value of the designated column in this * <code>CachedRowSetImpl</code> object as a <code>Clob</code> object * in the Java programming language. * * @param colName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @return a <code>Clob</code> object representing an SQL * <code>CLOB</code> value * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>CLOB</code> value * @see #getClob(int) */ public Clob getClob(String colName) throws SQLException { return getClob(getColIdxByName(colName)); } /** * Retrieves the value of the designated column in this * <code>CachedRowSetImpl</code> object as an <code>Array</code> object * in the Java programming langugage. * * @param colName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @return an <code>Array</code> object representing an SQL * <code>ARRAY</code> value * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>ARRAY</code> value * @see #getArray(int) */ public Array getArray(String colName) throws SQLException { return getArray(getColIdxByName(colName)); } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Date</code> * object, using the given <code>Calendar</code> object to construct an * appropriate millisecond value for the date. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @param cal the <code>java.util.Calendar</code> object to use in * constructing the date * @return the column value; if the value is SQL <code>NULL</code>, * the result is <code>null</code> * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>DATE</code> or * <code>TIMESTAMP</code> value */ public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLException { Object value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return null; } value = convertTemporal(value, RowSetMD.getColumnType(columnIndex), java.sql.Types.DATE); // create a default calendar Calendar defaultCal = Calendar.getInstance(); // set this Calendar to the time we have defaultCal.setTime((java.util.Date)value); /* * Now we can pull the pieces of the date out * of the default calendar and put them into * the user provided calendar */ cal.set(Calendar.YEAR, defaultCal.get(Calendar.YEAR)); cal.set(Calendar.MONTH, defaultCal.get(Calendar.MONTH)); cal.set(Calendar.DAY_OF_MONTH, defaultCal.get(Calendar.DAY_OF_MONTH)); /* * This looks a little odd but it is correct - * Calendar.getTime() returns a Date... */ return new java.sql.Date(cal.getTime().getTime()); } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Date</code> * object, using the given <code>Calendar</code> object to construct an * appropriate millisecond value for the date. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param cal the <code>java.util.Calendar</code> object to use in * constructing the date * @return the column value; if the value is SQL <code>NULL</code>, * the result is <code>null</code> * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>DATE</code> or * <code>TIMESTAMP</code> value */ public java.sql.Date getDate(String columnName, Calendar cal) throws SQLException { return getDate(getColIdxByName(columnName), cal); } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Time</code> * object, using the given <code>Calendar</code> object to construct an * appropriate millisecond value for the date. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @param cal the <code>java.util.Calendar</code> object to use in * constructing the date * @return the column value; if the value is SQL <code>NULL</code>, * the result is <code>null</code> * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>TIME</code> or * <code>TIMESTAMP</code> value */ public java.sql.Time getTime(int columnIndex, Calendar cal) throws SQLException { Object value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return null; } value = convertTemporal(value, RowSetMD.getColumnType(columnIndex), java.sql.Types.TIME); // create a default calendar Calendar defaultCal = Calendar.getInstance(); // set the time in the default calendar defaultCal.setTime((java.util.Date)value); /* * Now we can pull the pieces of the date out * of the default calendar and put them into * the user provided calendar */ cal.set(Calendar.HOUR_OF_DAY, defaultCal.get(Calendar.HOUR_OF_DAY)); cal.set(Calendar.MINUTE, defaultCal.get(Calendar.MINUTE)); cal.set(Calendar.SECOND, defaultCal.get(Calendar.SECOND)); return new java.sql.Time(cal.getTime().getTime()); } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Time</code> * object, using the given <code>Calendar</code> object to construct an * appropriate millisecond value for the date. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param cal the <code>java.util.Calendar</code> object to use in * constructing the date * @return the column value; if the value is SQL <code>NULL</code>, * the result is <code>null</code> * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>TIME</code> or * <code>TIMESTAMP</code> value */ public java.sql.Time getTime(String columnName, Calendar cal) throws SQLException { return getTime(getColIdxByName(columnName), cal); } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a <code>java.sql.Timestamp</code> * object, using the given <code>Calendar</code> object to construct an * appropriate millisecond value for the date. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in the rowset * @param cal the <code>java.util.Calendar</code> object to use in * constructing the date * @return the column value; if the value is SQL <code>NULL</code>, * the result is <code>null</code> * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>TIME</code> or * <code>TIMESTAMP</code> value */ public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException { Object value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); setLastValueNull(false); value = getCurrentRow().getColumnObject(columnIndex); // check for SQL NULL if (value == null) { setLastValueNull(true); return null; } value = convertTemporal(value, RowSetMD.getColumnType(columnIndex), java.sql.Types.TIMESTAMP); // create a default calendar Calendar defaultCal = Calendar.getInstance(); // set the time in the default calendar defaultCal.setTime((java.util.Date)value); /* * Now we can pull the pieces of the date out * of the default calendar and put them into * the user provided calendar */ cal.set(Calendar.YEAR, defaultCal.get(Calendar.YEAR)); cal.set(Calendar.MONTH, defaultCal.get(Calendar.MONTH)); cal.set(Calendar.DAY_OF_MONTH, defaultCal.get(Calendar.DAY_OF_MONTH)); cal.set(Calendar.HOUR_OF_DAY, defaultCal.get(Calendar.HOUR_OF_DAY)); cal.set(Calendar.MINUTE, defaultCal.get(Calendar.MINUTE)); cal.set(Calendar.SECOND, defaultCal.get(Calendar.SECOND)); return new java.sql.Timestamp(cal.getTime().getTime()); } /** * Retrieves the value of the designated column in the current row * of this <code>CachedRowSetImpl</code> object as a * <code>java.sql.Timestamp</code> object, using the given * <code>Calendar</code> object to construct an appropriate * millisecond value for the date. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param cal the <code>java.util.Calendar</code> object to use in * constructing the date * @return the column value; if the value is SQL <code>NULL</code>, * the result is <code>null</code> * @throws SQLException if (1) the given column name is not the name of * a column in this rowset, (2) the cursor is not on one of * this rowset's rows or its insert row, or (3) the designated * column does not store an SQL <code>DATE</code>, * <code>TIME</code>, or <code>TIMESTAMP</code> value */ public java.sql.Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException { return getTimestamp(getColIdxByName(columnName), cal); } /* * RowSetInternal Interface */ /** * Retrieves the <code>Connection</code> object passed to this * <code>CachedRowSetImpl</code> object. This connection may be * used to populate this rowset with data or to write data back * to its underlying data source. * * @return the <code>Connection</code> object passed to this rowset; * may be <code>null</code> if there is no connection * @throws SQLException if an error occurs */ public Connection getConnection() throws SQLException{ return conn; } /** * Sets the metadata for this <code>CachedRowSetImpl</code> object * with the given <code>RowSetMetaData</code> object. * * @param md a <code>RowSetMetaData</code> object instance containing * metadata about the columsn in the rowset * @throws SQLException if invalid meta data is supplied to the * rowset */ public void setMetaData(RowSetMetaData md) throws SQLException { RowSetMD =(RowSetMetaDataImpl) md; } /** * Returns a result set containing the original value of the rowset. The * original value is the state of the <code>CachedRowSetImpl</code> after the * last population or synchronization (whichever occurred most recently) with * the data source. * <p> * The cursor is positioned before the first row in the result set. * Only rows contained in the result set returned by <code>getOriginal()</code> * are said to have an original value. * * @return the original result set of the rowset * @throws SQLException if an error occurs produce the * <code>ResultSet</code> object */ public ResultSet getOriginal() throws SQLException { CachedRowSetImpl crs = new CachedRowSetImpl(); crs.RowSetMD = RowSetMD; crs.numRows = numRows; crs.cursorPos = 0; // make sure we don't get someone playing with these // %%% is this now necessary ??? //crs.setReader(null); //crs.setWriter(null); int colCount = RowSetMD.getColumnCount(); Row orig; for (Iterator<?> i = rvh.iterator(); i.hasNext();) { orig = new Row(colCount, ((Row)i.next()).getOrigRow()); crs.rvh.add(orig); } return (ResultSet)crs; } /** * Returns a result set containing the original value of the current * row only. * The original value is the state of the <code>CachedRowSetImpl</code> after * the last population or synchronization (whichever occurred most recently) * with the data source. * * @return the original result set of the row * @throws SQLException if there is no current row * @see #setOriginalRow */ public ResultSet getOriginalRow() throws SQLException { CachedRowSetImpl crs = new CachedRowSetImpl(); crs.RowSetMD = RowSetMD; crs.numRows = 1; crs.cursorPos = 0; crs.setTypeMap(this.getTypeMap()); // make sure we don't get someone playing with these // %%% is this now necessary ??? //crs.setReader(null); //crs.setWriter(null); Row orig = new Row(RowSetMD.getColumnCount(), getCurrentRow().getOrigRow()); crs.rvh.add(orig); return (ResultSet)crs; } /** * Marks the current row in this rowset as being an original row. * * @throws SQLException if there is no current row * @see #getOriginalRow */ public void setOriginalRow() throws SQLException { if (onInsertRow == true) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidop").toString()); } Row row = (Row)getCurrentRow(); makeRowOriginal(row); // this can happen if deleted rows are being shown if (row.getDeleted() == true) { removeCurrentRow(); } } /** * Makes the given row of this rowset the original row by clearing any * settings that mark the row as having been inserted, deleted, or updated. * This method is called internally by the methods * <code>setOriginalRow</code> * and <code>setOriginal</code>. * * @param row the row to be made the original row */ private void makeRowOriginal(Row row) { if (row.getInserted() == true) { row.clearInserted(); } if (row.getUpdated() == true) { row.moveCurrentToOrig(); } } /** * Marks all rows in this rowset as being original rows. Any updates * made to the rows become the original values for the rowset. * Calls to the method <code>setOriginal</code> connot be reversed. * * @throws SQLException if an error occurs */ public void setOriginal() throws SQLException { for (Iterator<?> i = rvh.iterator(); i.hasNext();) { Row row = (Row)i.next(); makeRowOriginal(row); // remove deleted rows from the collection. if (row.getDeleted() == true) { i.remove(); --numRows; } } numDeleted = 0; // notify any listeners that the rowset has changed notifyRowSetChanged(); } /** * Returns an identifier for the object (table) that was used to create this * rowset. * * @return a <code>String</code> object that identifies the table from * which this <code>CachedRowSetImpl</code> object was derived * @throws SQLException if an error occurs */ public String getTableName() throws SQLException { return tableName; } /** * Sets the identifier for the table from which this rowset was derived * to the given table name. * * @param tabName a <code>String</code> object that identifies the * table from which this <code>CachedRowSetImpl</code> object * was derived * @throws SQLException if an error occurs */ public void setTableName(String tabName) throws SQLException { if (tabName == null) throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.tablename").toString()); else tableName = tabName; } /** * Returns the columns that make a key to uniquely identify a * row in this <code>CachedRowSetImpl</code> object. * * @return an array of column numbers that constitutes a primary * key for this rowset. This array should be empty * if no column is representitive of a primary key * @throws SQLException if the rowset is empty or no columns * are designated as primary keys * @see #setKeyColumns */ public int[] getKeyColumns() throws SQLException { int[]keyColumns = this.keyCols; return (keyColumns == null) ? null : Arrays.copyOf(keyColumns, keyColumns.length); } /** * Sets this <code>CachedRowSetImpl</code> object's * <code>keyCols</code> field with the given array of column * numbers, which forms a key for uniquely identifying a row * in this rowset. * * @param keys an array of <code>int</code> indicating the * columns that form a primary key for this * <code>CachedRowSetImpl</code> object; every * element in the array must be greater than * <code>0</code> and less than or equal to the number * of columns in this rowset * @throws SQLException if any of the numbers in the * given array is not valid for this rowset * @see #getKeyColumns */ public void setKeyColumns(int [] keys) throws SQLException { int numCols = 0; if (RowSetMD != null) { numCols = RowSetMD.getColumnCount(); if (keys.length > numCols) throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.keycols").toString()); } keyCols = new int[keys.length]; for (int i = 0; i < keys.length; i++) { if (RowSetMD != null && (keys[i] <= 0 || keys[i] > numCols)) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidcol").toString() + keys[i]); } keyCols[i] = keys[i]; } } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>Ref</code> value. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param ref the new column <code>java.sql.Ref</code> value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateRef(int columnIndex, java.sql.Ref ref) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); // SerialClob will help in getting the byte array and storing it. // We need to be checking DatabaseMetaData.locatorsUpdatorCopy() // or through RowSetMetaData.locatorsUpdatorCopy() getCurrentRow().setColumnObject(columnIndex, new SerialRef(ref)); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>double</code> value. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param ref the new column <code>java.sql.Ref</code> value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateRef(String columnName, java.sql.Ref ref) throws SQLException { updateRef(getColIdxByName(columnName), ref); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>double</code> value. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param c the new column <code>Clob</code> value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateClob(int columnIndex, Clob c) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); // SerialClob will help in getting the byte array and storing it. // We need to be checking DatabaseMetaData.locatorsUpdatorCopy() // or through RowSetMetaData.locatorsUpdatorCopy() if(dbmslocatorsUpdateCopy){ getCurrentRow().setColumnObject(columnIndex, new SerialClob(c)); } else{ throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.opnotsupp").toString()); } } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>double</code> value. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param c the new column <code>Clob</code> value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateClob(String columnName, Clob c) throws SQLException { updateClob(getColIdxByName(columnName), c); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>java.sql.Blob</code> value. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param b the new column <code>Blob</code> value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateBlob(int columnIndex, Blob b) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); // SerialBlob will help in getting the byte array and storing it. // We need to be checking DatabaseMetaData.locatorsUpdatorCopy() // or through RowSetMetaData.locatorsUpdatorCopy() if(dbmslocatorsUpdateCopy){ getCurrentRow().setColumnObject(columnIndex, new SerialBlob(b)); } else{ throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.opnotsupp").toString()); } } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>java.sql.Blob </code> value. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param b the new column <code>Blob</code> value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateBlob(String columnName, Blob b) throws SQLException { updateBlob(getColIdxByName(columnName), b); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>java.sql.Array</code> values. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnIndex the first column is <code>1</code>, the second * is <code>2</code>, and so on; must be <code>1</code> or larger * and equal to or less than the number of columns in this rowset * @param a the new column <code>Array</code> value * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) this rowset is * <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateArray(int columnIndex, Array a) throws SQLException { // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); // SerialArray will help in getting the byte array and storing it. // We need to be checking DatabaseMetaData.locatorsUpdatorCopy() // or through RowSetMetaData.locatorsUpdatorCopy() getCurrentRow().setColumnObject(columnIndex, new SerialArray(a)); } /** * Sets the designated column in either the current row or the insert * row of this <code>CachedRowSetImpl</code> object with the given * <code>java.sql.Array</code> value. * * This method updates a column value in either the current row or * the insert row of this rowset, but it does not update the * database. If the cursor is on a row in the rowset, the * method {@link #updateRow} must be called to update the database. * If the cursor is on the insert row, the method {@link #insertRow} * must be called, which will insert the new row into both this rowset * and the database. Both of these methods must be called before the * cursor moves to another row. * * @param columnName a <code>String</code> object that must match the * SQL name of a column in this rowset, ignoring case * @param a the new column <code>Array</code> value * @throws SQLException if (1) the given column name does not match the * name of a column in this rowset, (2) the cursor is not on * one of this rowset's rows or its insert row, or (3) this * rowset is <code>ResultSet.CONCUR_READ_ONLY</code> */ public void updateArray(String columnName, Array a) throws SQLException { updateArray(getColIdxByName(columnName), a); } /** * Retrieves the value of the designated column in this * <code>CachedRowSetImpl</code> object as a <code>java.net.URL</code> object * in the Java programming language. * * @return a java.net.URL object containing the resource reference described by * the URL * @throws SQLException if (1) the given column index is out of bounds, * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>DATALINK</code> value. * @see #getURL(String) */ public java.net.URL getURL(int columnIndex) throws SQLException { //throw new SQLException("Operation not supported"); java.net.URL value; // sanity check. checkIndex(columnIndex); // make sure the cursor is on a valid row checkCursor(); if (RowSetMD.getColumnType(columnIndex) != java.sql.Types.DATALINK) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString()); } setLastValueNull(false); value = (java.net.URL)(getCurrentRow().getColumnObject(columnIndex)); // check for SQL NULL if (value == null) { setLastValueNull(true); return null; } return value; } /** * Retrieves the value of the designated column in this * <code>CachedRowSetImpl</code> object as a <code>java.net.URL</code> object * in the Java programming language. * * @return a java.net.URL object containing the resource reference described by * the URL * @throws SQLException if (1) the given column name not the name of a column * in this rowset, or * (2) the cursor is not on one of this rowset's rows or its * insert row, or (3) the designated column does not store an * SQL <code>DATALINK</code> value. * @see #getURL(int) */ public java.net.URL getURL(String columnName) throws SQLException { return getURL(getColIdxByName(columnName)); } /** * The first warning reported by calls on this <code>CachedRowSetImpl</code> * object is returned. Subsequent <code>CachedRowSetImpl</code> warnings will * be chained to this <code>SQLWarning</code>. All <code>RowSetWarnings</code> * warnings are generated in the disconnected environment and remain a * seperate warning chain to that provided by the <code>getWarnings</code> * method. * * <P>The warning chain is automatically cleared each time a new * row is read. * * <P><B>Note:</B> This warning chain only covers warnings caused * by <code>CachedRowSet</code> (and their child interface) * methods. All <code>SQLWarnings</code> can be obtained using the * <code>getWarnings</code> method which tracks warnings generated * by the underlying JDBC driver. * @return the first SQLWarning or null * */ public RowSetWarning getRowSetWarnings() { try { notifyCursorMoved(); } catch (SQLException e) {} // mask exception return rowsetWarning; } /** * The function tries to isolate the tablename when only setCommand * is set and not setTablename is called provided there is only one table * name in the query else just leaves the setting of table name as such. * If setTablename is set later it will over ride this table name * value so retrieved. * * @return the tablename if only one table in query else return "" */ private String buildTableName(String command) throws SQLException { // If we have a query from one table, // we set the table name implicitly // else user has to explicitly set the table name. int indexFrom, indexComma; String strTablename =""; command = command.trim(); // Query can be a select, insert or update if(command.toLowerCase().startsWith("select")) { // look for "from" keyword, after that look for a // comma after from. If comma is there don't set // table name else isolate table name. indexFrom = command.toLowerCase().indexOf("from"); indexComma = command.indexOf(',', indexFrom); if(indexComma == -1) { // implies only one table strTablename = (command.substring(indexFrom+"from".length(),command.length())).trim(); String tabName = strTablename; int idxWhere = tabName.toLowerCase().indexOf("where"); /** * Adding the addtional check for conditions following the table name. * If a condition is found truncate it. **/ if(idxWhere != -1) { tabName = tabName.substring(0,idxWhere).trim(); } strTablename = tabName; } else { //strTablename=""; } } else if(command.toLowerCase().startsWith("insert")) { //strTablename=""; } else if(command.toLowerCase().startsWith("update")) { //strTablename=""; } return strTablename; } /** * Commits all changes performed by the <code>acceptChanges()</code> * methods * * @see java.sql.Connection#commit */ public void commit() throws SQLException { conn.commit(); } /** * Rolls back all changes performed by the <code>acceptChanges()</code> * methods * * @see java.sql.Connection#rollback */ public void rollback() throws SQLException { conn.rollback(); } /** * Rolls back all changes performed by the <code>acceptChanges()</code> * to the last <code>Savepoint</code> transaction marker. * * @see java.sql.Connection#rollback(Savepoint) */ public void rollback(Savepoint s) throws SQLException { conn.rollback(s); } /** * Unsets the designated parameter to the given int array. * This was set using <code>setMatchColumn</code> * as the column which will form the basis of the join. * <P> * The parameter value unset by this method should be same * as was set. * * @param columnIdxes the index into this rowset * object's internal representation of parameter values * @throws SQLException if an error occurs or the * parameter index is out of bounds or if the columnIdx is * not the same as set using <code>setMatchColumn(int [])</code> */ public void unsetMatchColumn(int[] columnIdxes) throws SQLException { int i_val; for( int j= 0 ;j < columnIdxes.length; j++) { i_val = (Integer.parseInt(iMatchColumns.get(j).toString())); if(columnIdxes[j] != i_val) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.matchcols").toString()); } } for( int i = 0;i < columnIdxes.length ;i++) { iMatchColumns.set(i, -1); } } /** * Unsets the designated parameter to the given String array. * This was set using <code>setMatchColumn</code> * as the column which will form the basis of the join. * <P> * The parameter value unset by this method should be same * as was set. * * @param columnIdxes the index into this rowset * object's internal representation of parameter values * @throws SQLException if an error occurs or the * parameter index is out of bounds or if the columnName is * not the same as set using <code>setMatchColumn(String [])</code> */ public void unsetMatchColumn(String[] columnIdxes) throws SQLException { for(int j = 0 ;j < columnIdxes.length; j++) { if( !columnIdxes[j].equals(strMatchColumns.get(j)) ){ throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.matchcols").toString()); } } for(int i = 0 ; i < columnIdxes.length; i++) { strMatchColumns.set(i,null); } } /** * Retrieves the column name as <code>String</code> array * that was set using <code>setMatchColumn(String [])</code> * for this rowset. * * @return a <code>String</code> array object that contains the column names * for the rowset which has this the match columns * * @throws SQLException if an error occurs or column name is not set */ public String[] getMatchColumnNames() throws SQLException { String []str_temp = new String[strMatchColumns.size()]; if( strMatchColumns.get(0) == null) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.setmatchcols").toString()); } strMatchColumns.copyInto(str_temp); return str_temp; } /** * Retrieves the column id as <code>int</code> array that was set using * <code>setMatchColumn(int [])</code> for this rowset. * * @return a <code>int</code> array object that contains the column ids * for the rowset which has this as the match columns. * * @throws SQLException if an error occurs or column index is not set */ public int[] getMatchColumnIndexes() throws SQLException { Integer []int_temp = new Integer[iMatchColumns.size()]; int [] i_temp = new int[iMatchColumns.size()]; int i_val; i_val = iMatchColumns.get(0); if( i_val == -1 ) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.setmatchcols").toString()); } iMatchColumns.copyInto(int_temp); for(int i = 0; i < int_temp.length; i++) { i_temp[i] = (int_temp[i]).intValue(); } return i_temp; } /** * Sets the designated parameter to the given int array. * This forms the basis of the join for the * <code>JoinRowSet</code> as the column which will form the basis of the * join. * <P> * The parameter value set by this method is stored internally and * will be supplied as the appropriate parameter in this rowset's * command when the method <code>getMatchColumnIndexes</code> is called. * * @param columnIdxes the indexes into this rowset * object's internal representation of parameter values; the * first parameter is 0, the second is 1, and so on; must be * <code>0</code> or greater * @throws SQLException if an error occurs or the * parameter index is out of bounds */ public void setMatchColumn(int[] columnIdxes) throws SQLException { for(int j = 0 ; j < columnIdxes.length; j++) { if( columnIdxes[j] < 0 ) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.matchcols1").toString()); } } for(int i = 0 ;i < columnIdxes.length; i++) { iMatchColumns.add(i,columnIdxes[i]); } } /** * Sets the designated parameter to the given String array. * This forms the basis of the join for the * <code>JoinRowSet</code> as the column which will form the basis of the * join. * <P> * The parameter value set by this method is stored internally and * will be supplied as the appropriate parameter in this rowset's * command when the method <code>getMatchColumn</code> is called. * * @param columnNames the name of the column into this rowset * object's internal representation of parameter values * @throws SQLException if an error occurs or the * parameter index is out of bounds */ public void setMatchColumn(String[] columnNames) throws SQLException { for(int j = 0; j < columnNames.length; j++) { if( columnNames[j] == null || columnNames[j].equals("")) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.matchcols2").toString()); } } for( int i = 0; i < columnNames.length; i++) { strMatchColumns.add(i,columnNames[i]); } } /** * Sets the designated parameter to the given <code>int</code> * object. This forms the basis of the join for the * <code>JoinRowSet</code> as the column which will form the basis of the * join. * <P> * The parameter value set by this method is stored internally and * will be supplied as the appropriate parameter in this rowset's * command when the method <code>getMatchColumn</code> is called. * * @param columnIdx the index into this rowset * object's internal representation of parameter values; the * first parameter is 0, the second is 1, and so on; must be * <code>0</code> or greater * @throws SQLException if an error occurs or the * parameter index is out of bounds */ public void setMatchColumn(int columnIdx) throws SQLException { // validate, if col is ok to be set if(columnIdx < 0) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.matchcols1").toString()); } else { // set iMatchColumn iMatchColumns.set(0, columnIdx); //strMatchColumn = null; } } /** * Sets the designated parameter to the given <code>String</code> * object. This forms the basis of the join for the * <code>JoinRowSet</code> as the column which will form the basis of the * join. * <P> * The parameter value set by this method is stored internally and * will be supplied as the appropriate parameter in this rowset's * command when the method <code>getMatchColumn</code> is called. * * @param columnName the name of the column into this rowset * object's internal representation of parameter values * @throws SQLException if an error occurs or the * parameter index is out of bounds */ public void setMatchColumn(String columnName) throws SQLException { // validate, if col is ok to be set if(columnName == null || (columnName= columnName.trim()).equals("") ) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.matchcols2").toString()); } else { // set strMatchColumn strMatchColumns.set(0, columnName); //iMatchColumn = -1; } } /** * Unsets the designated parameter to the given <code>int</code> * object. This was set using <code>setMatchColumn</code> * as the column which will form the basis of the join. * <P> * The parameter value unset by this method should be same * as was set. * * @param columnIdx the index into this rowset * object's internal representation of parameter values * @throws SQLException if an error occurs or the * parameter index is out of bounds or if the columnIdx is * not the same as set using <code>setMatchColumn(int)</code> */ public void unsetMatchColumn(int columnIdx) throws SQLException { // check if we are unsetting the SAME column if(! iMatchColumns.get(0).equals(Integer.valueOf(columnIdx) ) ) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.unsetmatch").toString()); } else if(strMatchColumns.get(0) != null) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.unsetmatch1").toString()); } else { // that is, we are unsetting it. iMatchColumns.set(0, -1); } } /** * Unsets the designated parameter to the given <code>String</code> * object. This was set using <code>setMatchColumn</code> * as the column which will form the basis of the join. * <P> * The parameter value unset by this method should be same * as was set. * * @param columnName the index into this rowset * object's internal representation of parameter values * @throws SQLException if an error occurs or the * parameter index is out of bounds or if the columnName is * not the same as set using <code>setMatchColumn(String)</code> */ public void unsetMatchColumn(String columnName) throws SQLException { // check if we are unsetting the same column columnName = columnName.trim(); if(!((strMatchColumns.get(0)).equals(columnName))) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.unsetmatch").toString()); } else if(iMatchColumns.get(0) > 0) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.unsetmatch2").toString()); } else { strMatchColumns.set(0, null); // that is, we are unsetting it. } } /** * Notifies registered listeners that a RowSet object in the given RowSetEvent * object has populated a number of additional rows. The <code>numRows</code> parameter * ensures that this event will only be fired every <code>numRow</code>. * <p> * The source of the event can be retrieved with the method event.getSource. * * @param event a <code>RowSetEvent</code> object that contains the * <code>RowSet</code> object that is the source of the events * @param numRows when populating, the number of rows interval on which the * <code>CachedRowSet</code> populated should fire; the default value * is zero; cannot be less than <code>fetchSize</code> or zero */ public void rowSetPopulated(RowSetEvent event, int numRows) throws SQLException { if( numRows < 0 || numRows < getFetchSize()) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.numrows").toString()); } if(size() % numRows == 0) { RowSetEvent event_temp = new RowSetEvent(this); event = event_temp; notifyRowSetChanged(); } } /** * Populates this <code>CachedRowSet</code> object with data from * the given <code>ResultSet</code> object. While related to the <code>populate(ResultSet)</code> * method, an additional parameter is provided to allow starting position within * the <code>ResultSet</code> from where to populate the CachedRowSet * instance. * * This method is an alternative to the method <code>execute</code> * for filling the rowset with data. The method <code>populate</code> * does not require that the properties needed by the method * <code>execute</code>, such as the <code>command</code> property, * be set. This is true because the method <code>populate</code> * is given the <code>ResultSet</code> object from * which to get data and thus does not need to use the properties * required for setting up a connection and executing this * <code>CachedRowSetImpl</code> object's command. * <P> * After populating this rowset with data, the method * <code>populate</code> sets the rowset's metadata and * then sends a <code>RowSetChangedEvent</code> object * to all registered listeners prior to returning. * * @param data the <code>ResultSet</code> object containing the data * to be read into this <code>CachedRowSetImpl</code> object * @param start the integer specifing the position in the * <code>ResultSet</code> object to popultate the * <code>CachedRowSetImpl</code> object. * @throws SQLException if an error occurs; or the max row setting is * violated while populating the RowSet.Also id the start position * is negative. * @see #execute */ public void populate(ResultSet data, int start) throws SQLException{ int rowsFetched; Row currentRow; int numCols; int i; Map<String, Class<?>> map = getTypeMap(); Object obj; int mRows; cursorPos = 0; if(populatecallcount == 0){ if(start < 0){ throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.startpos").toString()); } if(getMaxRows() == 0){ data.absolute(start); while(data.next()){ totalRows++; } totalRows++; } startPos = start; } populatecallcount = populatecallcount +1; resultSet = data; if((endPos - startPos) >= getMaxRows() && (getMaxRows() > 0)){ endPos = prevEndPos; pagenotend = false; return; } if((maxRowsreached != getMaxRows() || maxRowsreached != totalRows) && pagenotend) { startPrev = start - getPageSize(); } if( pageSize == 0){ prevEndPos = endPos; endPos = start + getMaxRows() ; } else{ prevEndPos = endPos; endPos = start + getPageSize(); } if (start == 1){ resultSet.beforeFirst(); } else { resultSet.absolute(start -1); } if( pageSize == 0) { rvh = new Vector<Object>(getMaxRows()); } else{ rvh = new Vector<Object>(getPageSize()); } if (data == null) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.populate").toString()); } // get the meta data for this ResultSet RSMD = data.getMetaData(); // set up the metadata RowSetMD = new RowSetMetaDataImpl(); initMetaData(RowSetMD, RSMD); // release the meta-data so that aren't tempted to use it. RSMD = null; numCols = RowSetMD.getColumnCount(); mRows = this.getMaxRows(); rowsFetched = 0; currentRow = null; if(!data.next() && mRows == 0){ endPos = prevEndPos; pagenotend = false; return; } data.previous(); while ( data.next()) { currentRow = new Row(numCols); if(pageSize == 0){ if ( rowsFetched >= mRows && mRows > 0) { rowsetWarning.setNextException(new SQLException("Populating rows " + "setting has exceeded max row setting")); break; } } else { if ( (rowsFetched >= pageSize) ||( maxRowsreached >= mRows && mRows > 0)) { rowsetWarning.setNextException(new SQLException("Populating rows " + "setting has exceeded max row setting")); break; } } for ( i = 1; i <= numCols; i++) { /* * check if the user has set a map. If no map * is set then use plain getObject. This lets * us work with drivers that do not support * getObject with a map in fairly sensible way */ if (map == null) { obj = data.getObject(i); } else { obj = data.getObject(i, map); } /* * the following block checks for the various * types that we have to serialize in order to * store - right now only structs have been tested */ if (obj instanceof Struct) { obj = new SerialStruct((Struct)obj, map); } else if (obj instanceof SQLData) { obj = new SerialStruct((SQLData)obj, map); } else if (obj instanceof Blob) { obj = new SerialBlob((Blob)obj); } else if (obj instanceof Clob) { obj = new SerialClob((Clob)obj); } else if (obj instanceof java.sql.Array) { obj = new SerialArray((java.sql.Array)obj, map); } currentRow.initColumnObject(i, obj); } rowsFetched++; maxRowsreached++; rvh.add(currentRow); } numRows = rowsFetched ; // Also rowsFetched should be equal to rvh.size() // notify any listeners that the rowset has changed notifyRowSetChanged(); } /** * The nextPage gets the next page, that is a <code>CachedRowSetImpl</code> object * containing the number of rows specified by page size. * @return boolean value true indicating whether there are more pages to come and * false indicating that this is the last page. * @throws SQLException if an error occurs or this called before calling populate. */ public boolean nextPage() throws SQLException { if (populatecallcount == 0){ throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.nextpage").toString()); } // Fix for 6554186 onFirstPage = false; if(callWithCon){ crsReader.setStartPosition(endPos); crsReader.readData((RowSetInternal)this); resultSet = null; } else { populate(resultSet,endPos); } return pagenotend; } /** * This is the setter function for setting the size of the page, which specifies * how many rows have to be retrived at a time. * * @param size which is the page size * @throws SQLException if size is less than zero or greater than max rows. */ public void setPageSize (int size) throws SQLException { if (size < 0) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.pagesize").toString()); } if (size > getMaxRows() && getMaxRows() != 0) { throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.pagesize1").toString()); } pageSize = size; } /** * This is the getter function for the size of the page. * * @return an integer that is the page size. */ public int getPageSize() { return pageSize; } /** * Retrieves the data present in the page prior to the page from where it is * called. * @return boolean value true if it retrieves the previous page, flase if it * is on the first page. * @throws SQLException if it is called before populate is called or ResultSet * is of type <code>ResultSet.TYPE_FORWARD_ONLY</code> or if an error * occurs. */ public boolean previousPage() throws SQLException { int pS; int mR; int rem; pS = getPageSize(); mR = maxRowsreached; if (populatecallcount == 0){ throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.nextpage").toString()); } if( !callWithCon){ if(resultSet.getType() == ResultSet.TYPE_FORWARD_ONLY){ throw new SQLException (resBundle.handleGetObject("cachedrowsetimpl.fwdonly").toString()); } } pagenotend = true; if(startPrev < startPos ){ onFirstPage = true; return false; } if(onFirstPage){ return false; } rem = mR % pS; if(rem == 0){ maxRowsreached -= (2 * pS); if(callWithCon){ crsReader.setStartPosition(startPrev); crsReader.readData((RowSetInternal)this); resultSet = null; } else { populate(resultSet,startPrev); } return true; } else { maxRowsreached -= (pS + rem); if(callWithCon){ crsReader.setStartPosition(startPrev); crsReader.readData((RowSetInternal)this); resultSet = null; } else { populate(resultSet,startPrev); } return true; } } /** * Goes to the page number passed as the parameter * @param page , the page loaded on a call to this function * @return true if the page exists false otherwise * @throws SQLException if an error occurs */ /* public boolean absolutePage(int page) throws SQLException{ boolean isAbs = true, retVal = true; int counter; if( page <= 0 ){ throw new SQLException("Absolute positoin is invalid"); } counter = 0; firstPage(); counter++; while((counter < page) && isAbs) { isAbs = nextPage(); counter ++; } if( !isAbs && counter < page){ retVal = false; } else if(counter == page){ retVal = true; } return retVal; } */ /** * Goes to the page number passed as the parameter from the current page. * The parameter can take postive or negative value accordingly. * @param page , the page loaded on a call to this function * @return true if the page exists false otherwise * @throws SQLException if an error occurs */ /* public boolean relativePage(int page) throws SQLException { boolean isRel = true,retVal = true; int counter; if(page > 0){ counter = 0; while((counter < page) && isRel){ isRel = nextPage(); counter++; } if(!isRel && counter < page){ retVal = false; } else if( counter == page){ retVal = true; } return retVal; } else { counter = page; isRel = true; while((counter < 0) && isRel){ isRel = previousPage(); counter++; } if( !isRel && counter < 0){ retVal = false; } else if(counter == 0){ retVal = true; } return retVal; } } */ /** * Retrieves the first page of data as specified by the page size. * @return boolean value true if present on first page, false otherwise * @throws SQLException if it called before populate or ResultSet is of * type <code>ResultSet.TYPE_FORWARD_ONLY</code> or an error occurs */ /* public boolean firstPage() throws SQLException { if (populatecallcount == 0){ throw new SQLException("Populate the data before calling "); } if( !callWithCon){ if(resultSet.getType() == ResultSet.TYPE_FORWARD_ONLY) { throw new SQLException("Result of type forward only"); } } endPos = 0; maxRowsreached = 0; pagenotend = true; if(callWithCon){ crsReader.setStartPosition(startPos); crsReader.readData((RowSetInternal)this); resultSet = null; } else { populate(resultSet,startPos); } onFirstPage = true; return onFirstPage; } */ /** * Retrives the last page of data as specified by the page size. * @return boolean value tur if present on the last page, false otherwise * @throws SQLException if called before populate or if an error occurs. */ /* public boolean lastPage() throws SQLException{ int pS; int mR; int quo; int rem; pS = getPageSize(); mR = getMaxRows(); if(pS == 0){ onLastPage = true; return onLastPage; } if(getMaxRows() == 0){ mR = totalRows; } if (populatecallcount == 0){ throw new SQLException("Populate the data before calling "); } onFirstPage = false; if((mR % pS) == 0){ quo = mR / pS; int start = startPos + (pS * (quo - 1)); maxRowsreached = mR - pS; if(callWithCon){ crsReader.setStartPosition(start); crsReader.readData((RowSetInternal)this); resultSet = null; } else { populate(resultSet,start); } onLastPage = true; return onLastPage; } else { quo = mR /pS; rem = mR % pS; int start = startPos + (pS * quo); maxRowsreached = mR - (rem); if(callWithCon){ crsReader.setStartPosition(start); crsReader.readData((RowSetInternal)this); resultSet = null; } else { populate(resultSet,start); } onLastPage = true; return onLastPage; } } */ /** * Sets the status for the row on which the cursor is positioned. The insertFlag is used * to mention the toggle status for this row * @param insertFlag if it is true - marks this row as inserted * if it is false - marks it as not a newly inserted row * @throws SQLException if an error occurs while doing this operation */ public void setRowInserted(boolean insertFlag) throws SQLException { checkCursor(); if(onInsertRow == true) throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidop").toString()); if( insertFlag ) { ((Row)getCurrentRow()).setInserted(); } else { ((Row)getCurrentRow()).clearInserted(); } } /** * Retrieves the value of the designated <code>SQL XML</code> parameter as a * <code>SQLXML</code> object in the Java programming language. * @param columnIndex the first column is 1, the second is 2, ... * @return a SQLXML object that maps an SQL XML value * @throws SQLException if a database access error occurs * @since 1.6 */ public SQLXML getSQLXML(int columnIndex) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Retrieves the value of the designated <code>SQL XML</code> parameter as a * <code>SQLXML</code> object in the Java programming language. * @param colName the name of the column from which to retrieve the value * @return a SQLXML object that maps an SQL XML value * @throws SQLException if a database access error occurs */ public SQLXML getSQLXML(String colName) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Retrieves the value of the designated column in the current row of this * <code>ResultSet</code> object as a java.sql.RowId object in the Java * programming language. * * @param columnIndex the first column is 1, the second 2, ... * @return the column value if the value is a SQL <code>NULL</code> the * value returned is <code>null</code> * @throws SQLException if a database access error occurs * @since 1.6 */ public RowId getRowId(int columnIndex) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Retrieves the value of the designated column in the current row of this * <code>ResultSet</code> object as a java.sql.RowId object in the Java * programming language. * * @param columnName the name of the column * @return the column value if the value is a SQL <code>NULL</code> the * value returned is <code>null</code> * @throws SQLException if a database access error occurs * @since 1.6 */ public RowId getRowId(String columnName) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Updates the designated column with a <code>RowId</code> value. The updater * methods are used to update column values in the current row or the insert * row. The updater methods do not update the underlying database; instead * the {@code updateRow} or {@code insertRow} methods are called * to update the database. * * @param columnIndex the first column is 1, the second 2, ... * @param x the column value * @throws SQLException if a database access occurs * @since 1.6 */ public void updateRowId(int columnIndex, RowId x) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Updates the designated column with a <code>RowId</code> value. The updater * methods are used to update column values in the current row or the insert * row. The updater methods do not update the underlying database; instead * the {@code updateRow} or {@code insertRow} methods are called * to update the database. * * @param columnName the name of the column * @param x the column value * @throws SQLException if a database access occurs * @since 1.6 */ public void updateRowId(String columnName, RowId x) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Retrieves the holdability of this ResultSet object * @return either ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT * @throws SQLException if a database error occurs * @since 1.6 */ public int getHoldability() throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Retrieves whether this ResultSet object has been closed. A ResultSet is closed if the * method close has been called on it, or if it is automatically closed. * @return true if this ResultSet object is closed; false if it is still open * @throws SQLException if a database access error occurs * @since 1.6 */ public boolean isClosed() throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * This method is used for updating columns that support National Character sets. * It can be used for updating NCHAR,NVARCHAR and LONGNVARCHAR columns. * @param columnIndex the first column is 1, the second 2, ... * @param nString the value for the column to be updated * @throws SQLException if a database access error occurs * @since 1.6 */ public void updateNString(int columnIndex, String nString) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * This method is used for updating columns that support National Character sets. * It can be used for updating NCHAR,NVARCHAR and LONGNVARCHAR columns. * @param columnName name of the Column * @param nString the value for the column to be updated * @throws SQLException if a database access error occurs * @since 1.6 */ public void updateNString(String columnName, String nString) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /*o * This method is used for updating SQL <code>NCLOB</code> type that maps * to <code>java.sql.Types.NCLOB</code> * @param columnIndex the first column is 1, the second 2, ... * @param nClob the value for the column to be updated * @throws SQLException if a database access error occurs * @since 1.6 */ public void updateNClob(int columnIndex, NClob nClob) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * This method is used for updating SQL <code>NCLOB</code> type that maps * to <code>java.sql.Types.NCLOB</code> * @param columnName name of the column * @param nClob the value for the column to be updated * @throws SQLException if a database access error occurs * @since 1.6 */ public void updateNClob(String columnName, NClob nClob) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Retrieves the value of the designated column in the current row * of this <code>ResultSet</code> object as a <code>NClob</code> object * in the Java programming language. * * @param i the first column is 1, the second is 2, ... * @return a <code>NClob</code> object representing the SQL * <code>NCLOB</code> value in the specified column * @exception SQLException if a database access error occurs * @since 1.6 */ public NClob getNClob(int i) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Retrieves the value of the designated column in the current row * of this <code>ResultSet</code> object as a <code>NClob</code> object * in the Java programming language. * * @param colName the name of the column from which to retrieve the value * @return a <code>NClob</code> object representing the SQL <code>NCLOB</code> * value in the specified column * @exception SQLException if a database access error occurs * @since 1.6 */ public NClob getNClob(String colName) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } public <T> T unwrap(java.lang.Class<T> iface) throws java.sql.SQLException { return null; } public boolean isWrapperFor(Class<?> interfaces) throws SQLException { return false; } /** * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an * SQL <code>XML</code> value when it sends it to the database. * @param parameterIndex index of the first parameter is 1, the second is 2, ... * @param xmlObject a <code>SQLXML</code> object that maps an SQL <code>XML</code> value * @throws SQLException if a database access error occurs * @since 1.6 */ public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an * <code>SQL XML</code> value when it sends it to the database. * @param parameterName the name of the parameter * @param xmlObject a <code>SQLXML</code> object that maps an <code>SQL XML</code> value * @throws SQLException if a database access error occurs * @since 1.6 */ public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The * driver converts this to a SQL <code>ROWID</code> value when it sends it * to the database * * @param parameterIndex the first parameter is 1, the second is 2, ... * @param x the parameter value * @throws SQLException if a database access error occurs * * @since 1.6 */ public void setRowId(int parameterIndex, RowId x) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The * driver converts this to a SQL <code>ROWID</code> when it sends it to the * database. * * @param parameterName the name of the parameter * @param x the parameter value * @throws SQLException if a database access error occurs * @since 1.6 */ public void setRowId(String parameterName, RowId x) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Sets the designated parameter to a <code>Reader</code> object. The * <code>Reader</code> reads the data till end-of-file is reached. The * driver does the necessary conversion from Java character format to * the national character set in the database. * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>setNCharacterStream</code> which takes a length parameter. * * @param parameterIndex of the first parameter is 1, the second is 2, ... * @param value the parameter value * @throws SQLException if the driver does not support national * character sets; if the driver can detect that a data conversion * error could occur ; if a database access error occurs; or * this method is called on a closed <code>PreparedStatement</code> * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method * @since 1.6 */ public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>java.sql.NClob</code> object. The object * implements the <code>java.sql.NClob</code> interface. This <code>NClob</code> * object maps to a SQL <code>NCLOB</code>. * @param parameterName the name of the column to be set * @param value the parameter value * @throws SQLException if the driver does not support national * character sets; if the driver can detect that a data conversion * error could occur; or if a database access error occurs * @since 1.6 */ public void setNClob(String parameterName, NClob value) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Retrieves the value of the designated column in the current row * of this <code>ResultSet</code> object as a * <code>java.io.Reader</code> object. * It is intended for use when * accessing <code>NCHAR</code>,<code>NVARCHAR</code> * and <code>LONGNVARCHAR</code> columns. * * @return a <code>java.io.Reader</code> object that contains the column * value; if the value is SQL <code>NULL</code>, the value returned is * <code>null</code> in the Java programming language. * @param columnIndex the first column is 1, the second is 2, ... * @exception SQLException if a database access error occurs * @since 1.6 */ public java.io.Reader getNCharacterStream(int columnIndex) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Retrieves the value of the designated column in the current row * of this <code>ResultSet</code> object as a * <code>java.io.Reader</code> object. * It is intended for use when * accessing <code>NCHAR</code>,<code>NVARCHAR</code> * and <code>LONGNVARCHAR</code> columns. * * @param columnName the name of the column * @return a <code>java.io.Reader</code> object that contains the column * value; if the value is SQL <code>NULL</code>, the value returned is * <code>null</code> in the Java programming language * @exception SQLException if a database access error occurs * @since 1.6 */ public java.io.Reader getNCharacterStream(String columnName) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Updates the designated column with a <code>java.sql.SQLXML</code> value. * The updater * methods are used to update column values in the current row or the insert * row. The updater methods do not update the underlying database; instead * the <code>updateRow</code> or <code>insertRow</code> methods are called * to update the database. * @param columnIndex the first column is 1, the second 2, ... * @param xmlObject the value for the column to be updated * @throws SQLException if a database access error occurs * @since 1.6 */ public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Updates the designated column with a <code>java.sql.SQLXML</code> value. * The updater * methods are used to update column values in the current row or the insert * row. The updater methods do not update the underlying database; instead * the <code>updateRow</code> or <code>insertRow</code> methods are called * to update the database. * * @param columnName the name of the column * @param xmlObject the column value * @throws SQLException if a database access occurs * @since 1.6 */ public void updateSQLXML(String columnName, SQLXML xmlObject) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Retrieves the value of the designated column in the current row * of this <code>ResultSet</code> object as * a <code>String</code> in the Java programming language. * It is intended for use when * accessing <code>NCHAR</code>,<code>NVARCHAR</code> * and <code>LONGNVARCHAR</code> columns. * * @param columnIndex the first column is 1, the second is 2, ... * @return the column value; if the value is SQL <code>NULL</code>, the * value returned is <code>null</code> * @exception SQLException if a database access error occurs * @since 1.6 */ public String getNString(int columnIndex) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Retrieves the value of the designated column in the current row * of this <code>ResultSet</code> object as * a <code>String</code> in the Java programming language. * It is intended for use when * accessing <code>NCHAR</code>,<code>NVARCHAR</code> * and <code>LONGNVARCHAR</code> columns. * * @param columnName the SQL name of the column * @return the column value; if the value is SQL <code>NULL</code>, the * value returned is <code>null</code> * @exception SQLException if a database access error occurs * @since 1.6 */ public String getNString(String columnName) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Updates the designated column with a character stream value, which will * have the specified number of bytes. The driver does the necessary conversion * from Java character format to the national character set in the database. * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns. * The updater methods are used to update column values in the current row or * the insert row. The updater methods do not update the underlying database; * instead the updateRow or insertRow methods are called to update the database. * * @param columnIndex - the first column is 1, the second is 2, ... * @param x - the new column value * @param length - the length of the stream * @exception SQLException if a database access error occurs * @since 1.6 */ public void updateNCharacterStream(int columnIndex, java.io.Reader x, long length) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Updates the designated column with a character stream value, which will * have the specified number of bytes. The driver does the necessary conversion * from Java character format to the national character set in the database. * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns. * The updater methods are used to update column values in the current row or * the insert row. The updater methods do not update the underlying database; * instead the updateRow or insertRow methods are called to update the database. * * @param columnName - name of the Column * @param x - the new column value * @param length - the length of the stream * @exception SQLException if a database access error occurs * @since 1.6 */ public void updateNCharacterStream(String columnName, java.io.Reader x, long length) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.opnotysupp").toString()); } /** * Updates the designated column with a character stream value. The * driver does the necessary conversion from Java character format to * the national character set in the database. * It is intended for use when * updating <code>NCHAR</code>,<code>NVARCHAR</code> * and <code>LONGNVARCHAR</code> columns. * * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>updateNCharacterStream</code> which takes a length parameter. * * @param columnIndex the first column is 1, the second is 2, ... * @param x the new column value * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateNCharacterStream(int columnIndex, java.io.Reader x) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column with a character stream value. The * driver does the necessary conversion from Java character format to * the national character set in the database. * It is intended for use when * updating <code>NCHAR</code>,<code>NVARCHAR</code> * and <code>LONGNVARCHAR</code> columns. * * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>updateNCharacterStream</code> which takes a length parameter. * * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column * @param reader the <code>java.io.Reader</code> object containing * the new column value * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateNCharacterStream(String columnLabel, java.io.Reader reader) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); }////////////////////////// /** * Updates the designated column using the given input stream, which * will have the specified number of bytes. * When a very large ASCII value is input to a <code>LONGVARCHAR</code> * parameter, it may be more practical to send it via a * <code>java.io.InputStream</code>. Data will be read from the stream * as needed until end-of-file is reached. The JDBC driver will * do any necessary conversion from ASCII to the database char format. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * <p> * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnIndex the first column is 1, the second is 2, ... * @param inputStream An object that contains the data to set the parameter * value to. * @param length the number of bytes in the parameter data. * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column using the given input stream, which * will have the specified number of bytes. * When a very large ASCII value is input to a <code>LONGVARCHAR</code> * parameter, it may be more practical to send it via a * <code>java.io.InputStream</code>. Data will be read from the stream * as needed until end-of-file is reached. The JDBC driver will * do any necessary conversion from ASCII to the database char format. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * <p> * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column * @param inputStream An object that contains the data to set the parameter * value to. * @param length the number of bytes in the parameter data. * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column using the given input stream. * When a very large ASCII value is input to a <code>LONGVARCHAR</code> * parameter, it may be more practical to send it via a * <code>java.io.InputStream</code>. Data will be read from the stream * as needed until end-of-file is reached. The JDBC driver will * do any necessary conversion from ASCII to the database char format. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>updateBlob</code> which takes a length parameter. * <p> * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnIndex the first column is 1, the second is 2, ... * @param inputStream An object that contains the data to set the parameter * value to. * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column using the given input stream. * When a very large ASCII value is input to a <code>LONGVARCHAR</code> * parameter, it may be more practical to send it via a * <code>java.io.InputStream</code>. Data will be read from the stream * as needed until end-of-file is reached. The JDBC driver will * do any necessary conversion from ASCII to the database char format. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>updateBlob</code> which takes a length parameter. * <p> * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column * @param inputStream An object that contains the data to set the parameter * value to. * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column using the given <code>Reader</code> * object, which is the given number of characters long. * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> * parameter, it may be more practical to send it via a * <code>java.io.Reader</code> object. The data will be read from the stream * as needed until end-of-file is reached. The JDBC driver will * do any necessary conversion from UNICODE to the database char format. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * <p> * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnIndex the first column is 1, the second is 2, ... * @param reader An object that contains the data to set the parameter value to. * @param length the number of characters in the parameter data. * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateClob(int columnIndex, Reader reader, long length) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column using the given <code>Reader</code> * object, which is the given number of characters long. * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> * parameter, it may be more practical to send it via a * <code>java.io.Reader</code> object. The data will be read from the stream * as needed until end-of-file is reached. The JDBC driver will * do any necessary conversion from UNICODE to the database char format. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * <p> * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column * @param reader An object that contains the data to set the parameter value to. * @param length the number of characters in the parameter data. * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateClob(String columnLabel, Reader reader, long length) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column using the given <code>Reader</code> * object. * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> * parameter, it may be more practical to send it via a * <code>java.io.Reader</code> object. The data will be read from the stream * as needed until end-of-file is reached. The JDBC driver will * do any necessary conversion from UNICODE to the database char format. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>updateClob</code> which takes a length parameter. * <p> * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnIndex the first column is 1, the second is 2, ... * @param reader An object that contains the data to set the parameter value to. * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateClob(int columnIndex, Reader reader) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column using the given <code>Reader</code> * object. * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> * parameter, it may be more practical to send it via a * <code>java.io.Reader</code> object. The data will be read from the stream * as needed until end-of-file is reached. The JDBC driver will * do any necessary conversion from UNICODE to the database char format. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>updateClob</code> which takes a length parameter. * <p> * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column * @param reader An object that contains the data to set the parameter value to. * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateClob(String columnLabel, Reader reader) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column using the given <code>Reader</code> * object, which is the given number of characters long. * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> * parameter, it may be more practical to send it via a * <code>java.io.Reader</code> object. The data will be read from the stream * as needed until end-of-file is reached. The JDBC driver will * do any necessary conversion from UNICODE to the database char format. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * <p> * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnIndex the first column is 1, the second 2, ... * @param reader An object that contains the data to set the parameter value to. * @param length the number of characters in the parameter data. * @throws SQLException if the driver does not support national * character sets; if the driver can detect that a data conversion * error could occur; this method is called on a closed result set, * if a database access error occurs or * the result set concurrency is <code>CONCUR_READ_ONLY</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column using the given <code>Reader</code> * object, which is the given number of characters long. * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> * parameter, it may be more practical to send it via a * <code>java.io.Reader</code> object. The data will be read from the stream * as needed until end-of-file is reached. The JDBC driver will * do any necessary conversion from UNICODE to the database char format. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * <p> * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column * @param reader An object that contains the data to set the parameter value to. * @param length the number of characters in the parameter data. * @throws SQLException if the driver does not support national * character sets; if the driver can detect that a data conversion * error could occur; this method is called on a closed result set; * if a database access error occurs or * the result set concurrency is <code>CONCUR_READ_ONLY</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column using the given <code>Reader</code> * object. * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> * parameter, it may be more practical to send it via a * <code>java.io.Reader</code> object. The data will be read from the stream * as needed until end-of-file is reached. The JDBC driver will * do any necessary conversion from UNICODE to the database char format. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>updateNClob</code> which takes a length parameter. * <p> * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnIndex the first column is 1, the second 2, ... * @param reader An object that contains the data to set the parameter value to. * @throws SQLException if the driver does not support national * character sets; if the driver can detect that a data conversion * error could occur; this method is called on a closed result set, * if a database access error occurs or * the result set concurrency is <code>CONCUR_READ_ONLY</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateNClob(int columnIndex, Reader reader) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column using the given <code>Reader</code> * object. * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> * parameter, it may be more practical to send it via a * <code>java.io.Reader</code> object. The data will be read from the stream * as needed until end-of-file is reached. The JDBC driver will * do any necessary conversion from UNICODE to the database char format. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>updateNClob</code> which takes a length parameter. * <p> * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column * @param reader An object that contains the data to set the parameter value to. * @throws SQLException if the driver does not support national * character sets; if the driver can detect that a data conversion * error could occur; this method is called on a closed result set; * if a database access error occurs or * the result set concurrency is <code>CONCUR_READ_ONLY</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateNClob(String columnLabel, Reader reader) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column with an ascii stream value, which will have * the specified number of bytes. * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnIndex the first column is 1, the second is 2, ... * @param x the new column value * @param length the length of the stream * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateAsciiStream(int columnIndex, java.io.InputStream x, long length) throws SQLException { } /** * Updates the designated column with a binary stream value, which will have * the specified number of bytes. * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnIndex the first column is 1, the second is 2, ... * @param x the new column value * @param length the length of the stream * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateBinaryStream(int columnIndex, java.io.InputStream x, long length) throws SQLException { } /** * Updates the designated column with a character stream value, which will have * the specified number of bytes. * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnIndex the first column is 1, the second is 2, ... * @param x the new column value * @param length the length of the stream * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateCharacterStream(int columnIndex, java.io.Reader x, long length) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column with a character stream value, which will have * the specified number of bytes. * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column * @param reader the <code>java.io.Reader</code> object containing * the new column value * @param length the length of the stream * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateCharacterStream(String columnLabel, java.io.Reader reader, long length) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column with an ascii stream value, which will have * the specified number of bytes.. * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column * @param x the new column value * @param length the length of the stream * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateAsciiStream(String columnLabel, java.io.InputStream x, long length) throws SQLException { } /** * Updates the designated column with a binary stream value, which will have * the specified number of bytes. * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column * @param x the new column value * @param length the length of the stream * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateBinaryStream(String columnLabel, java.io.InputStream x, long length) throws SQLException { } /** * Updates the designated column with a binary stream value. * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>updateBinaryStream</code> which takes a length parameter. * * @param columnIndex the first column is 1, the second is 2, ... * @param x the new column value * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateBinaryStream(int columnIndex, java.io.InputStream x) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column with a binary stream value. * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>updateBinaryStream</code> which takes a length parameter. * * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column * @param x the new column value * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateBinaryStream(String columnLabel, java.io.InputStream x) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column with a character stream value. * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>updateCharacterStream</code> which takes a length parameter. * * @param columnIndex the first column is 1, the second is 2, ... * @param x the new column value * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateCharacterStream(int columnIndex, java.io.Reader x) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column with a character stream value. * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>updateCharacterStream</code> which takes a length parameter. * * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column * @param reader the <code>java.io.Reader</code> object containing * the new column value * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateCharacterStream(String columnLabel, java.io.Reader reader) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column with an ascii stream value. * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>updateAsciiStream</code> which takes a length parameter. * * @param columnIndex the first column is 1, the second is 2, ... * @param x the new column value * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateAsciiStream(int columnIndex, java.io.InputStream x) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Updates the designated column with an ascii stream value. * The updater methods are used to update column values in the * current row or the insert row. The updater methods do not * update the underlying database; instead the <code>updateRow</code> or * <code>insertRow</code> methods are called to update the database. * * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>updateAsciiStream</code> which takes a length parameter. * * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the label is the name of the column * @param x the new column value * @exception SQLException if a database access error occurs, * the result set concurrency is <code>CONCUR_READ_ONLY</code> * or this method is called on a closed result set * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void updateAsciiStream(String columnLabel, java.io.InputStream x) throws SQLException { } /** * Sets the designated parameter to the given <code>java.net.URL</code> value. * The driver converts this to an SQL <code>DATALINK</code> value * when it sends it to the database. * * @param parameterIndex the first parameter is 1, the second is 2, ... * @param x the <code>java.net.URL</code> object to be set * @exception SQLException if a database access error occurs or * this method is called on a closed <code>PreparedStatement</code> * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method * @since 1.4 */ public void setURL(int parameterIndex, java.net.URL x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>Reader</code> object. * This method differs from the <code>setCharacterStream (int, Reader)</code> method * because it informs the driver that the parameter value should be sent to * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the * driver may have to do extra work to determine whether the parameter * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code> * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>setNClob</code> which takes a length parameter. * * @param parameterIndex index of the first parameter is 1, the second is 2, ... * @param reader An object that contains the data to set the parameter value to. * @throws SQLException if parameterIndex does not correspond to a parameter * marker in the SQL statement; * if the driver does not support national character sets; * if the driver can detect that a data conversion * error could occur; if a database access error occurs or * this method is called on a closed <code>PreparedStatement</code> * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method * * @since 1.6 */ public void setNClob(int parameterIndex, Reader reader) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>Reader</code> object. The <code>reader</code> must contain the number * of characters specified by length otherwise a <code>SQLException</code> will be * generated when the <code>CallableStatement</code> is executed. * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method * because it informs the driver that the parameter value should be sent to * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the * driver may have to do extra work to determine whether the parameter * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code> * * @param parameterName the name of the parameter to be set * @param reader An object that contains the data to set the parameter value to. * @param length the number of characters in the parameter data. * @throws SQLException if parameterIndex does not correspond to a parameter * marker in the SQL statement; if the length specified is less than zero; * if the driver does not support national * character sets; if the driver can detect that a data conversion * error could occur; if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void setNClob(String parameterName, Reader reader, long length) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>Reader</code> object. * This method differs from the <code>setCharacterStream (int, Reader)</code> method * because it informs the driver that the parameter value should be sent to * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the * driver may have to do extra work to determine whether the parameter * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code> * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>setNClob</code> which takes a length parameter. * * @param parameterName the name of the parameter * @param reader An object that contains the data to set the parameter value to. * @throws SQLException if the driver does not support national character sets; * if the driver can detect that a data conversion * error could occur; if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method * * @since 1.6 */ public void setNClob(String parameterName, Reader reader) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>Reader</code> object. The reader must contain the number * of characters specified by length otherwise a <code>SQLException</code> will be * generated when the <code>PreparedStatement</code> is executed. * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method * because it informs the driver that the parameter value should be sent to * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the * driver may have to do extra work to determine whether the parameter * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code> * @param parameterIndex index of the first parameter is 1, the second is 2, ... * @param reader An object that contains the data to set the parameter value to. * @param length the number of characters in the parameter data. * @throws SQLException if parameterIndex does not correspond to a parameter * marker in the SQL statement; if the length specified is less than zero; * if the driver does not support national character sets; * if the driver can detect that a data conversion * error could occur; if a database access error occurs or * this method is called on a closed <code>PreparedStatement</code> * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method * * @since 1.6 */ public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>java.sql.NClob</code> object. The driver converts this toa * SQL <code>NCLOB</code> value when it sends it to the database. * @param parameterIndex of the first parameter is 1, the second is 2, ... * @param value the parameter value * @throws SQLException if the driver does not support national * character sets; if the driver can detect that a data conversion * error could occur ; or if a database access error occurs * @since 1.6 */ public void setNClob(int parameterIndex, NClob value) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given <code>String</code> object. * The driver converts this to a SQL <code>NCHAR</code> or * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value * (depending on the argument's * size relative to the driver's limits on <code>NVARCHAR</code> values) * when it sends it to the database. * * @param parameterIndex of the first parameter is 1, the second is 2, ... * @param value the parameter value * @throws SQLException if the driver does not support national * character sets; if the driver can detect that a data conversion * error could occur ; or if a database access error occurs * @since 1.6 */ public void setNString(int parameterIndex, String value) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given <code>String</code> object. * The driver converts this to a SQL <code>NCHAR</code> or * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> * @param parameterName the name of the column to be set * @param value the parameter value * @throws SQLException if the driver does not support national * character sets; if the driver can detect that a data conversion * error could occur; or if a database access error occurs * @since 1.6 */ public void setNString(String parameterName, String value) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>Reader</code> object. The * <code>Reader</code> reads the data till end-of-file is reached. The * driver does the necessary conversion from Java character format to * the national character set in the database. * @param parameterIndex of the first parameter is 1, the second is 2, ... * @param value the parameter value * @param length the number of characters in the parameter data. * @throws SQLException if the driver does not support national * character sets; if the driver can detect that a data conversion * error could occur ; or if a database access error occurs * @since 1.6 */ public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>Reader</code> object. The * <code>Reader</code> reads the data till end-of-file is reached. The * driver does the necessary conversion from Java character format to * the national character set in the database. * @param parameterName the name of the column to be set * @param value the parameter value * @param length the number of characters in the parameter data. * @throws SQLException if the driver does not support national * character sets; if the driver can detect that a data conversion * error could occur; or if a database access error occurs * @since 1.6 */ public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>Reader</code> object. The * <code>Reader</code> reads the data till end-of-file is reached. The * driver does the necessary conversion from Java character format to * the national character set in the database. * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>setNCharacterStream</code> which takes a length parameter. * * @param parameterName the name of the parameter * @param value the parameter value * @throws SQLException if the driver does not support national * character sets; if the driver can detect that a data conversion * error could occur ; if a database access error occurs; or * this method is called on a closed <code>CallableStatement</code> * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method * @since 1.6 */ public void setNCharacterStream(String parameterName, Reader value) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value, * using the given <code>Calendar</code> object. The driver uses * the <code>Calendar</code> object to construct an SQL <code>TIMESTAMP</code> value, * which the driver then sends to the database. With a * a <code>Calendar</code> object, the driver can calculate the timestamp * taking into account a custom timezone. If no * <code>Calendar</code> object is specified, the driver uses the default * timezone, which is that of the virtual machine running the application. * * @param parameterName the name of the parameter * @param x the parameter value * @param cal the <code>Calendar</code> object the driver will use * to construct the timestamp * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @see #getTimestamp * @since 1.4 */ public void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>Reader</code> object. The <code>reader</code> must contain the number * of characters specified by length otherwise a <code>SQLException</code> will be * generated when the <code>CallableStatement</code> is executed. * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method * because it informs the driver that the parameter value should be sent to * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the * driver may have to do extra work to determine whether the parameter * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code> * @param parameterName the name of the parameter to be set * @param reader An object that contains the data to set the parameter value to. * @param length the number of characters in the parameter data. * @throws SQLException if parameterIndex does not correspond to a parameter * marker in the SQL statement; if the length specified is less than zero; * a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * * @since 1.6 */ public void setClob(String parameterName, Reader reader, long length) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given <code>java.sql.Clob</code> object. * The driver converts this to an SQL <code>CLOB</code> value when it * sends it to the database. * * @param parameterName the name of the parameter * @param x a <code>Clob</code> object that maps an SQL <code>CLOB</code> value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void setClob (String parameterName, Clob x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>Reader</code> object. * This method differs from the <code>setCharacterStream (int, Reader)</code> method * because it informs the driver that the parameter value should be sent to * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the * driver may have to do extra work to determine whether the parameter * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code> * * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>setClob</code> which takes a length parameter. * * @param parameterName the name of the parameter * @param reader An object that contains the data to set the parameter value to. * @throws SQLException if a database access error occurs or this method is called on * a closed <code>CallableStatement</code> * * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method * @since 1.6 */ public void setClob(String parameterName, Reader reader) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given <code>java.sql.Date</code> value * using the default time zone of the virtual machine that is running * the application. * The driver converts this * to an SQL <code>DATE</code> value when it sends it to the database. * * @param parameterName the name of the parameter * @param x the parameter value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @see #getDate * @since 1.4 */ public void setDate(String parameterName, java.sql.Date x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given <code>java.sql.Date</code> value, * using the given <code>Calendar</code> object. The driver uses * the <code>Calendar</code> object to construct an SQL <code>DATE</code> value, * which the driver then sends to the database. With a * a <code>Calendar</code> object, the driver can calculate the date * taking into account a custom timezone. If no * <code>Calendar</code> object is specified, the driver uses the default * timezone, which is that of the virtual machine running the application. * * @param parameterName the name of the parameter * @param x the parameter value * @param cal the <code>Calendar</code> object the driver will use * to construct the date * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @see #getDate * @since 1.4 */ public void setDate(String parameterName, java.sql.Date x, Calendar cal) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given <code>java.sql.Time</code> value. * The driver converts this * to an SQL <code>TIME</code> value when it sends it to the database. * * @param parameterName the name of the parameter * @param x the parameter value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @see #getTime * @since 1.4 */ public void setTime(String parameterName, java.sql.Time x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given <code>java.sql.Time</code> value, * using the given <code>Calendar</code> object. The driver uses * the <code>Calendar</code> object to construct an SQL <code>TIME</code> value, * which the driver then sends to the database. With a * a <code>Calendar</code> object, the driver can calculate the time * taking into account a custom timezone. If no * <code>Calendar</code> object is specified, the driver uses the default * timezone, which is that of the virtual machine running the application. * * @param parameterName the name of the parameter * @param x the parameter value * @param cal the <code>Calendar</code> object the driver will use * to construct the time * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @see #getTime * @since 1.4 */ public void setTime(String parameterName, java.sql.Time x, Calendar cal) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>Reader</code> object. * This method differs from the <code>setCharacterStream (int, Reader)</code> method * because it informs the driver that the parameter value should be sent to * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the * driver may have to do extra work to determine whether the parameter * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code> * * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>setClob</code> which takes a length parameter. * * @param parameterIndex index of the first parameter is 1, the second is 2, ... * @param reader An object that contains the data to set the parameter value to. * @throws SQLException if a database access error occurs, this method is called on * a closed <code>PreparedStatement</code>or if parameterIndex does not correspond to a parameter * marker in the SQL statement * * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method * @since 1.6 */ public void setClob(int parameterIndex, Reader reader) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>Reader</code> object. The reader must contain the number * of characters specified by length otherwise a <code>SQLException</code> will be * generated when the <code>PreparedStatement</code> is executed. *This method differs from the <code>setCharacterStream (int, Reader, int)</code> method * because it informs the driver that the parameter value should be sent to * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the * driver may have to do extra work to determine whether the parameter * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code> * @param parameterIndex index of the first parameter is 1, the second is 2, ... * @param reader An object that contains the data to set the parameter value to. * @param length the number of characters in the parameter data. * @throws SQLException if a database access error occurs, this method is called on * a closed <code>PreparedStatement</code>, if parameterIndex does not correspond to a parameter * marker in the SQL statement, or if the length specified is less than zero. * * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method * @since 1.6 */ public void setClob(int parameterIndex, Reader reader, long length) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>InputStream</code> object. The inputstream must contain the number * of characters specified by length otherwise a <code>SQLException</code> will be * generated when the <code>PreparedStatement</code> is executed. * This method differs from the <code>setBinaryStream (int, InputStream, int)</code> * method because it informs the driver that the parameter value should be * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used, * the driver may have to do extra work to determine whether the parameter * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code> * @param parameterIndex index of the first parameter is 1, * the second is 2, ... * @param inputStream An object that contains the data to set the parameter * value to. * @param length the number of bytes in the parameter data. * @throws SQLException if a database access error occurs, * this method is called on a closed <code>PreparedStatement</code>, * if parameterIndex does not correspond * to a parameter marker in the SQL statement, if the length specified * is less than zero or if the number of bytes in the inputstream does not match * the specified length. * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method * * @since 1.6 */ public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>InputStream</code> object. * This method differs from the <code>setBinaryStream (int, InputStream)</code> * method because it informs the driver that the parameter value should be * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used, * the driver may have to do extra work to determine whether the parameter * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code> * * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>setBlob</code> which takes a length parameter. * * @param parameterIndex index of the first parameter is 1, * the second is 2, ... * @param inputStream An object that contains the data to set the parameter * value to. * @throws SQLException if a database access error occurs, * this method is called on a closed <code>PreparedStatement</code> or * if parameterIndex does not correspond * to a parameter marker in the SQL statement, * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method * * @since 1.6 */ public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>InputStream</code> object. The <code>inputstream</code> must contain the number * of characters specified by length, otherwise a <code>SQLException</code> will be * generated when the <code>CallableStatement</code> is executed. * This method differs from the <code>setBinaryStream (int, InputStream, int)</code> * method because it informs the driver that the parameter value should be * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used, * the driver may have to do extra work to determine whether the parameter * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code> * * @param parameterName the name of the parameter to be set * the second is 2, ... * * @param inputStream An object that contains the data to set the parameter * value to. * @param length the number of bytes in the parameter data. * @throws SQLException if parameterIndex does not correspond * to a parameter marker in the SQL statement, or if the length specified * is less than zero; if the number of bytes in the inputstream does not match * the specified length; if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * * @since 1.6 */ public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given <code>java.sql.Blob</code> object. * The driver converts this to an SQL <code>BLOB</code> value when it * sends it to the database. * * @param parameterName the name of the parameter * @param x a <code>Blob</code> object that maps an SQL <code>BLOB</code> value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.6 */ public void setBlob (String parameterName, Blob x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to a <code>InputStream</code> object. * This method differs from the <code>setBinaryStream (int, InputStream)</code> * method because it informs the driver that the parameter value should be * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used, * the driver may have to do extra work to determine whether the parameter * data should be send to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code> * * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>setBlob</code> which takes a length parameter. * * @param parameterName the name of the parameter * @param inputStream An object that contains the data to set the parameter * value to. * @throws SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method * * @since 1.6 */ public void setBlob(String parameterName, InputStream inputStream) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the value of the designated parameter with the given object. The second * argument must be an object type; for integral values, the * <code>java.lang</code> equivalent objects should be used. * * <p>The given Java object will be converted to the given targetSqlType * before being sent to the database. * * If the object has a custom mapping (is of a class implementing the * interface <code>SQLData</code>), * the JDBC driver should call the method <code>SQLData.writeSQL</code> to write it * to the SQL data stream. * If, on the other hand, the object is of a class implementing * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>NClob</code>, * <code>Struct</code>, <code>java.net.URL</code>, * or <code>Array</code>, the driver should pass it to the database as a * value of the corresponding SQL type. * <P> * Note that this method may be used to pass datatabase- * specific abstract data types. * * @param parameterName the name of the parameter * @param x the object containing the input parameter value * @param targetSqlType the SQL type (as defined in java.sql.Types) to be * sent to the database. The scale argument may further qualify this type. * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types, * this is the number of digits after the decimal point. For all other * types, this value will be ignored. * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>, * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>, * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>, * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code> * or <code>STRUCT</code> data type and the JDBC driver does not support * this data type * @see Types * @see #getObject * @since 1.4 */ public void setObject(String parameterName, Object x, int targetSqlType, int scale) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the value of the designated parameter with the given object. * This method is like the method <code>setObject</code> * above, except that it assumes a scale of zero. * * @param parameterName the name of the parameter * @param x the object containing the input parameter value * @param targetSqlType the SQL type (as defined in java.sql.Types) to be * sent to the database * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>, * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>, * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>, * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code> * or <code>STRUCT</code> data type and the JDBC driver does not support * this data type * @see #getObject * @since 1.4 */ public void setObject(String parameterName, Object x, int targetSqlType) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the value of the designated parameter with the given object. * The second parameter must be of type <code>Object</code>; therefore, the * <code>java.lang</code> equivalent objects should be used for built-in types. * * <p>The JDBC specification specifies a standard mapping from * Java <code>Object</code> types to SQL types. The given argument * will be converted to the corresponding SQL type before being * sent to the database. * * <p>Note that this method may be used to pass datatabase- * specific abstract data types, by using a driver-specific Java * type. * * If the object is of a class implementing the interface <code>SQLData</code>, * the JDBC driver should call the method <code>SQLData.writeSQL</code> * to write it to the SQL data stream. * If, on the other hand, the object is of a class implementing * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>NClob</code>, * <code>Struct</code>, <code>java.net.URL</code>, * or <code>Array</code>, the driver should pass it to the database as a * value of the corresponding SQL type. * <P> * This method throws an exception if there is an ambiguity, for example, if the * object is of a class implementing more than one of the interfaces named above. * * @param parameterName the name of the parameter * @param x the object containing the input parameter value * @exception SQLException if a database access error occurs, * this method is called on a closed <code>CallableStatement</code> or if the given * <code>Object</code> parameter is ambiguous * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @see #getObject * @since 1.4 */ public void setObject(String parameterName, Object x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given input stream, which will have * the specified number of bytes. * When a very large ASCII value is input to a <code>LONGVARCHAR</code> * parameter, it may be more practical to send it via a * <code>java.io.InputStream</code>. Data will be read from the stream * as needed until end-of-file is reached. The JDBC driver will * do any necessary conversion from ASCII to the database char format. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * * @param parameterName the name of the parameter * @param x the Java input stream that contains the ASCII parameter value * @param length the number of bytes in the stream * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.4 */ public void setAsciiStream(String parameterName, java.io.InputStream x, int length) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given input stream, which will have * the specified number of bytes. * When a very large binary value is input to a <code>LONGVARBINARY</code> * parameter, it may be more practical to send it via a * <code>java.io.InputStream</code> object. The data will be read from the stream * as needed until end-of-file is reached. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * * @param parameterName the name of the parameter * @param x the java input stream which contains the binary parameter value * @param length the number of bytes in the stream * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.4 */ public void setBinaryStream(String parameterName, java.io.InputStream x, int length) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given <code>Reader</code> * object, which is the given number of characters long. * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> * parameter, it may be more practical to send it via a * <code>java.io.Reader</code> object. The data will be read from the stream * as needed until end-of-file is reached. The JDBC driver will * do any necessary conversion from UNICODE to the database char format. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * * @param parameterName the name of the parameter * @param reader the <code>java.io.Reader</code> object that * contains the UNICODE data used as the designated parameter * @param length the number of characters in the stream * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.4 */ public void setCharacterStream(String parameterName, java.io.Reader reader, int length) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given input stream. * When a very large ASCII value is input to a <code>LONGVARCHAR</code> * parameter, it may be more practical to send it via a * <code>java.io.InputStream</code>. Data will be read from the stream * as needed until end-of-file is reached. The JDBC driver will * do any necessary conversion from ASCII to the database char format. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>setAsciiStream</code> which takes a length parameter. * * @param parameterName the name of the parameter * @param x the Java input stream that contains the ASCII parameter value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method * @since 1.6 */ public void setAsciiStream(String parameterName, java.io.InputStream x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given input stream. * When a very large binary value is input to a <code>LONGVARBINARY</code> * parameter, it may be more practical to send it via a * <code>java.io.InputStream</code> object. The data will be read from the * stream as needed until end-of-file is reached. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>setBinaryStream</code> which takes a length parameter. * * @param parameterName the name of the parameter * @param x the java input stream which contains the binary parameter value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method * @since 1.6 */ public void setBinaryStream(String parameterName, java.io.InputStream x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given <code>Reader</code> * object. * When a very large UNICODE value is input to a <code>LONGVARCHAR</code> * parameter, it may be more practical to send it via a * <code>java.io.Reader</code> object. The data will be read from the stream * as needed until end-of-file is reached. The JDBC driver will * do any necessary conversion from UNICODE to the database char format. * * <P><B>Note:</B> This stream object can either be a standard * Java stream object or your own subclass that implements the * standard interface. * <P><B>Note:</B> Consult your JDBC driver documentation to determine if * it might be more efficient to use a version of * <code>setCharacterStream</code> which takes a length parameter. * * @param parameterName the name of the parameter * @param reader the <code>java.io.Reader</code> object that contains the * Unicode data * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method * @since 1.6 */ public void setCharacterStream(String parameterName, java.io.Reader reader) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given * <code>java.math.BigDecimal</code> value. * The driver converts this to an SQL <code>NUMERIC</code> value when * it sends it to the database. * * @param parameterName the name of the parameter * @param x the parameter value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @see #getBigDecimal * @since 1.4 */ public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given Java <code>String</code> value. * The driver converts this * to an SQL <code>VARCHAR</code> or <code>LONGVARCHAR</code> value * (depending on the argument's * size relative to the driver's limits on <code>VARCHAR</code> values) * when it sends it to the database. * * @param parameterName the name of the parameter * @param x the parameter value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @see #getString * @since 1.4 */ public void setString(String parameterName, String x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given Java array of bytes. * The driver converts this to an SQL <code>VARBINARY</code> or * <code>LONGVARBINARY</code> (depending on the argument's size relative * to the driver's limits on <code>VARBINARY</code> values) when it sends * it to the database. * * @param parameterName the name of the parameter * @param x the parameter value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @see #getBytes * @since 1.4 */ public void setBytes(String parameterName, byte x[]) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value. * The driver * converts this to an SQL <code>TIMESTAMP</code> value when it sends it to the * database. * * @param parameterName the name of the parameter * @param x the parameter value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @see #getTimestamp * @since 1.4 */ public void setTimestamp(String parameterName, java.sql.Timestamp x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to SQL <code>NULL</code>. * * <P><B>Note:</B> You must specify the parameter's SQL type. * * @param parameterName the name of the parameter * @param sqlType the SQL type code defined in <code>java.sql.Types</code> * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.4 */ public void setNull(String parameterName, int sqlType) throws SQLException { throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to SQL <code>NULL</code>. * This version of the method <code>setNull</code> should * be used for user-defined types and REF type parameters. Examples * of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and * named array types. * * <P><B>Note:</B> To be portable, applications must give the * SQL type code and the fully-qualified SQL type name when specifying * a NULL user-defined or REF parameter. In the case of a user-defined type * the name is the type name of the parameter itself. For a REF * parameter, the name is the type name of the referenced type. If * a JDBC driver does not need the type code or type name information, * it may ignore it. * * Although it is intended for user-defined and Ref parameters, * this method may be used to set a null parameter of any JDBC type. * If the parameter does not have a user-defined or REF type, the given * typeName is ignored. * * * @param parameterName the name of the parameter * @param sqlType a value from <code>java.sql.Types</code> * @param typeName the fully-qualified name of an SQL user-defined type; * ignored if the parameter is not a user-defined type or * SQL <code>REF</code> value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.4 */ public void setNull (String parameterName, int sqlType, String typeName) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given Java <code>boolean</code> value. * The driver converts this * to an SQL <code>BIT</code> or <code>BOOLEAN</code> value when it sends it to the database. * * @param parameterName the name of the parameter * @param x the parameter value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @see #getBoolean * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @since 1.4 */ public void setBoolean(String parameterName, boolean x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given Java <code>byte</code> value. * The driver converts this * to an SQL <code>TINYINT</code> value when it sends it to the database. * * @param parameterName the name of the parameter * @param x the parameter value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @see #getByte * @since 1.4 */ public void setByte(String parameterName, byte x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given Java <code>short</code> value. * The driver converts this * to an SQL <code>SMALLINT</code> value when it sends it to the database. * * @param parameterName the name of the parameter * @param x the parameter value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @see #getShort * @since 1.4 */ public void setShort(String parameterName, short x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given Java <code>int</code> value. * The driver converts this * to an SQL <code>INTEGER</code> value when it sends it to the database. * * @param parameterName the name of the parameter * @param x the parameter value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @see #getInt * @since 1.4 */ public void setInt(String parameterName, int x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given Java <code>long</code> value. * The driver converts this * to an SQL <code>BIGINT</code> value when it sends it to the database. * * @param parameterName the name of the parameter * @param x the parameter value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @see #getLong * @since 1.4 */ public void setLong(String parameterName, long x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given Java <code>float</code> value. * The driver converts this * to an SQL <code>FLOAT</code> value when it sends it to the database. * * @param parameterName the name of the parameter * @param x the parameter value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @see #getFloat * @since 1.4 */ public void setFloat(String parameterName, float x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * Sets the designated parameter to the given Java <code>double</code> value. * The driver converts this * to an SQL <code>DOUBLE</code> value when it sends it to the database. * * @param parameterName the name of the parameter * @param x the parameter value * @exception SQLException if a database access error occurs or * this method is called on a closed <code>CallableStatement</code> * @exception SQLFeatureNotSupportedException if the JDBC driver does not support * this method * @see #getDouble * @since 1.4 */ public void setDouble(String parameterName, double x) throws SQLException{ throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("cachedrowsetimpl.featnotsupp").toString()); } /** * This method re populates the resBundle * during the deserialization process * */ private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException { // Default state initialization happens here ois.defaultReadObject(); // Initialization of transient Res Bundle happens here . try { resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle(); } catch(IOException ioe) { throw new RuntimeException(ioe); } } //------------------------- JDBC 4.1 ----------------------------------- public <T> T getObject(int columnIndex, Class<T> type) throws SQLException { throw new SQLFeatureNotSupportedException("Not supported yet."); } public <T> T getObject(String columnLabel, Class<T> type) throws SQLException { throw new SQLFeatureNotSupportedException("Not supported yet."); } static final long serialVersionUID =1884577171200622428L;}