0001: /*
0002: * Copyright 2003-2006 Sun Microsystems, Inc. All Rights Reserved.
0003: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
0004: *
0005: * This code is free software; you can redistribute it and/or modify it
0006: * under the terms of the GNU General Public License version 2 only, as
0007: * published by the Free Software Foundation. Sun designates this
0008: * particular file as subject to the "Classpath" exception as provided
0009: * by Sun in the LICENSE file that accompanied this code.
0010: *
0011: * This code is distributed in the hope that it will be useful, but WITHOUT
0012: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
0013: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
0014: * version 2 for more details (a copy is included in the LICENSE file that
0015: * accompanied this code).
0016: *
0017: * You should have received a copy of the GNU General Public License version
0018: * 2 along with this work; if not, write to the Free Software Foundation,
0019: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
0020: *
0021: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
0022: * CA 95054 USA or visit www.sun.com if you need additional information or
0023: * have any questions.
0024: */
0025:
0026: package com.sun.rowset;
0027:
0028: import java.sql.*;
0029: import javax.sql.*;
0030: import javax.naming.*;
0031: import java.io.*;
0032: import java.math.*;
0033: import java.util.*;
0034: import java.beans.*;
0035:
0036: import javax.sql.rowset.*;
0037:
0038: /**
0039: * The standard implementation of the <code>JdbcRowSet</code> interface. See the interface
0040: * defintion for full behavior and implementation requirements.
0041: *
0042: * @author Jonathan Bruce, Amit Handa
0043: */
0044:
0045: public class JdbcRowSetImpl extends BaseRowSet implements JdbcRowSet,
0046: Joinable {
0047:
0048: /**
0049: * The <code>Connection</code> object that is this rowset's
0050: * current connection to the database. This field is set
0051: * internally when the connection is established.
0052: */
0053: private Connection conn;
0054:
0055: /**
0056: * The <code>PreparedStatement</code> object that is this rowset's
0057: * current command. This field is set internally when the method
0058: * <code>execute</code> creates the <code>PreparedStatement</code>
0059: * object.
0060: */
0061: private PreparedStatement ps;
0062:
0063: /**
0064: * The <code>ResultSet</code> object that is this rowset's
0065: * current result set. This field is set internally when the method
0066: * <code>execute</code> executes the rowset's command and thereby
0067: * creates the rowset's <code>ResultSet</code> object.
0068: */
0069: private ResultSet rs;
0070:
0071: /**
0072: * The <code>RowSetMetaDataImpl</code> object that is contructed when
0073: * a <code>ResultSet</code> object is passed to the <code>JdbcRowSet</code>
0074: * constructor. This helps in constructing all metadata associated
0075: * with the <code>ResultSet</code> object using the setter methods of
0076: * <code>RowSetMetaDataImpl</code>.
0077: */
0078: private RowSetMetaDataImpl rowsMD;
0079:
0080: /**
0081: * The <code>ResultSetMetaData</code> object from which this
0082: * <code>RowSetMetaDataImpl</code> is formed and which helps in getting
0083: * the metadata information.
0084: */
0085: private ResultSetMetaData resMD;
0086:
0087: /**
0088: * The property that helps to fire the property changed event when certain
0089: * properties are changed in the <code>JdbcRowSet</code> object. This property
0090: * is being added to satisfy Rave requirements.
0091: */
0092: private PropertyChangeSupport propertyChangeSupport;
0093:
0094: /**
0095: * The Vector holding the Match Columns
0096: */
0097: private Vector iMatchColumns;
0098:
0099: /**
0100: * The Vector that will hold the Match Column names.
0101: */
0102: private Vector strMatchColumns;
0103:
0104: protected transient JdbcRowSetResourceBundle jdbcResBundle;
0105:
0106: /**
0107: * Constructs a default <code>JdbcRowSet</code> object.
0108: * The new instance of <code>JdbcRowSet</code> will serve as a proxy
0109: * for the <code>ResultSet</code> object it creates, and by so doing,
0110: * it will make it possible to use the result set as a JavaBeans
0111: * component.
0112: * <P>
0113: * The following is true of a default <code>JdbcRowSet</code> instance:
0114: * <UL>
0115: * <LI>Does not show deleted rows
0116: * <LI>Has no time limit for how long a driver may take to
0117: * execute the rowset's command
0118: * <LI>Has no limit for the number of rows it may contain
0119: * <LI>Has no limit for the number of bytes a column may contain
0120: * <LI>Has a scrollable cursor and does not show changes
0121: * made by others
0122: * <LI>Will not see uncommitted data (make "dirty" reads)
0123: * <LI>Has escape processing turned on
0124: * <LI>Has its connection's type map set to <code>null</code>
0125: * <LI>Has an empty <code>Hashtable</code> object for storing any
0126: * parameters that are set
0127: * </UL>
0128: * A newly created <code>JdbcRowSet</code> object must have its
0129: * <code>execute</code> method invoked before other public methods
0130: * are called on it; otherwise, such method calls will cause an
0131: * exception to be thrown.
0132: *
0133: * @throws SQLException [1] if any of its public methods are called prior
0134: * to calling the <code>execute</code> method; [2] if invalid JDBC driver
0135: * properties are set or [3] if no connection to a data source exists.
0136: */
0137: public JdbcRowSetImpl() {
0138: conn = null;
0139: ps = null;
0140: rs = null;
0141:
0142: try {
0143: jdbcResBundle = JdbcRowSetResourceBundle
0144: .getJdbcRowSetResourceBundle();
0145: } catch (IOException ioe) {
0146: throw new RuntimeException(ioe);
0147: }
0148:
0149: propertyChangeSupport = new PropertyChangeSupport(this );
0150:
0151: initParams();
0152:
0153: // set the defaults
0154:
0155: try {
0156: setShowDeleted(false);
0157: } catch (SQLException sqle) {
0158: System.err.println(jdbcResBundle.handleGetObject(
0159: "jdbcrowsetimpl.setshowdeleted").toString()
0160: + sqle.getLocalizedMessage());
0161: }
0162:
0163: try {
0164: setQueryTimeout(0);
0165: } catch (SQLException sqle) {
0166: System.err.println(jdbcResBundle.handleGetObject(
0167: "jdbcrowsetimpl.setquerytimeout").toString()
0168: + sqle.getLocalizedMessage());
0169: }
0170:
0171: try {
0172: setMaxRows(0);
0173: } catch (SQLException sqle) {
0174: System.err.println(jdbcResBundle.handleGetObject(
0175: "jdbcrowsetimpl.setmaxrows").toString()
0176: + sqle.getLocalizedMessage());
0177: }
0178:
0179: try {
0180: setMaxFieldSize(0);
0181: } catch (SQLException sqle) {
0182: System.err.println(jdbcResBundle.handleGetObject(
0183: "jdbcrowsetimpl.setmaxfieldsize").toString()
0184: + sqle.getLocalizedMessage());
0185: }
0186:
0187: try {
0188: setEscapeProcessing(true);
0189: } catch (SQLException sqle) {
0190: System.err.println(jdbcResBundle.handleGetObject(
0191: "jdbcrowsetimpl.setescapeprocessing").toString()
0192: + sqle.getLocalizedMessage());
0193: }
0194:
0195: try {
0196: setConcurrency(ResultSet.CONCUR_UPDATABLE);
0197: } catch (SQLException sqle) {
0198: System.err.println(jdbcResBundle.handleGetObject(
0199: "jdbcrowsetimpl.setconcurrency").toString()
0200: + sqle.getLocalizedMessage());
0201: }
0202:
0203: setTypeMap(null);
0204:
0205: try {
0206: setType(ResultSet.TYPE_SCROLL_INSENSITIVE);
0207: } catch (SQLException sqle) {
0208: System.err.println(jdbcResBundle.handleGetObject(
0209: "jdbcrowsetimpl.settype").toString()
0210: + sqle.getLocalizedMessage());
0211: }
0212:
0213: setReadOnly(true);
0214:
0215: try {
0216: setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
0217: } catch (SQLException sqle) {
0218: System.err.println(jdbcResBundle.handleGetObject(
0219: "jdbcrowsetimpl.settransactionisolation")
0220: .toString()
0221: + sqle.getLocalizedMessage());
0222: }
0223:
0224: //Instantiating the vector for MatchColumns
0225:
0226: iMatchColumns = new Vector(10);
0227: for (int i = 0; i < 10; i++) {
0228: iMatchColumns.add(i, new Integer(-1));
0229: }
0230:
0231: strMatchColumns = new Vector(10);
0232: for (int j = 0; j < 10; j++) {
0233: strMatchColumns.add(j, null);
0234: }
0235: }
0236:
0237: /**
0238: * Constructs a default <code>JdbcRowSet</code> object given a
0239: * valid <code>Connection</code> object. The new
0240: * instance of <code>JdbcRowSet</code> will serve as a proxy for
0241: * the <code>ResultSet</code> object it creates, and by so doing,
0242: * it will make it possible to use the result set as a JavaBeans
0243: * component.
0244: * <P>
0245: * The following is true of a default <code>JdbcRowSet</code> instance:
0246: * <UL>
0247: * <LI>Does not show deleted rows
0248: * <LI>Has no time limit for how long a driver may take to
0249: * execute the rowset's command
0250: * <LI>Has no limit for the number of rows it may contain
0251: * <LI>Has no limit for the number of bytes a column may contain
0252: * <LI>Has a scrollable cursor and does not show changes
0253: * made by others
0254: * <LI>Will not see uncommitted data (make "dirty" reads)
0255: * <LI>Has escape processing turned on
0256: * <LI>Has its connection's type map set to <code>null</code>
0257: * <LI>Has an empty <code>Hashtable</code> object for storing any
0258: * parameters that are set
0259: * </UL>
0260: * A newly created <code>JdbcRowSet</code> object must have its
0261: * <code>execute</code> method invoked before other public methods
0262: * are called on it; otherwise, such method calls will cause an
0263: * exception to be thrown.
0264: *
0265: * @throws SQLException [1] if any of its public methods are called prior
0266: * to calling the <code>execute</code> method, [2] if invalid JDBC driver
0267: * properties are set, or [3] if no connection to a data source exists.
0268: */
0269: public JdbcRowSetImpl(Connection con) throws SQLException {
0270:
0271: conn = con;
0272: ps = null;
0273: rs = null;
0274:
0275: try {
0276: jdbcResBundle = JdbcRowSetResourceBundle
0277: .getJdbcRowSetResourceBundle();
0278: } catch (IOException ioe) {
0279: throw new RuntimeException(ioe);
0280: }
0281:
0282: propertyChangeSupport = new PropertyChangeSupport(this );
0283:
0284: initParams();
0285: // set the defaults
0286: setShowDeleted(false);
0287: setQueryTimeout(0);
0288: setMaxRows(0);
0289: setMaxFieldSize(0);
0290:
0291: setParams();
0292:
0293: setReadOnly(true);
0294: setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
0295: setEscapeProcessing(true);
0296: setTypeMap(null);
0297:
0298: //Instantiating the vector for MatchColumns
0299:
0300: iMatchColumns = new Vector(10);
0301: for (int i = 0; i < 10; i++) {
0302: iMatchColumns.add(i, new Integer(-1));
0303: }
0304:
0305: strMatchColumns = new Vector(10);
0306: for (int j = 0; j < 10; j++) {
0307: strMatchColumns.add(j, null);
0308: }
0309: }
0310:
0311: /**
0312: * Constructs a default <code>JdbcRowSet</code> object using the
0313: * URL, username, and password arguments supplied. The new
0314: * instance of <code>JdbcRowSet</code> will serve as a proxy for
0315: * the <code>ResultSet</code> object it creates, and by so doing,
0316: * it will make it possible to use the result set as a JavaBeans
0317: * component.
0318: *
0319: * <P>
0320: * The following is true of a default <code>JdbcRowSet</code> instance:
0321: * <UL>
0322: * <LI>Does not show deleted rows
0323: * <LI>Has no time limit for how long a driver may take to
0324: * execute the rowset's command
0325: * <LI>Has no limit for the number of rows it may contain
0326: * <LI>Has no limit for the number of bytes a column may contain
0327: * <LI>Has a scrollable cursor and does not show changes
0328: * made by others
0329: * <LI>Will not see uncommitted data (make "dirty" reads)
0330: * <LI>Has escape processing turned on
0331: * <LI>Has its connection's type map set to <code>null</code>
0332: * <LI>Has an empty <code>Hashtable</code> object for storing any
0333: * parameters that are set
0334: * </UL>
0335: *
0336: * @param url - a JDBC URL for the database to which this <code>JdbcRowSet</code>
0337: * object will be connected. The form for a JDBC URL is
0338: * <code>jdbc:subprotocol:subname</code>.
0339: * @param user - the database user on whose behalf the connection
0340: * is being made
0341: * @param password - the user's password
0342: *
0343: * @throws SQLException if a database access error occurs
0344: *
0345: */
0346: public JdbcRowSetImpl(String url, String user, String password)
0347: throws SQLException {
0348: conn = null;
0349: ps = null;
0350: rs = null;
0351:
0352: try {
0353: jdbcResBundle = JdbcRowSetResourceBundle
0354: .getJdbcRowSetResourceBundle();
0355: } catch (IOException ioe) {
0356: throw new RuntimeException(ioe);
0357: }
0358:
0359: propertyChangeSupport = new PropertyChangeSupport(this );
0360:
0361: initParams();
0362:
0363: // Pass the arguments to BaseRowSet
0364: // setter methods now.
0365:
0366: setUsername(user);
0367: setPassword(password);
0368: setUrl(url);
0369:
0370: // set the defaults
0371: setShowDeleted(false);
0372: setQueryTimeout(0);
0373: setMaxRows(0);
0374: setMaxFieldSize(0);
0375:
0376: // to ensure connection to a db call connect now
0377: // and associate a conn with "this" object
0378: // in this case.
0379: conn = connect();
0380: setParams();
0381:
0382: setReadOnly(true);
0383: setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
0384: setEscapeProcessing(true);
0385: setTypeMap(null);
0386:
0387: //Instantiating the vector for MatchColumns
0388:
0389: iMatchColumns = new Vector(10);
0390: for (int i = 0; i < 10; i++) {
0391: iMatchColumns.add(i, new Integer(-1));
0392: }
0393:
0394: strMatchColumns = new Vector(10);
0395: for (int j = 0; j < 10; j++) {
0396: strMatchColumns.add(j, null);
0397: }
0398: }
0399:
0400: /**
0401: * Constructs a <code>JdbcRowSet</code> object using the given valid
0402: * <code>ResultSet</code> object. The new
0403: * instance of <code>JdbcRowSet</code> will serve as a proxy for
0404: * the <code>ResultSet</code> object, and by so doing,
0405: * it will make it possible to use the result set as a JavaBeans
0406: * component.
0407: *
0408: * <P>
0409: * The following is true of a default <code>JdbcRowSet</code> instance:
0410: * <UL>
0411: * <LI>Does not show deleted rows
0412: * <LI>Has no time limit for how long a driver may take to
0413: * execute the rowset's command
0414: * <LI>Has no limit for the number of rows it may contain
0415: * <LI>Has no limit for the number of bytes a column may contain
0416: * <LI>Has a scrollable cursor and does not show changes
0417: * made by others
0418: * <LI>Will not see uncommitted data (make "dirty" reads)
0419: * <LI>Has escape processing turned on
0420: * <LI>Has its connection's type map set to <code>null</code>
0421: * <LI>Has an empty <code>Hashtable</code> object for storing any
0422: * parameters that are set
0423: * </UL>
0424: *
0425: * @param res a valid <code>ResultSet</code> object
0426: *
0427: * @throws SQLException if a database access occurs due to a non
0428: * valid ResultSet handle.
0429: */
0430: public JdbcRowSetImpl(ResultSet res) throws SQLException {
0431:
0432: // A ResultSet handle encapsulates a connection handle.
0433: // But there is no way we can retrieve a Connection handle
0434: // from a ResultSet object.
0435: // So to avoid any anomalies we keep the conn = null
0436: // The passed rs handle will be a wrapper around for
0437: // "this" object's all operations.
0438: conn = null;
0439:
0440: ps = null;
0441:
0442: rs = res;
0443:
0444: try {
0445: jdbcResBundle = JdbcRowSetResourceBundle
0446: .getJdbcRowSetResourceBundle();
0447: } catch (IOException ioe) {
0448: throw new RuntimeException(ioe);
0449: }
0450:
0451: propertyChangeSupport = new PropertyChangeSupport(this );
0452:
0453: initParams();
0454:
0455: // get the values from the resultset handle.
0456: setShowDeleted(false);
0457: setQueryTimeout(0);
0458: setMaxRows(0);
0459: setMaxFieldSize(0);
0460:
0461: setParams();
0462:
0463: setReadOnly(true);
0464: setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
0465: setEscapeProcessing(true);
0466: setTypeMap(null);
0467:
0468: // Get a handle to ResultSetMetaData
0469: // Construct RowSetMetaData out of it.
0470:
0471: resMD = rs.getMetaData();
0472:
0473: rowsMD = new RowSetMetaDataImpl();
0474:
0475: initMetaData(rowsMD, resMD);
0476:
0477: //Instantiating the vector for MatchColumns
0478:
0479: iMatchColumns = new Vector(10);
0480: for (int i = 0; i < 10; i++) {
0481: iMatchColumns.add(i, new Integer(-1));
0482: }
0483:
0484: strMatchColumns = new Vector(10);
0485: for (int j = 0; j < 10; j++) {
0486: strMatchColumns.add(j, null);
0487: }
0488: }
0489:
0490: /**
0491: * Initializes the given <code>RowSetMetaData</code> object with the values
0492: * in the given <code>ResultSetMetaData</code> object.
0493: *
0494: * @param md the <code>RowSetMetaData</code> object for this
0495: * <code>JdbcRowSetImpl</code> object, which will be set with
0496: * values from rsmd
0497: * @param rsmd the <code>ResultSetMetaData</code> object from which new
0498: * values for md will be read
0499: * @throws SQLException if an error occurs
0500: */
0501: protected void initMetaData(RowSetMetaData md,
0502: ResultSetMetaData rsmd) throws SQLException {
0503: int numCols = rsmd.getColumnCount();
0504:
0505: md.setColumnCount(numCols);
0506: for (int col = 1; col <= numCols; col++) {
0507: md.setAutoIncrement(col, rsmd.isAutoIncrement(col));
0508: md.setCaseSensitive(col, rsmd.isCaseSensitive(col));
0509: md.setCurrency(col, rsmd.isCurrency(col));
0510: md.setNullable(col, rsmd.isNullable(col));
0511: md.setSigned(col, rsmd.isSigned(col));
0512: md.setSearchable(col, rsmd.isSearchable(col));
0513: md
0514: .setColumnDisplaySize(col, rsmd
0515: .getColumnDisplaySize(col));
0516: md.setColumnLabel(col, rsmd.getColumnLabel(col));
0517: md.setColumnName(col, rsmd.getColumnName(col));
0518: md.setSchemaName(col, rsmd.getSchemaName(col));
0519: md.setPrecision(col, rsmd.getPrecision(col));
0520: md.setScale(col, rsmd.getScale(col));
0521: md.setTableName(col, rsmd.getTableName(col));
0522: md.setCatalogName(col, rsmd.getCatalogName(col));
0523: md.setColumnType(col, rsmd.getColumnType(col));
0524: md.setColumnTypeName(col, rsmd.getColumnTypeName(col));
0525: }
0526: }
0527:
0528: protected void checkState() throws SQLException {
0529:
0530: // If all the three i.e. conn, ps & rs are
0531: // simultaneously null implies we are not connected
0532: // to the db, implies undesirable state so throw exception
0533:
0534: if (conn == null && ps == null && rs == null) {
0535: throw new SQLException(jdbcResBundle.handleGetObject(
0536: "jdbcrowsetimpl.invalstate").toString());
0537: }
0538: }
0539:
0540: //---------------------------------------------------------------------
0541: // Reading and writing data
0542: //---------------------------------------------------------------------
0543:
0544: /**
0545: * Creates the internal <code>ResultSet</code> object for which this
0546: * <code>JdbcRowSet</code> object is a wrapper, effectively
0547: * making the result set a JavaBeans component.
0548: * <P>
0549: * Certain properties must have been set before this method is called
0550: * so that it can establish a connection to a database and execute the
0551: * query that will create the result set. If a <code>DataSource</code>
0552: * object will be used to create the connection, properties for the
0553: * data source name, user name, and password must be set. If the
0554: * <code>DriverManager</code> will be used, the properties for the
0555: * URL, user name, and password must be set. In either case, the
0556: * property for the command must be set. If the command has placeholder
0557: * parameters, those must also be set. This method throws
0558: * an exception if the required properties are not set.
0559: * <P>
0560: * Other properties have default values that may optionally be set
0561: * to new values. The <code>execute</code> method will use the value
0562: * for the command property to create a <code>PreparedStatement</code>
0563: * object and set its properties (escape processing, maximum field
0564: * size, maximum number of rows, and query timeout limit) to be those
0565: * of this rowset.
0566: *
0567: * @throws SQLException if (1) a database access error occurs,
0568: * (2) any required JDBC properties are not set, or (3) if an
0569: * invalid connection exists.
0570: */
0571: public void execute() throws SQLException {
0572: /*
0573: * To execute based on the properties:
0574: * i) determine how to get a connection
0575: * ii) prepare the statement
0576: * iii) set the properties of the statement
0577: * iv) parse the params. and set them
0578: * v) execute the statement
0579: *
0580: * During all of this try to tolerate as many errors
0581: * as possible, many drivers will not support all of
0582: * the properties and will/should throw SQLException
0583: * at us...
0584: *
0585: */
0586:
0587: prepare();
0588:
0589: // set the properties of our shiny new statement
0590: setProperties(ps);
0591:
0592: // set the parameters
0593: decodeParams(getParams(), ps);
0594:
0595: // execute the statement
0596: rs = ps.executeQuery();
0597:
0598: // notify listeners
0599: notifyRowSetChanged();
0600:
0601: }
0602:
0603: protected void setProperties(PreparedStatement ps)
0604: throws SQLException {
0605:
0606: try {
0607: ps.setEscapeProcessing(getEscapeProcessing());
0608: } catch (SQLException ex) {
0609: System.err.println(jdbcResBundle.handleGetObject(
0610: "jdbcrowsetimpl.setescapeprocessing").toString()
0611: + ex.getLocalizedMessage());
0612: }
0613:
0614: try {
0615: ps.setMaxFieldSize(getMaxFieldSize());
0616: } catch (SQLException ex) {
0617: System.err.println(jdbcResBundle.handleGetObject(
0618: "jdbcrowsetimpl.setmaxfieldsize").toString()
0619: + ex.getLocalizedMessage());
0620: }
0621:
0622: try {
0623: ps.setMaxRows(getMaxRows());
0624: } catch (SQLException ex) {
0625: System.err.println(jdbcResBundle.handleGetObject(
0626: "jdbcrowsetimpl.setmaxrows").toString()
0627: + ex.getLocalizedMessage());
0628: }
0629:
0630: try {
0631: ps.setQueryTimeout(getQueryTimeout());
0632: } catch (SQLException ex) {
0633: System.err.println(jdbcResBundle.handleGetObject(
0634: "jdbcrowsetimpl.setquerytimeout").toString()
0635: + ex.getLocalizedMessage());
0636: }
0637:
0638: }
0639:
0640: // An alternate solution is required instead of having the
0641: // connect method as protected.
0642: // This is a work around to assist Rave Team
0643: // :ah
0644:
0645: protected Connection connect() throws SQLException {
0646:
0647: // Get a JDBC connection.
0648:
0649: // First check for Connection handle object as such if
0650: // "this" initialized using conn.
0651:
0652: if (conn != null) {
0653: return conn;
0654:
0655: } else if (getDataSourceName() != null) {
0656:
0657: // Connect using JNDI.
0658: try {
0659: Context ctx = new InitialContext();
0660: DataSource ds = (DataSource) ctx
0661: .lookup(getDataSourceName());
0662: //return ds.getConnection(getUsername(),getPassword());
0663:
0664: if (getUsername() != null && !getUsername().equals("")) {
0665: return ds.getConnection(getUsername(),
0666: getPassword());
0667: } else {
0668: return ds.getConnection();
0669: }
0670: } catch (javax.naming.NamingException ex) {
0671: throw new SQLException(jdbcResBundle.handleGetObject(
0672: "jdbcrowsetimpl.connect").toString());
0673: }
0674:
0675: } else if (getUrl() != null) {
0676: // Check only for getUrl() != null because
0677: // user, passwd can be null
0678: // Connect using the driver manager.
0679:
0680: return DriverManager.getConnection(getUrl(), getUsername(),
0681: getPassword());
0682: } else {
0683: return null;
0684: }
0685:
0686: }
0687:
0688: protected PreparedStatement prepare() throws SQLException {
0689: // get a connection
0690: conn = connect();
0691:
0692: try {
0693:
0694: Map aMap = getTypeMap();
0695: if (aMap != null) {
0696: conn.setTypeMap(aMap);
0697: }
0698: ps = conn.prepareStatement(getCommand(),
0699: ResultSet.TYPE_SCROLL_INSENSITIVE,
0700: ResultSet.CONCUR_UPDATABLE);
0701: } catch (SQLException ex) {
0702: System.err.println(jdbcResBundle.handleGetObject(
0703: "jdbcrowsetimpl.prepare").toString()
0704: + ex.getLocalizedMessage());
0705:
0706: if (ps != null)
0707: ps.close();
0708: if (conn != null)
0709: conn.close();
0710:
0711: throw new SQLException(ex.getMessage());
0712: }
0713:
0714: return ps;
0715: }
0716:
0717: private void decodeParams(Object[] params, PreparedStatement ps)
0718: throws SQLException {
0719:
0720: // There is a corresponding decodeParams in JdbcRowSetImpl
0721: // which does the same as this method. This is a design flaw.
0722: // Update the CachedRowsetReader.decodeParams when you update
0723: // this method.
0724:
0725: // Adding the same comments to CachedRowsetReader.decodeParams.
0726:
0727: int arraySize;
0728: Object[] param = null;
0729:
0730: for (int i = 0; i < params.length; i++) {
0731: if (params[i] instanceof Object[]) {
0732: param = (Object[]) params[i];
0733:
0734: if (param.length == 2) {
0735: if (param[0] == null) {
0736: ps.setNull(i + 1, ((Integer) param[1])
0737: .intValue());
0738: continue;
0739: }
0740:
0741: if (param[0] instanceof java.sql.Date
0742: || param[0] instanceof java.sql.Time
0743: || param[0] instanceof java.sql.Timestamp) {
0744: System.err
0745: .println(jdbcResBundle
0746: .handleGetObject("jdbcrowsetimpl.detecteddate"));
0747: if (param[1] instanceof java.util.Calendar) {
0748: System.err
0749: .println(jdbcResBundle
0750: .handleGetObject("jdbcrowsetimpl.detectedcalendar"));
0751: ps.setDate(i + 1, (java.sql.Date) param[0],
0752: (java.util.Calendar) param[1]);
0753: continue;
0754: } else {
0755: throw new SQLException(jdbcResBundle
0756: .handleGetObject(
0757: "jdbcrowsetimpl.paramtype")
0758: .toString());
0759: }
0760: }
0761:
0762: if (param[0] instanceof Reader) {
0763: ps.setCharacterStream(i + 1, (Reader) param[0],
0764: ((Integer) param[1]).intValue());
0765: continue;
0766: }
0767:
0768: /*
0769: * What's left should be setObject(int, Object, scale)
0770: */
0771: if (param[1] instanceof Integer) {
0772: ps.setObject(i + 1, param[0],
0773: ((Integer) param[1]).intValue());
0774: continue;
0775: }
0776:
0777: } else if (param.length == 3) {
0778:
0779: if (param[0] == null) {
0780: ps.setNull(i + 1, ((Integer) param[1])
0781: .intValue(), (String) param[2]);
0782: continue;
0783: }
0784:
0785: if (param[0] instanceof java.io.InputStream) {
0786: switch (((Integer) param[2]).intValue()) {
0787: case JdbcRowSetImpl.UNICODE_STREAM_PARAM:
0788: ps.setUnicodeStream(i + 1,
0789: (java.io.InputStream) param[0],
0790: ((Integer) param[1]).intValue());
0791: case JdbcRowSetImpl.BINARY_STREAM_PARAM:
0792: ps.setBinaryStream(i + 1,
0793: (java.io.InputStream) param[0],
0794: ((Integer) param[1]).intValue());
0795: case JdbcRowSetImpl.ASCII_STREAM_PARAM:
0796: ps.setAsciiStream(i + 1,
0797: (java.io.InputStream) param[0],
0798: ((Integer) param[1]).intValue());
0799: default:
0800: throw new SQLException(jdbcResBundle
0801: .handleGetObject(
0802: "jdbcrowsetimpl.paramtype")
0803: .toString());
0804: }
0805: }
0806:
0807: /*
0808: * no point at looking at the first element now;
0809: * what's left must be the setObject() cases.
0810: */
0811: if (param[1] instanceof Integer
0812: && param[2] instanceof Integer) {
0813: ps.setObject(i + 1, param[0],
0814: ((Integer) param[1]).intValue(),
0815: ((Integer) param[2]).intValue());
0816: continue;
0817: }
0818:
0819: throw new SQLException(
0820: jdbcResBundle.handleGetObject(
0821: "jdbcrowsetimpl.paramtype")
0822: .toString());
0823:
0824: } else {
0825: // common case - this catches all SQL92 types
0826: ps.setObject(i + 1, params[i]);
0827: continue;
0828: }
0829: } else {
0830: // Try to get all the params to be set here
0831: ps.setObject(i + 1, params[i]);
0832:
0833: }
0834: }
0835: }
0836:
0837: /**
0838: * Moves the cursor for this rowset's <code>ResultSet</code>
0839: * object down one row from its current position.
0840: * A <code>ResultSet</code> cursor is initially positioned
0841: * before the first row; the first call to the method
0842: * <code>next</code> makes the first row the current row; the
0843: * second call makes the second row the current row, and so on.
0844: *
0845: * <P>If an input stream is open for the current row, a call
0846: * to the method <code>next</code> will
0847: * implicitly close it. A <code>ResultSet</code> object's
0848: * warning chain is cleared when a new row is read.
0849: *
0850: * @return <code>true</code> if the new current row is valid;
0851: * <code>false</code> if there are no more rows
0852: * @throws SQLException if a database access error occurs
0853: * or this rowset does not currently have a valid connection,
0854: * prepared statement, and result set
0855: */
0856: public boolean next() throws SQLException {
0857: checkState();
0858:
0859: boolean b = rs.next();
0860: notifyCursorMoved();
0861: return b;
0862: }
0863:
0864: /**
0865: * Releases this rowset's <code>ResultSet</code> object's database and
0866: * JDBC resources immediately instead of waiting for
0867: * this to happen when it is automatically closed.
0868: *
0869: * <P><B>Note:</B> A <code>ResultSet</code> object
0870: * is automatically closed by the
0871: * <code>Statement</code> object that generated it when
0872: * that <code>Statement</code> object is closed,
0873: * re-executed, or is used to retrieve the next result from a
0874: * sequence of multiple results. A <code>ResultSet</code> object
0875: * is also automatically closed when it is garbage collected.
0876: *
0877: * @throws SQLException if a database access error occurs
0878: */
0879: public void close() throws SQLException {
0880: if (rs != null)
0881: rs.close();
0882: if (ps != null)
0883: ps.close();
0884: if (conn != null)
0885: conn.close();
0886: }
0887:
0888: /**
0889: * Reports whether the last column read from this rowset's
0890: * <code>ResultSet</code> object had a value of SQL <code>NULL</code>.
0891: * Note that you must first call one of the <code>getXXX</code> methods
0892: * on a column to try to read its value and then call
0893: * the method <code>wasNull</code> to see if the value read was
0894: * SQL <code>NULL</code>.
0895: *
0896: * @return <code>true</code> if the last column value read was SQL
0897: * <code>NULL</code> and <code>false</code> otherwise
0898: * @throws SQLException if a database access error occurs
0899: * or this rowset does not have a currently valid connection,
0900: * prepared statement, and result set
0901: */
0902: public boolean wasNull() throws SQLException {
0903: checkState();
0904:
0905: return rs.wasNull();
0906: }
0907:
0908: //======================================================================
0909: // Methods for accessing results by column index
0910: //======================================================================
0911:
0912: /**
0913: * Gets the value of the designated column in the current row
0914: * of this rowset's <code>ResultSet</code> object as
0915: * a <code>String</code>.
0916: *
0917: * @param columnIndex the first column is 1, the second is 2, and so on
0918: * @return the column value; if the value is SQL <code>NULL</code>, the
0919: * value returned is <code>null</code>
0920: * @throws SQLException if (1) a database access error occurs
0921: * or (2) this rowset does not currently have a valid connection,
0922: * prepared statement, and result set
0923: */
0924: public String getString(int columnIndex) throws SQLException {
0925: checkState();
0926:
0927: return rs.getString(columnIndex);
0928: }
0929:
0930: /**
0931: * Gets the value of the designated column in the current row
0932: * of this rowset's <code>ResultSet</code> object as
0933: * a <code>boolean</code>.
0934: *
0935: * @param columnIndex the first column is 1, the second is 2, and so on
0936: * @return the column value; if the value is SQL <code>NULL</code>, the
0937: * value returned is <code>false</code>
0938: * @throws SQLException if (1) a database access error occurs
0939: * or (2) this rowset does not have a currently valid connection,
0940: * prepared statement, and result set
0941: */
0942: public boolean getBoolean(int columnIndex) throws SQLException {
0943: checkState();
0944:
0945: return rs.getBoolean(columnIndex);
0946: }
0947:
0948: /**
0949: * Gets the value of the designated column in the current row
0950: * of this rowset's <code>ResultSet</code> object as
0951: * a <code>byte</code>.
0952: *
0953: * @param columnIndex the first column is 1, the second is 2, and so on
0954: * @return the column value; if the value is SQL <code>NULL</code>, the
0955: * value returned is <code>0</code>
0956: * @throws SQLException if (1) a database access error occurs
0957: * or (2) this rowset does not have a currently valid connection,
0958: * prepared statement, and result set
0959: */
0960: public byte getByte(int columnIndex) throws SQLException {
0961: checkState();
0962:
0963: return rs.getByte(columnIndex);
0964: }
0965:
0966: /**
0967: * Gets the value of the designated column in the current row
0968: * of this rowset's <code>ResultSet</code> object as
0969: * a <code>short</code>.
0970: *
0971: * @param columnIndex the first column is 1, the second is 2, and so on
0972: * @return the column value; if the value is SQL <code>NULL</code>, the
0973: * value returned is <code>0</code>
0974: * @throws SQLException if (1) a database access error occurs
0975: * or (2) this rowset does not have a currently valid connection,
0976: * prepared statement, and result set
0977: */
0978: public short getShort(int columnIndex) throws SQLException {
0979: checkState();
0980:
0981: return rs.getShort(columnIndex);
0982: }
0983:
0984: /**
0985: * Gets the value of the designated column in the current row
0986: * of this rowset's <code>ResultSet</code> object as
0987: * an <code>int</code>.
0988: *
0989: * @param columnIndex the first column is 1, the second is 2, and so on
0990: * @return the column value; if the value is SQL <code>NULL</code>, the
0991: * value returned is <code>0</code>
0992: * @throws SQLException if (1) a database access error occurs
0993: * or (2) this rowset does not have a currently valid connection,
0994: * prepared statement, and result set
0995: */
0996: public int getInt(int columnIndex) throws SQLException {
0997: checkState();
0998:
0999: return rs.getInt(columnIndex);
1000: }
1001:
1002: /**
1003: * Gets the value of the designated column in the current row
1004: * of this rowset's <code>ResultSet</code> object as
1005: * a <code>long</code>.
1006: *
1007: * @param columnIndex the first column is 1, the second is 2, and so on
1008: * @return the column value; if the value is SQL <code>NULL</code>, the
1009: * value returned is <code>0</code>
1010: * @throws SQLException if (1) a database access error occurs
1011: * or (2) this rowset does not have a currently valid connection,
1012: * prepared statement, and result set
1013: */
1014: public long getLong(int columnIndex) throws SQLException {
1015: checkState();
1016:
1017: return rs.getLong(columnIndex);
1018: }
1019:
1020: /**
1021: * Gets the value of the designated column in the current row
1022: * of this rowset's <code>ResultSet</code> object as
1023: * a <code>float</code>.
1024: *
1025: * @param columnIndex the first column is 1, the second is 2, and so on
1026: * @return the column value; if the value is SQL <code>NULL</code>, the
1027: * value returned is <code>0</code>
1028: * @throws SQLException if (1) a database access error occurs
1029: * or (2) this rowset does not have a currently valid connection,
1030: * prepared statement, and result set
1031: */
1032: public float getFloat(int columnIndex) throws SQLException {
1033: checkState();
1034:
1035: return rs.getFloat(columnIndex);
1036: }
1037:
1038: /**
1039: * Gets the value of the designated column in the current row
1040: * of this rowset's <code>ResultSet</code> object as
1041: * a <code>double</code>.
1042: *
1043: * @param columnIndex the first column is 1, the second is 2, and so on
1044: * @return the column value; if the value is SQL <code>NULL</code>, the
1045: * value returned is <code>0</code>
1046: * @throws SQLException if (1) a database access error occurs
1047: * or (2) this rowset does not have a currently valid connection,
1048: * prepared statement, and result set
1049: */
1050: public double getDouble(int columnIndex) throws SQLException {
1051: checkState();
1052:
1053: return rs.getDouble(columnIndex);
1054: }
1055:
1056: /**
1057: * Gets the value of the designated column in the current row
1058: * of this rowset's <code>ResultSet</code> object as
1059: * a <code>java.sql.BigDecimal</code>.
1060: *
1061: * @param columnIndex the first column is 1, the second is 2, and so on
1062: * @param scale the number of digits to the right of the decimal point
1063: * @return the column value; if the value is SQL <code>NULL</code>, the
1064: * value returned is <code>null</code>
1065: * @throws SQLException if (1) database access error occurs
1066: * or (2) this rowset does not have a currently valid connection,
1067: * prepared statement, and result set
1068: * @deprecated
1069: */
1070: public BigDecimal getBigDecimal(int columnIndex, int scale)
1071: throws SQLException {
1072: checkState();
1073:
1074: return rs.getBigDecimal(columnIndex, scale);
1075: }
1076:
1077: /**
1078: * Gets the value of the designated column in the current row
1079: * of this rowset's <code>ResultSet</code> object as
1080: * a <code>byte</code> array in the Java programming language.
1081: * The bytes represent the raw values returned by the driver.
1082: *
1083: * @param columnIndex the first column is 1, the second is 2, and so on
1084: * @return the column value; if the value is SQL <code>NULL</code>, the
1085: * value returned is <code>null</code>
1086: * @throws SQLException if (1) a database access error occurs
1087: * or (2) this rowset does not have a currently valid connection,
1088: * prepared statement, and result set
1089: */
1090: public byte[] getBytes(int columnIndex) throws SQLException {
1091: checkState();
1092:
1093: return rs.getBytes(columnIndex);
1094: }
1095:
1096: /**
1097: * Gets the value of the designated column in the current row
1098: * of this rowset's <code>ResultSet</code> object as
1099: * a <code>java.sql.Date</code> object in the Java programming language.
1100: *
1101: * @param columnIndex the first column is 1, the second is 2, and so on
1102: * @return the column value; if the value is SQL <code>NULL</code>, the
1103: * value returned is <code>null</code>
1104: * @throws SQLException if (1) a database access error occurs
1105: * or (2) this rowset does not have a currently valid connection,
1106: * prepared statement, and result set
1107: */
1108: public java.sql.Date getDate(int columnIndex) throws SQLException {
1109: checkState();
1110:
1111: return rs.getDate(columnIndex);
1112: }
1113:
1114: /**
1115: * Gets the value of the designated column in the current row
1116: * of this rowset's <code>ResultSet</code> object as
1117: * a <code>java.sql.Time</code> object in the Java programming language.
1118: *
1119: * @param columnIndex the first column is 1, the second is 2, and so on
1120: * @return the column value; if the value is SQL <code>NULL</code>, the
1121: * value returned is <code>null</code>
1122: * @throws SQLException if (1) a database access error occurs
1123: * or (2) this rowset does not have a currently valid connection,
1124: * prepared statement, and result set
1125: */
1126: public java.sql.Time getTime(int columnIndex) throws SQLException {
1127: checkState();
1128:
1129: return rs.getTime(columnIndex);
1130: }
1131:
1132: /**
1133: * Gets the value of the designated column in the current row
1134: * of this rowset's <code>ResultSet</code> object as
1135: * a <code>java.sql.Timestamp</code> object in the Java programming language.
1136: *
1137: * @param columnIndex the first column is 1, the second is 2, and so on
1138: * @return the column value; if the value is SQL <code>NULL</code>, the
1139: * value returned is <code>null</code>
1140: * @throws SQLException if (1) a database access error occurs
1141: * or (2) this rowset does not have a currently valid connection,
1142: * prepared statement, and result set
1143: */
1144: public java.sql.Timestamp getTimestamp(int columnIndex)
1145: throws SQLException {
1146: checkState();
1147:
1148: return rs.getTimestamp(columnIndex);
1149: }
1150:
1151: /**
1152: * Gets the value of the designated column in the current row
1153: * of this rowset's <code>ResultSet</code> object as
1154: * a stream of ASCII characters. The value can then be read in chunks from the
1155: * stream. This method is particularly
1156: * suitable for retrieving large <code>LONGVARCHAR</code> values.
1157: * The JDBC driver will
1158: * do any necessary conversion from the database format into ASCII.
1159: *
1160: * <P><B>Note:</B> All the data in the returned stream must be
1161: * read prior to getting the value of any other column. The next
1162: * call to a <code>getXXX</code> method implicitly closes the stream. Also, a
1163: * stream may return <code>0</code> when the method
1164: * <code>InputStream.available</code>
1165: * is called whether there is data available or not.
1166: *
1167: * @param columnIndex the first column is 1, the second is 2, and so on
1168: * @return a Java input stream that delivers the database column value
1169: * as a stream of one-byte ASCII characters;
1170: * if the value is SQL <code>NULL</code>, the
1171: * value returned is <code>null</code>
1172: * @throws SQLException if (1) database access error occurs
1173: * (2) this rowset does not have a currently valid connection,
1174: * prepared statement, and result set
1175: */
1176: public java.io.InputStream getAsciiStream(int columnIndex)
1177: throws SQLException {
1178: checkState();
1179:
1180: return rs.getAsciiStream(columnIndex);
1181: }
1182:
1183: /**
1184: * Gets the value of the designated column in the current row
1185: * of this rowset's <code>ResultSet</code> object as
1186: * as a stream of Unicode characters.
1187: * The value can then be read in chunks from the
1188: * stream. This method is particularly
1189: * suitable for retrieving large<code>LONGVARCHAR</code>values. The JDBC driver will
1190: * do any necessary conversion from the database format into Unicode.
1191: * The byte format of the Unicode stream must be Java UTF-8,
1192: * as specified in the Java virtual machine specification.
1193: *
1194: * <P><B>Note:</B> All the data in the returned stream must be
1195: * read prior to getting the value of any other column. The next
1196: * call to a <code>getXXX</code> method implicitly closes the stream. Also, a
1197: * stream may return <code>0</code> when the method
1198: * <code>InputStream.available</code>
1199: * is called whether there is data available or not.
1200: *
1201: * @param columnIndex the first column is 1, the second is 2, and so on
1202: * @return a Java input stream that delivers the database column value
1203: * as a stream in Java UTF-8 byte format;
1204: * if the value is SQL <code>NULL</code>, the value returned is <code>null</code>
1205: * @throws SQLException if (1) a database access error occurs
1206: * or (2) this rowset does not have a currently valid connection,
1207: * prepared statement, and result set
1208: * @deprecated use <code>getCharacterStream</code> in place of
1209: * <code>getUnicodeStream</code>
1210: */
1211: public java.io.InputStream getUnicodeStream(int columnIndex)
1212: throws SQLException {
1213: checkState();
1214:
1215: return rs.getUnicodeStream(columnIndex);
1216: }
1217:
1218: /**
1219: * Gets the value of a column in the current row as a stream of
1220: * the value of the designated column in the current row
1221: * of this rowset's <code>ResultSet</code> object as a binary stream of
1222: * uninterpreted bytes. The value can then be read in chunks from the
1223: * stream. This method is particularly
1224: * suitable for retrieving large <code>LONGVARBINARY</code> values.
1225: *
1226: * <P><B>Note:</B> All the data in the returned stream must be
1227: * read prior to getting the value of any other column. The next
1228: * call to a <code>getXXX</code> method implicitly closes the stream. Also, a
1229: * stream may return <code>0</code> when the method
1230: * <code>InputStream.available</code>
1231: * is called whether there is data available or not.
1232: *
1233: * @param columnIndex the first column is 1, the second is 2, and so on
1234: * @return a Java input stream that delivers the database column value
1235: * as a stream of uninterpreted bytes;
1236: * if the value is SQL <code>NULL</code>, the value returned is <code>null</code>
1237: * @throws SQLException if (1) a database access error occurs
1238: * or (2) this rowset does not have a currently valid connection,
1239: * prepared statement, and result set
1240: */
1241: public java.io.InputStream getBinaryStream(int columnIndex)
1242: throws SQLException {
1243: checkState();
1244:
1245: return rs.getBinaryStream(columnIndex);
1246: }
1247:
1248: //======================================================================
1249: // Methods for accessing results by column name
1250: //======================================================================
1251:
1252: /**
1253: * Gets the value of the designated column in the current row
1254: * of this rowset's <code>ResultSet</code> object as
1255: * a <code>String</code>.
1256: *
1257: * @param columnName the SQL name of the column
1258: * @return the column value; if the value is SQL <code>NULL</code>, the
1259: * value returned is <code>null</code>
1260: * @throws SQLException if (1) a database access error occurs
1261: * or (2) this rowset does not have a currently valid connection,
1262: * prepared statement, and result set
1263: */
1264: public String getString(String columnName) throws SQLException {
1265: return getString(findColumn(columnName));
1266: }
1267:
1268: /**
1269: * Gets the value of the designated column in the current row
1270: * of this rowset's <code>ResultSet</code> object as
1271: * a <code>boolean</code>.
1272: *
1273: * @param columnName the SQL name of the column
1274: * @return the column value; if the value is SQL <code>NULL</code>, the
1275: * value returned is <code>false</code>
1276: * @throws SQLException if (1) a database access error occurs
1277: * or (2) this rowset does not have a currently valid connection,
1278: * prepared statement, and result set
1279: */
1280: public boolean getBoolean(String columnName) throws SQLException {
1281: return getBoolean(findColumn(columnName));
1282: }
1283:
1284: /**
1285: * Gets the value of the designated column in the current row
1286: * of this rowset's <code>ResultSet</code> object as
1287: * a <code>byte</code>.
1288: *
1289: * @param columnName the SQL name of the column
1290: * @return the column value; if the value is SQL <code>NULL</code>, the
1291: * value returned is <code>0</code>
1292: * @throws SQLException if (1) a database access error occurs
1293: * or (2) this rowset does not have a currently valid connection,
1294: * prepared statement, and result set
1295: */
1296: public byte getByte(String columnName) throws SQLException {
1297: return getByte(findColumn(columnName));
1298: }
1299:
1300: /**
1301: * Gets the value of the designated column in the current row
1302: * of this rowset's <code>ResultSet</code> object as
1303: * a <code>short</code>.
1304: *
1305: * @param columnName the SQL name of the column
1306: * @return the column value; if the value is SQL <code>NULL</code>, the
1307: * value returned is <code>0</code>
1308: * @throws SQLException if (1) a database access error occurs
1309: * or (2) this rowset does not have a currently valid connection,
1310: * prepared statement, and result set
1311: */
1312: public short getShort(String columnName) throws SQLException {
1313: return getShort(findColumn(columnName));
1314: }
1315:
1316: /**
1317: * Gets the value of the designated column in the current row
1318: * of this rowset's <code>ResultSet</code> object as
1319: * an <code>int</code>.
1320: *
1321: * @param columnName the SQL name of the column
1322: * @return the column value; if the value is SQL <code>NULL</code>, the
1323: * value returned is <code>0</code>
1324: * @throws SQLException if (1) a database access error occurs
1325: * or (2) this rowset does not have a currently valid connection,
1326: * prepared statement, and result set
1327: */
1328: public int getInt(String columnName) throws SQLException {
1329: return getInt(findColumn(columnName));
1330: }
1331:
1332: /**
1333: * Gets the value of the designated column in the current row
1334: * of this rowset's <code>ResultSet</code> object as
1335: * a <code>long</code>.
1336: *
1337: * @param columnName the SQL name of the column
1338: * @return the column value; if the value is SQL <code>NULL</code>, the
1339: * value returned is <code>0</code>
1340: * @throws SQLException if a database access error occurs
1341: * or this rowset does not have a currently valid connection,
1342: * prepared statement, and result set
1343: */
1344: public long getLong(String columnName) throws SQLException {
1345: return getLong(findColumn(columnName));
1346: }
1347:
1348: /**
1349: * Gets the value of the designated column in the current row
1350: * of this rowset's <code>ResultSet</code> object as
1351: * a <code>float</code>.
1352: *
1353: * @param columnName the SQL name of the column
1354: * @return the column value; if the value is SQL <code>NULL</code>, the
1355: * value returned is <code>0</code>
1356: * @throws SQLException if (1) a database access error occurs
1357: * or (2) this rowset does not have a currently valid connection,
1358: * prepared statement, and result set
1359: */
1360: public float getFloat(String columnName) throws SQLException {
1361: return getFloat(findColumn(columnName));
1362: }
1363:
1364: /**
1365: * Gets the value of the designated column in the current row
1366: * of this rowset's <code>ResultSet</code> object as
1367: * a <code>double</code>.
1368: *
1369: * @param columnName the SQL name of the column
1370: * @return the column value; if the value is SQL <code>NULL</code>, the
1371: * value returned is <code>0</code>
1372: * @throws SQLException if (1) a database access error occurs
1373: * or (2) this rowset does not have a currently valid connection,
1374: * prepared statement, and result set
1375: */
1376: public double getDouble(String columnName) throws SQLException {
1377: return getDouble(findColumn(columnName));
1378: }
1379:
1380: /**
1381: * Gets the value of the designated column in the current row
1382: * of this rowset's <code>ResultSet</code> object as
1383: * a <code>java.math.BigDecimal</code>.
1384: *
1385: * @param columnName the SQL name of the column
1386: * @param scale the number of digits to the right of the decimal point
1387: * @return the column value; if the value is SQL <code>NULL</code>, the
1388: * value returned is <code>null</code>
1389: * @throws SQLException if (1) adatabase access error occurs
1390: * or (2) this rowset does not have a currently valid connection,
1391: * prepared statement, and result set
1392: * @deprecated
1393: */
1394: public BigDecimal getBigDecimal(String columnName, int scale)
1395: throws SQLException {
1396: return getBigDecimal(findColumn(columnName), scale);
1397: }
1398:
1399: /**
1400: * Gets the value of the designated column in the current row
1401: * of this rowset's <code>ResultSet</code> object as
1402: * a <code>byte</code> array in the Java programming language.
1403: * The bytes represent the raw values returned by the driver.
1404: *
1405: * @param columnName the SQL name of the column
1406: * @return the column value; if the value is SQL <code>NULL</code>, the
1407: * value returned is <code>null</code>
1408: * @throws SQLException if (1) a database access error occurs
1409: * or (2) this rowset does not have a currently valid connection,
1410: * prepared statement, and result set
1411: */
1412: public byte[] getBytes(String columnName) throws SQLException {
1413: return getBytes(findColumn(columnName));
1414: }
1415:
1416: /**
1417: * Gets the value of the designated column in the current row
1418: * of this rowset's <code>ResultSet</code> object as
1419: * a <code>java.sql.Date</code> object in the Java programming language.
1420: *
1421: * @param columnName the SQL name of the column
1422: * @return the column value; if the value is SQL <code>NULL</code>, the
1423: * value returned is <code>null</code>
1424: * @throws SQLException if (1) a database access error occurs
1425: * or (2) this rowset does not have a currently valid connection,
1426: * prepared statement, and result set
1427: */
1428: public java.sql.Date getDate(String columnName) throws SQLException {
1429: return getDate(findColumn(columnName));
1430: }
1431:
1432: /**
1433: * Gets the value of the designated column in the current row
1434: * of this rowset's <code>ResultSet</code> object as
1435: * a <code>java.sql.Time</code> object in the Java programming language.
1436: *
1437: * @param columnName the SQL name of the column
1438: * @return the column value;
1439: * if the value is SQL <code>NULL</code>,
1440: * the value returned is <code>null</code>
1441: * @throws SQLException if (1) a database access error occurs
1442: * or (2) this rowset does not have a currently valid connection,
1443: * prepared statement, and result set
1444: */
1445: public java.sql.Time getTime(String columnName) throws SQLException {
1446: return getTime(findColumn(columnName));
1447: }
1448:
1449: /**
1450: * Gets the value of the designated column in the current row
1451: * of this rowset's <code>ResultSet</code> object as
1452: * a <code>java.sql.Timestamp</code> object.
1453: *
1454: * @param columnName the SQL name of the column
1455: * @return the column value; if the value is SQL <code>NULL</code>, the
1456: * value returned is <code>null</code>
1457: * @throws SQLException if (1) a database access error occurs
1458: * or (2) this rowset does not have a currently valid connection,
1459: * prepared statement, and result set
1460: */
1461: public java.sql.Timestamp getTimestamp(String columnName)
1462: throws SQLException {
1463: return getTimestamp(findColumn(columnName));
1464: }
1465:
1466: /**
1467: * Gets the value of the designated column in the current row
1468: * of this rowset's <code>ResultSet</code> object as a stream of
1469: * ASCII characters. The value can then be read in chunks from the
1470: * stream. This method is particularly
1471: * suitable for retrieving large <code>LONGVARCHAR</code> values.
1472: * The JDBC driver will
1473: * do any necessary conversion from the database format into ASCII.
1474: *
1475: * <P><B>Note:</B> All the data in the returned stream must be
1476: * read prior to getting the value of any other column. The next
1477: * call to a <code>getXXX</code> method implicitly closes the stream. Also, a
1478: * stream may return <code>0</code> when the method <code>available</code>
1479: * is called whether there is data available or not.
1480: *
1481: * @param columnName the SQL name of the column
1482: * @return a Java input stream that delivers the database column value
1483: * as a stream of one-byte ASCII characters.
1484: * If the value is SQL <code>NULL</code>,
1485: * the value returned is <code>null</code>.
1486: * @throws SQLException if (1) a database access error occurs
1487: * or (2) this rowset does not have a currently valid connection,
1488: * prepared statement, and result set
1489: */
1490: public java.io.InputStream getAsciiStream(String columnName)
1491: throws SQLException {
1492: return getAsciiStream(findColumn(columnName));
1493: }
1494:
1495: /**
1496: * Gets the value of the designated column in the current row
1497: * of this rowset's <code>ResultSet</code> object as a stream of
1498: * Unicode characters. The value can then be read in chunks from the
1499: * stream. This method is particularly
1500: * suitable for retrieving large <code>LONGVARCHAR</code> values.
1501: * The JDBC driver will
1502: * do any necessary conversion from the database format into Unicode.
1503: * The byte format of the Unicode stream must be Java UTF-8,
1504: * as defined in the Java virtual machine specification.
1505: *
1506: * <P><B>Note:</B> All the data in the returned stream must be
1507: * read prior to getting the value of any other column. The next
1508: * call to a <code>getXXX</code> method implicitly closes the stream. Also, a
1509: * stream may return <code>0</code> when the method <code>available</code>
1510: * is called whether there is data available or not.
1511: *
1512: * @param columnName the SQL name of the column
1513: * @return a Java input stream that delivers the database column value
1514: * as a stream of two-byte Unicode characters.
1515: * If the value is SQL <code>NULL</code>,
1516: * the value returned is <code>null</code>.
1517: * @throws SQLException if (1) a database access error occurs
1518: * or (2) this rowset does not have a currently valid connection,
1519: * prepared statement, and result set
1520: * @deprecated
1521: */
1522: public java.io.InputStream getUnicodeStream(String columnName)
1523: throws SQLException {
1524: return getUnicodeStream(findColumn(columnName));
1525: }
1526:
1527: /**
1528: * Gets the value of the designated column in the current row
1529: * of this rowset's <code>ResultSet</code> object as a stream of uninterpreted
1530: * <code>byte</code>s.
1531: * The value can then be read in chunks from the
1532: * stream. This method is particularly
1533: * suitable for retrieving large <code>LONGVARBINARY</code>
1534: * values.
1535: *
1536: * <P><B>Note:</B> All the data in the returned stream must be
1537: * read prior to getting the value of any other column. The next
1538: * call to a <code>getXXX</code> method implicitly closes the stream. Also, a
1539: * stream may return <code>0</code> when the method <code>available</code>
1540: * is called whether there is data available or not.
1541: *
1542: * @param columnName the SQL name of the column
1543: * @return a Java input stream that delivers the database column value
1544: * as a stream of uninterpreted bytes;
1545: * if the value is SQL <code>NULL</code>, the result is <code>null</code>
1546: * @throws SQLException if (1) a database access error occurs
1547: * or (2) this rowset does not have a currently valid connection,
1548: * prepared statement, and result set
1549: */
1550: public java.io.InputStream getBinaryStream(String columnName)
1551: throws SQLException {
1552: return getBinaryStream(findColumn(columnName));
1553: }
1554:
1555: //=====================================================================
1556: // Advanced features:
1557: //=====================================================================
1558:
1559: /**
1560: * Returns the first warning reported by calls on this rowset's
1561: * <code>ResultSet</code> object.
1562: * Subsequent warnings on this rowset's <code>ResultSet</code> object
1563: * will be chained to the <code>SQLWarning</code> object that
1564: * this method returns.
1565: *
1566: * <P>The warning chain is automatically cleared each time a new
1567: * row is read.
1568: *
1569: * <P><B>Note:</B> This warning chain only covers warnings caused
1570: * by <code>ResultSet</code> methods. Any warning caused by
1571: * <code>Statement</code> methods
1572: * (such as reading OUT parameters) will be chained on the
1573: * <code>Statement</code> object.
1574: *
1575: * @return the first <code>SQLWarning</code> object reported or <code>null</code>
1576: * @throws SQLException if (1) a database access error occurs
1577: * or (2) this rowset does not have a currently valid connection,
1578: * prepared statement, and result set
1579: */
1580: public SQLWarning getWarnings() throws SQLException {
1581: checkState();
1582:
1583: return rs.getWarnings();
1584: }
1585:
1586: /**
1587: * Clears all warnings reported on this rowset's <code>ResultSet</code> object.
1588: * After this method is called, the method <code>getWarnings</code>
1589: * returns <code>null</code> until a new warning is
1590: * reported for this rowset's <code>ResultSet</code> object.
1591: *
1592: * @throws SQLException if (1) a database access error occurs
1593: * or (2) this rowset does not have a currently valid connection,
1594: * prepared statement, and result set
1595: */
1596: public void clearWarnings() throws SQLException {
1597: checkState();
1598:
1599: rs.clearWarnings();
1600: }
1601:
1602: /**
1603: * Gets the name of the SQL cursor used by this rowset's <code>ResultSet</code>
1604: * object.
1605: *
1606: * <P>In SQL, a result table is retrieved through a cursor that is
1607: * named. The current row of a result set can be updated or deleted
1608: * using a positioned update/delete statement that references the
1609: * cursor name. To insure that the cursor has the proper isolation
1610: * level to support update, the cursor's <code>select</code> statement should be
1611: * of the form 'select for update'. If the 'for update' clause is
1612: * omitted, the positioned updates may fail.
1613: *
1614: * <P>The JDBC API supports this SQL feature by providing the name of the
1615: * SQL cursor used by a <code>ResultSet</code> object.
1616: * The current row of a <code>ResultSet</code> object
1617: * is also the current row of this SQL cursor.
1618: *
1619: * <P><B>Note:</B> If positioned update is not supported, a
1620: * <code>SQLException</code> is thrown.
1621: *
1622: * @return the SQL name for this rowset's <code>ResultSet</code> object's cursor
1623: * @throws SQLException if (1) a database access error occurs
1624: * or (2) xthis rowset does not have a currently valid connection,
1625: * prepared statement, and result set
1626: */
1627: public String getCursorName() throws SQLException {
1628: checkState();
1629:
1630: return rs.getCursorName();
1631: }
1632:
1633: /**
1634: * Retrieves the number, types and properties of
1635: * this rowset's <code>ResultSet</code> object's columns.
1636: *
1637: * @return the description of this rowset's <code>ResultSet</code>
1638: * object's columns
1639: * @throws SQLException if (1) a database access error occurs
1640: * or (2) this rowset does not have a currently valid connection,
1641: * prepared statement, and result set
1642: */
1643: public ResultSetMetaData getMetaData() throws SQLException {
1644:
1645: checkState();
1646:
1647: // It may be the case that JdbcRowSet might not have been
1648: // initialized with ResultSet handle and may be by PreparedStatement
1649: // internally when we set JdbcRowSet.setCommand().
1650: // We may require all the basic properties of setEscapeProcessing
1651: // setMaxFieldSize etc. which an application can use before we call
1652: // execute.
1653: try {
1654: checkState();
1655: } catch (SQLException sqle) {
1656: prepare();
1657: // will return ResultSetMetaData
1658: return ps.getMetaData();
1659: }
1660: return rs.getMetaData();
1661: }
1662:
1663: /**
1664: * <p>Gets the value of the designated column in the current row
1665: * of this rowset's <code>ResultSet</code> object as
1666: * an <code>Object</code>.
1667: *
1668: * <p>This method will return the value of the given column as a
1669: * Java object. The type of the Java object will be the default
1670: * Java object type corresponding to the column's SQL type,
1671: * following the mapping for built-in types specified in the JDBC
1672: * specification.
1673: *
1674: * <p>This method may also be used to read datatabase-specific
1675: * abstract data types.
1676: *
1677: * In the JDBC 3.0 API, the behavior of method
1678: * <code>getObject</code> is extended to materialize
1679: * data of SQL user-defined types. When a column contains
1680: * a structured or distinct value, the behavior of this method is as
1681: * if it were a call to: <code>getObject(columnIndex,
1682: * this.getStatement().getConnection().getTypeMap())</code>.
1683: *
1684: * @param columnIndex the first column is 1, the second is 2, and so on
1685: * @return a <code>java.lang.Object</code> holding the column value
1686: * @throws SQLException if (1) a database access error occurs
1687: * or (2) this rowset does not currently have a valid connection,
1688: * prepared statement, and result set
1689: */
1690: public Object getObject(int columnIndex) throws SQLException {
1691: checkState();
1692:
1693: return rs.getObject(columnIndex);
1694: }
1695:
1696: /**
1697: * <p>Gets the value of the designated column in the current row
1698: * of this rowset's <code>ResultSet</code> object as
1699: * an <code>Object</code>.
1700: *
1701: * <p>This method will return the value of the given column as a
1702: * Java object. The type of the Java object will be the default
1703: * Java object type corresponding to the column's SQL type,
1704: * following the mapping for built-in types specified in the JDBC
1705: * specification.
1706: *
1707: * <p>This method may also be used to read datatabase-specific
1708: * abstract data types.
1709: *
1710: * In the JDBC 3.0 API, the behavior of the method
1711: * <code>getObject</code> is extended to materialize
1712: * data of SQL user-defined types. When a column contains
1713: * a structured or distinct value, the behavior of this method is as
1714: * if it were a call to: <code>getObject(columnIndex,
1715: * this.getStatement().getConnection().getTypeMap())</code>.
1716: *
1717: * @param columnName the SQL name of the column
1718: * @return a <code>java.lang.Object</code> holding the column value
1719: * @throws SQLException if (1) a database access error occurs
1720: * or (2) this rowset does not currently have a valid connection,
1721: * prepared statement, and result set
1722: */
1723: public Object getObject(String columnName) throws SQLException {
1724: return getObject(findColumn(columnName));
1725: }
1726:
1727: //----------------------------------------------------------------
1728:
1729: /**
1730: * Maps the given <code>JdbcRowSetImpl</code> column name to its
1731: * <code>JdbcRowSetImpl</code> column index and reflects this on
1732: * the internal <code>ResultSet</code> object.
1733: *
1734: * @param columnName the name of the column
1735: * @return the column index of the given column name
1736: * @throws SQLException if (1) a database access error occurs
1737: * (2) this rowset does not have a currently valid connection,
1738: * prepared statement, and result set
1739: */
1740: public int findColumn(String columnName) throws SQLException {
1741: checkState();
1742:
1743: return rs.findColumn(columnName);
1744: }
1745:
1746: //--------------------------JDBC 2.0-----------------------------------
1747:
1748: //---------------------------------------------------------------------
1749: // Getters and Setters
1750: //---------------------------------------------------------------------
1751:
1752: /**
1753: * Gets the value of the designated column in the current row
1754: * of this rowset's <code>ResultSet</code> object as a
1755: * <code>java.io.Reader</code> object.
1756: * @return a <code>java.io.Reader</code> object that contains the column
1757: * value; if the value is SQL <code>NULL</code>, the value returned is
1758: * <code>null</code>.
1759: * @param columnIndex the first column is 1, the second is 2, and so on
1760: *
1761: */
1762: public java.io.Reader getCharacterStream(int columnIndex)
1763: throws SQLException {
1764: checkState();
1765:
1766: return rs.getCharacterStream(columnIndex);
1767: }
1768:
1769: /**
1770: * Gets the value of the designated column in the current row
1771: * of this rowset's <code>ResultSet</code> object as a
1772: * <code>java.io.Reader</code> object.
1773: *
1774: * @return a <code>java.io.Reader</code> object that contains the column
1775: * value; if the value is SQL <code>NULL</code>, the value returned is
1776: * <code>null</code>.
1777: * @param columnName the name of the column
1778: * @return the value in the specified column as a <code>java.io.Reader</code>
1779: *
1780: */
1781: public java.io.Reader getCharacterStream(String columnName)
1782: throws SQLException {
1783: return getCharacterStream(findColumn(columnName));
1784: }
1785:
1786: /**
1787: * Gets the value of the designated column in the current row
1788: * of this rowset's <code>ResultSet</code> object as a
1789: * <code>java.math.BigDecimal</code> with full precision.
1790: *
1791: * @param columnIndex the first column is 1, the second is 2, and so on
1792: * @return the column value (full precision);
1793: * if the value is SQL <code>NULL</code>, the value returned is
1794: * <code>null</code>.
1795: * @throws SQLException if a database access error occurs
1796: * or this rowset does not currently have a valid
1797: * connection, prepared statement, and result set
1798: */
1799: public BigDecimal getBigDecimal(int columnIndex)
1800: throws SQLException {
1801: checkState();
1802:
1803: return rs.getBigDecimal(columnIndex);
1804: }
1805:
1806: /**
1807: * Gets the value of the designated column in the current row
1808: * of this rowset's <code>ResultSet</code> object as a
1809: * <code>java.math.BigDecimal</code> with full precision.
1810: *
1811: * @param columnName the column name
1812: * @return the column value (full precision);
1813: * if the value is SQL <code>NULL</code>, the value returned is
1814: * <code>null</code>.
1815: * @throws SQLException if a database access error occurs
1816: * or this rowset does not currently have a valid
1817: * connection, prepared statement, and result set
1818: */
1819: public BigDecimal getBigDecimal(String columnName)
1820: throws SQLException {
1821: return getBigDecimal(findColumn(columnName));
1822: }
1823:
1824: //---------------------------------------------------------------------
1825: // Traversal/Positioning
1826: //---------------------------------------------------------------------
1827:
1828: /**
1829: * Indicates whether the cursor is before the first row in
1830: * this rowset's <code>ResultSet</code> object.
1831: *
1832: * @return <code>true</code> if the cursor is before the first row;
1833: * <code>false</code> if the cursor is at any other position or the
1834: * result set contains no rows
1835: * @throws SQLException if a database access error occurs
1836: * or this rowset does not currently have a valid
1837: * connection, prepared statement, and result set
1838: */
1839: public boolean isBeforeFirst() throws SQLException {
1840: checkState();
1841:
1842: return rs.isBeforeFirst();
1843: }
1844:
1845: /**
1846: * Indicates whether the cursor is after the last row in
1847: * this rowset's <code>ResultSet</code> object.
1848: *
1849: * @return <code>true</code> if the cursor is after the last row;
1850: * <code>false</code> if the cursor is at any other position or the
1851: * result set contains no rows
1852: * @throws SQLException if a database access error occurs
1853: * or this rowset does not currently have a valid
1854: * connection, prepared statement, and result set
1855: */
1856: public boolean isAfterLast() throws SQLException {
1857: checkState();
1858:
1859: return rs.isAfterLast();
1860: }
1861:
1862: /**
1863: * Indicates whether the cursor is on the first row of
1864: * this rowset's <code>ResultSet</code> object.
1865: *
1866: * @return <code>true</code> if the cursor is on the first row;
1867: * <code>false</code> otherwise
1868: * @throws SQLException if a database access error occurs
1869: * or this rowset does not currently have a valid
1870: * connection, prepared statement, and result set
1871: */
1872: public boolean isFirst() throws SQLException {
1873: checkState();
1874:
1875: return rs.isFirst();
1876: }
1877:
1878: /**
1879: * Indicates whether the cursor is on the last row of
1880: * this rowset's <code>ResultSet</code> object.
1881: * Note: Calling the method <code>isLast</code> may be expensive
1882: * because the JDBC driver
1883: * might need to fetch ahead one row in order to determine
1884: * whether the current row is the last row in the result set.
1885: *
1886: * @return <code>true</code> if the cursor is on the last row;
1887: * <code>false</code> otherwise
1888: * @throws SQLException if a database access error occurs
1889: * or this rowset does not currently have a valid
1890: * connection, prepared statement, and result set
1891: *
1892: */
1893: public boolean isLast() throws SQLException {
1894: checkState();
1895:
1896: return rs.isLast();
1897: }
1898:
1899: /**
1900: * Moves the cursor to the front of
1901: * this rowset's <code>ResultSet</code> object, just before the
1902: * first row. This method has no effect if the result set contains no rows.
1903: *
1904: * @throws SQLException if (1) a database access error occurs,
1905: * (2) the result set type is <code>TYPE_FORWARD_ONLY</code>,
1906: * or (3) this rowset does not currently have a valid
1907: * connection, prepared statement, and result set
1908: */
1909: public void beforeFirst() throws SQLException {
1910: checkState();
1911:
1912: rs.beforeFirst();
1913: notifyCursorMoved();
1914: }
1915:
1916: /**
1917: * Moves the cursor to the end of
1918: * this rowset's <code>ResultSet</code> object, just after the
1919: * last row. This method has no effect if the result set contains no rows.
1920: * @throws SQLException if (1) a database access error occurs,
1921: * (2) the result set type is <code>TYPE_FORWARD_ONLY</code>,
1922: * or (3) this rowset does not currently have a valid
1923: * connection, prepared statement, and result set
1924: */
1925: public void afterLast() throws SQLException {
1926: checkState();
1927:
1928: rs.afterLast();
1929: notifyCursorMoved();
1930: }
1931:
1932: /**
1933: * Moves the cursor to the first row in
1934: * this rowset's <code>ResultSet</code> object.
1935: *
1936: * @return <code>true</code> if the cursor is on a valid row;
1937: * <code>false</code> if there are no rows in the result set
1938: * @throws SQLException if (1) a database access error occurs,
1939: * (2) the result set type is <code>TYPE_FORWARD_ONLY</code>,
1940: * or (3) this rowset does not currently have a valid
1941: * connection, prepared statement, and result set
1942: */
1943: public boolean first() throws SQLException {
1944: checkState();
1945:
1946: boolean b = rs.first();
1947: notifyCursorMoved();
1948: return b;
1949:
1950: }
1951:
1952: /**
1953: * Moves the cursor to the last row in
1954: * this rowset's <code>ResultSet</code> object.
1955: *
1956: * @return <code>true</code> if the cursor is on a valid row;
1957: * <code>false</code> if there are no rows in the result set
1958: * @throws SQLException if (1) a database access error occurs,
1959: * (2) the result set type is <code>TYPE_FORWARD_ONLY</code>,
1960: * or (3) this rowset does not currently have a valid
1961: * connection, prepared statement, and result set
1962: */
1963: public boolean last() throws SQLException {
1964: checkState();
1965:
1966: boolean b = rs.last();
1967: notifyCursorMoved();
1968: return b;
1969: }
1970:
1971: /**
1972: * Retrieves the current row number. The first row is number 1, the
1973: * second is number 2, and so on.
1974: *
1975: * @return the current row number; <code>0</code> if there is no current row
1976: * @throws SQLException if a database access error occurs
1977: * or this rowset does not currently have a valid connection,
1978: * prepared statement, and result set
1979: */
1980: public int getRow() throws SQLException {
1981: checkState();
1982:
1983: return rs.getRow();
1984: }
1985:
1986: /**
1987: * Moves the cursor to the given row number in
1988: * this rowset's internal <code>ResultSet</code> object.
1989: *
1990: * <p>If the row number is positive, the cursor moves to
1991: * the given row number with respect to the
1992: * beginning of the result set. The first row is row 1, the second
1993: * is row 2, and so on.
1994: *
1995: * <p>If the given row number is negative, the cursor moves to
1996: * an absolute row position with respect to
1997: * the end of the result set. For example, calling the method
1998: * <code>absolute(-1)</code> positions the
1999: * cursor on the last row, calling the method <code>absolute(-2)</code>
2000: * moves the cursor to the next-to-last row, and so on.
2001: *
2002: * <p>An attempt to position the cursor beyond the first/last row in
2003: * the result set leaves the cursor before the first row or after
2004: * the last row.
2005: *
2006: * <p><B>Note:</B> Calling <code>absolute(1)</code> is the same
2007: * as calling <code>first()</code>. Calling <code>absolute(-1)</code>
2008: * is the same as calling <code>last()</code>.
2009: *
2010: * @return <code>true</code> if the cursor is on the result set;
2011: * <code>false</code> otherwise
2012: * @throws SQLException if (1) a database access error occurs,
2013: * (2) the row is <code>0</code>, (3) the result set
2014: * type is <code>TYPE_FORWARD_ONLY</code>, or (4) this
2015: * rowset does not currently have a valid connection,
2016: * prepared statement, and result set
2017: */
2018: public boolean absolute(int row) throws SQLException {
2019: checkState();
2020:
2021: boolean b = rs.absolute(row);
2022: notifyCursorMoved();
2023: return b;
2024: }
2025:
2026: /**
2027: * Moves the cursor a relative number of rows, either positive or negative.
2028: * Attempting to move beyond the first/last row in the
2029: * result set positions the cursor before/after the
2030: * the first/last row. Calling <code>relative(0)</code> is valid, but does
2031: * not change the cursor position.
2032: *
2033: * <p>Note: Calling the method <code>relative(1)</code>
2034: * is different from calling the method <code>next()</code>
2035: * because is makes sense to call <code>next()</code> when there
2036: * is no current row,
2037: * for example, when the cursor is positioned before the first row
2038: * or after the last row of the result set.
2039: *
2040: * @return <code>true</code> if the cursor is on a row;
2041: * <code>false</code> otherwise
2042: * @throws SQLException if (1) a database access error occurs,
2043: * (2) there is no current row, (3) the result set
2044: * type is <code>TYPE_FORWARD_ONLY</code>, or (4) this
2045: * rowset does not currently have a valid connection,
2046: * prepared statement, and result set
2047: */
2048: public boolean relative(int rows) throws SQLException {
2049: checkState();
2050:
2051: boolean b = rs.relative(rows);
2052: notifyCursorMoved();
2053: return b;
2054: }
2055:
2056: /**
2057: * Moves the cursor to the previous row in this
2058: * <code>ResultSet</code> object.
2059: *
2060: * <p><B>Note:</B> Calling the method <code>previous()</code> is not the same as
2061: * calling the method <code>relative(-1)</code> because it
2062: * makes sense to call <code>previous()</code> when there is no current row.
2063: *
2064: * @return <code>true</code> if the cursor is on a valid row;
2065: * <code>false</code> if it is off the result set
2066: * @throws SQLException if (1) a database access error occurs,
2067: * (2) the result set type is <code>TYPE_FORWARD_ONLY</code>,
2068: * or (3) this rowset does not currently have a valid
2069: * connection, prepared statement, and result set
2070: */
2071: public boolean previous() throws SQLException {
2072: checkState();
2073:
2074: boolean b = rs.previous();
2075: notifyCursorMoved();
2076: return b;
2077: }
2078:
2079: /**
2080: * Gives a hint as to the direction in which the rows in this
2081: * <code>ResultSet</code> object will be processed.
2082: * The initial value is determined by the
2083: * <code>Statement</code> object
2084: * that produced this rowset's <code>ResultSet</code> object.
2085: * The fetch direction may be changed at any time.
2086: *
2087: * @throws SQLException if (1) a database access error occurs,
2088: * (2) the result set type is <code>TYPE_FORWARD_ONLY</code>
2089: * and the fetch direction is not <code>FETCH_FORWARD</code>,
2090: * or (3) this rowset does not currently have a valid
2091: * connection, prepared statement, and result set
2092: * @see java.sql.Statement#setFetchDirection
2093: */
2094: public void setFetchDirection(int direction) throws SQLException {
2095: checkState();
2096:
2097: rs.setFetchDirection(direction);
2098: }
2099:
2100: /**
2101: * Returns the fetch direction for this
2102: * <code>ResultSet</code> object.
2103: *
2104: * @return the current fetch direction for this rowset's
2105: * <code>ResultSet</code> object
2106: * @throws SQLException if a database access error occurs
2107: * or this rowset does not currently have a valid connection,
2108: * prepared statement, and result set
2109: */
2110: public int getFetchDirection() throws SQLException {
2111: try {
2112: checkState();
2113: } catch (SQLException sqle) {
2114: super .getFetchDirection();
2115: }
2116: return rs.getFetchDirection();
2117: }
2118:
2119: /**
2120: * Gives the JDBC driver a hint as to the number of rows that should
2121: * be fetched from the database when more rows are needed for this
2122: * <code>ResultSet</code> object.
2123: * If the fetch size specified is zero, the JDBC driver
2124: * ignores the value and is free to make its own best guess as to what
2125: * the fetch size should be. The default value is set by the
2126: * <code>Statement</code> object
2127: * that created the result set. The fetch size may be changed at any time.
2128: *
2129: * @param rows the number of rows to fetch
2130: * @throws SQLException if (1) a database access error occurs, (2) the
2131: * condition <code>0 <= rows <= this.getMaxRows()</code> is not
2132: * satisfied, or (3) this rowset does not currently have a valid
2133: * connection, prepared statement, and result set
2134: *
2135: */
2136: public void setFetchSize(int rows) throws SQLException {
2137: checkState();
2138:
2139: rs.setFetchSize(rows);
2140: }
2141:
2142: /**
2143: *
2144: * Returns the fetch size for this
2145: * <code>ResultSet</code> object.
2146: *
2147: * @return the current fetch size for this rowset's <code>ResultSet</code> object
2148: * @throws SQLException if a database access error occurs
2149: * or this rowset does not currently have a valid connection,
2150: * prepared statement, and result set
2151: */
2152: public int getType() throws SQLException {
2153: try {
2154: checkState();
2155: } catch (SQLException sqle) {
2156: return super .getType();
2157: }
2158:
2159: // If the ResultSet has not been created, then return the default type
2160: // otherwise return the type from the ResultSet.
2161: if (rs == null) {
2162: return super .getType();
2163: } else {
2164: int rstype = rs.getType();
2165: return rstype;
2166: }
2167:
2168: }
2169:
2170: /**
2171: * Returns the concurrency mode of this rowset's <code>ResultSet</code> object.
2172: * The concurrency used is determined by the
2173: * <code>Statement</code> object that created the result set.
2174: *
2175: * @return the concurrency type, either <code>CONCUR_READ_ONLY</code>
2176: * or <code>CONCUR_UPDATABLE</code>
2177: * @throws SQLException if (1) a database access error occurs
2178: * or (2) this rowset does not currently have a valid connection,
2179: * prepared statement, and result set
2180: */
2181: public int getConcurrency() throws SQLException {
2182: try {
2183: checkState();
2184: } catch (SQLException sqle) {
2185: super .getConcurrency();
2186: }
2187: return rs.getConcurrency();
2188: }
2189:
2190: //---------------------------------------------------------------------
2191: // Updates
2192: //---------------------------------------------------------------------
2193:
2194: /**
2195: * Indicates whether the current row has been updated. The value returned
2196: * depends on whether or not the result set can detect updates.
2197: *
2198: * @return <code>true</code> if the row has been visibly updated
2199: * by the owner or another, and updates are detected
2200: * @throws SQLException if a database access error occurs
2201: * or this rowset does not currently have a valid connection,
2202: * prepared statement, and result set
2203: * @see java.sql.DatabaseMetaData#updatesAreDetected
2204: */
2205: public boolean rowUpdated() throws SQLException {
2206: checkState();
2207:
2208: return rs.rowUpdated();
2209: }
2210:
2211: /**
2212: * Indicates whether the current row has had an insertion.
2213: * The value returned depends on whether or not this
2214: * <code>ResultSet</code> object can detect visible inserts.
2215: *
2216: * @return <code>true</code> if a row has had an insertion
2217: * and insertions are detected; <code>false</code> otherwise
2218: * @throws SQLException if a database access error occurs
2219: * or this rowset does not currently have a valid connection,
2220: * prepared statement, and result set
2221: * @see java.sql.DatabaseMetaData#insertsAreDetected
2222: *
2223: */
2224: public boolean rowInserted() throws SQLException {
2225: checkState();
2226:
2227: return rs.rowInserted();
2228: }
2229:
2230: /**
2231: * Indicates whether a row has been deleted. A deleted row may leave
2232: * a visible "hole" in a result set. This method can be used to
2233: * detect holes in a result set. The value returned depends on whether
2234: * or not this rowset's <code>ResultSet</code> object can detect deletions.
2235: *
2236: * @return <code>true</code> if a row was deleted and deletions are detected;
2237: * <code>false</code> otherwise
2238: * @throws SQLException if a database access error occurs
2239: * or this rowset does not currently have a valid connection,
2240: * prepared statement, and result set
2241: * @see java.sql.DatabaseMetaData#deletesAreDetected
2242: */
2243: public boolean rowDeleted() throws SQLException {
2244: checkState();
2245:
2246: return rs.rowDeleted();
2247: }
2248:
2249: /**
2250: * Gives a nullable column a null value.
2251: *
2252: * The <code>updateXXX</code> methods are used to update column values in the
2253: * current row or the insert row. The <code>updateXXX</code> methods do not
2254: * update the underlying database; instead the <code>updateRow</code>
2255: * or <code>insertRow</code> methods are called to update the database.
2256: *
2257: * @param columnIndex the first column is 1, the second is 2, and so on
2258: * @throws SQLException if a database access error occurs
2259: * or this rowset does not currently have a valid connection,
2260: * prepared statement, and result set
2261: */
2262: public void updateNull(int columnIndex) throws SQLException {
2263: checkState();
2264:
2265: // To check the type and concurrency of the ResultSet
2266: // to verify whether updates are possible or not
2267: checkTypeConcurrency();
2268:
2269: rs.updateNull(columnIndex);
2270: }
2271:
2272: /**
2273: * Updates the designated column with a <code>boolean</code> value.
2274: * The <code>updateXXX</code> methods are used to update column values in the
2275: * current row or the insert row. The <code>updateXXX</code> methods do not
2276: * update the underlying database; instead the <code>updateRow</code> or
2277: * <code>insertRow</code> methods are called to update the database.
2278: *
2279: * @param columnIndex the first column is 1, the second is 2, and so on
2280: * @param x the new column value
2281: * @throws SQLException if a database access error occurs
2282: * or this rowset does not currently have a valid connection,
2283: * prepared statement, and result set
2284: *
2285: */
2286: public void updateBoolean(int columnIndex, boolean x)
2287: throws SQLException {
2288: checkState();
2289:
2290: // To check the type and concurrency of the ResultSet
2291: // to verify whether updates are possible or not
2292: checkTypeConcurrency();
2293:
2294: rs.updateBoolean(columnIndex, x);
2295: }
2296:
2297: /**
2298: * Updates the designated column with a <code>byte</code> value.
2299: * The <code>updateXXX</code> methods are used to update column values in the
2300: * current row or the insert row. The <code>updateXXX</code> methods do not
2301: * update the underlying database; instead the <code>updateRow</code> or
2302: * <code>insertRow</code> methods are called to update the database.
2303: *
2304: *
2305: * @param columnIndex the first column is 1, the second is 2, and so on
2306: * @param x the new column value
2307: * @throws SQLException if a database access error occurs
2308: * or this rowset does not currently have a valid connection,
2309: * prepared statement, and result set
2310: *
2311: */
2312: public void updateByte(int columnIndex, byte x) throws SQLException {
2313: checkState();
2314:
2315: // To check the type and concurrency of the ResultSet
2316: // to verify whether updates are possible or not
2317: checkTypeConcurrency();
2318:
2319: rs.updateByte(columnIndex, x);
2320: }
2321:
2322: /**
2323: * Updates the designated column with a <code>short</code> value.
2324: * The <code>updateXXX</code> methods are used to update column values in the
2325: * current row or the insert row. The <code>updateXXX</code> methods do not
2326: * update the underlying database; instead the <code>updateRow</code> or
2327: * <code>insertRow</code> methods are called to update the database.
2328: *
2329: * @param columnIndex the first column is 1, the second is 2, and so on
2330: * @param x the new column value
2331: * @throws SQLException if a database access error occurs
2332: * or this rowset does not currently have a valid connection,
2333: * prepared statement, and result set
2334: *
2335: */
2336: public void updateShort(int columnIndex, short x)
2337: throws SQLException {
2338: checkState();
2339:
2340: // To check the type and concurrency of the ResultSet
2341: // to verify whether updates are possible or not
2342: checkTypeConcurrency();
2343:
2344: rs.updateShort(columnIndex, x);
2345: }
2346:
2347: /**
2348: * Updates the designated column with an <code>int</code> value.
2349: * The <code>updateXXX</code> methods are used to update column values in the
2350: * current row or the insert row. The <code>updateXXX</code> methods do not
2351: * update the underlying database; instead the <code>updateRow</code> or
2352: * <code>insertRow</code> methods are called to update the database.
2353: *
2354: * @param columnIndex the first column is 1, the second is 2, and so on
2355: * @param x the new column value
2356: * @throws SQLException if a database access error occurs
2357: * or this rowset does not currently have a valid connection,
2358: * prepared statement, and result set
2359: */
2360: public void updateInt(int columnIndex, int x) throws SQLException {
2361: checkState();
2362:
2363: // To check the type and concurrency of the ResultSet
2364: // to verify whether updates are possible or not
2365: checkTypeConcurrency();
2366:
2367: rs.updateInt(columnIndex, x);
2368: }
2369:
2370: /**
2371: * Updates the designated column with a <code>long</code> value.
2372: * The <code>updateXXX</code> methods are used to update column values in the
2373: * current row or the insert row. The <code>updateXXX</code> methods do not
2374: * update the underlying database; instead the <code>updateRow</code> or
2375: * <code>insertRow</code> methods are called to update the database.
2376: *
2377: * @param columnIndex the first column is 1, the second is 2, and so on
2378: * @param x the new column value
2379: * @throws SQLException if a database access error occurs
2380: * or this rowset does not currently have a valid connection,
2381: * prepared statement, and result set
2382: *
2383: */
2384: public void updateLong(int columnIndex, long x) throws SQLException {
2385: checkState();
2386:
2387: // To check the type and concurrency of the ResultSet
2388: // to verify whether updates are possible or not
2389: checkTypeConcurrency();
2390:
2391: rs.updateLong(columnIndex, x);
2392: }
2393:
2394: /**
2395: * Updates the designated column with a <code>float</code> value.
2396: * The <code>updateXXX</code> methods are used to update column values in the
2397: * current row or the insert row. The <code>updateXXX</code> methods do not
2398: * update the underlying database; instead the <code>updateRow</code> or
2399: * <code>insertRow</code> methods are called to update the database.
2400: *
2401: * @param columnIndex the first column is 1, the second is 2, and so on
2402: * @param x the new column value
2403: * @throws SQLException if a database access error occurs
2404: * or this rowset does not currently have a valid connection,
2405: * prepared statement, and result set
2406: *
2407: */
2408: public void updateFloat(int columnIndex, float x)
2409: throws SQLException {
2410: checkState();
2411:
2412: // To check the type and concurrency of the ResultSet
2413: // to verify whether updates are possible or not
2414: checkTypeConcurrency();
2415:
2416: rs.updateFloat(columnIndex, x);
2417: }
2418:
2419: /**
2420: * Updates the designated column with a <code>double</code> value.
2421: * The <code>updateXXX</code> methods are used to update column values in the
2422: * current row or the insert row. The <code>updateXXX</code> methods do not
2423: * update the underlying database; instead the <code>updateRow</code> or
2424: * <code>insertRow</code> methods are called to update the database.
2425: *
2426: * @param columnIndex the first column is 1, the second is 2, and so on
2427: * @param x the new column value
2428: * @throws SQLException if a database access error occurs
2429: * or this rowset does not currently have a valid connection,
2430: * prepared statement, and result set
2431: *
2432: */
2433: public void updateDouble(int columnIndex, double x)
2434: throws SQLException {
2435: checkState();
2436:
2437: // To check the type and concurrency of the ResultSet
2438: // to verify whether updates are possible or not
2439: checkTypeConcurrency();
2440:
2441: rs.updateDouble(columnIndex, x);
2442: }
2443:
2444: /**
2445: * Updates the designated column with a <code>java.math.BigDecimal</code>
2446: * value.
2447: * The <code>updateXXX</code> methods are used to update column values in the
2448: * current row or the insert row. The <code>updateXXX</code> methods do not
2449: * update the underlying database; instead the <code>updateRow</code> or
2450: * <code>insertRow</code> methods are called to update the database.
2451: *
2452: * @param columnIndex the first column is 1, the second is 2, and so on
2453: * @param x the new column value
2454: * @throws SQLException if a database access error occurs
2455: * or this rowset does not currently have a valid connection,
2456: * prepared statement, and result set
2457: *
2458: */
2459: public void updateBigDecimal(int columnIndex, BigDecimal x)
2460: throws SQLException {
2461: checkState();
2462:
2463: // To check the type and concurrency of the ResultSet
2464: // to verify whether updates are possible or not
2465: checkTypeConcurrency();
2466:
2467: rs.updateBigDecimal(columnIndex, x);
2468: }
2469:
2470: /**
2471: * Updates the designated column with a <code>String</code> value.
2472: * The <code>updateXXX</code> methods are used to update column values in the
2473: * current row or the insert row. The <code>updateXXX</code> methods do not
2474: * update the underlying database; instead the <code>updateRow</code> or
2475: * <code>insertRow</code> methods are called to update the database.
2476: *
2477: * @param columnIndex the first column is 1, the second is 2, and so on
2478: * @param x the new column value
2479: * @throws SQLException if a database access error occurs
2480: * or this rowset does not currently have a valid connection,
2481: * prepared statement, and result set
2482: *
2483: */
2484: public void updateString(int columnIndex, String x)
2485: throws SQLException {
2486: checkState();
2487:
2488: // To check the type and concurrency of the ResultSet
2489: // to verify whether updates are possible or not
2490: checkTypeConcurrency();
2491:
2492: rs.updateString(columnIndex, x);
2493: }
2494:
2495: /**
2496: * Updates the designated column with a <code>byte</code> array value.
2497: * The <code>updateXXX</code> methods are used to update column values in the
2498: * current row or the insert row. The <code>updateXXX</code> methods do not
2499: * update the underlying database; instead the <code>updateRow</code> or
2500: * <code>insertRow</code> methods are called to update the database.
2501: *
2502: * @param columnIndex the first column is 1, the second is 2, and so on
2503: * @param x the new column value
2504: * @throws SQLException if a database access error occurs
2505: * or this rowset does not currently have a valid connection,
2506: * prepared statement, and result set
2507: *
2508: */
2509: public void updateBytes(int columnIndex, byte x[])
2510: throws SQLException {
2511: checkState();
2512:
2513: // To check the type and concurrency of the ResultSet
2514: // to verify whether updates are possible or not
2515: checkTypeConcurrency();
2516:
2517: rs.updateBytes(columnIndex, x);
2518: }
2519:
2520: /**
2521: * Updates the designated column with a <code>java.sql.Date</code> value.
2522: * The <code>updateXXX</code> methods are used to update column values in the
2523: * current row or the insert row. The <code>updateXXX</code> methods do not
2524: * update the underlying database; instead the <code>updateRow</code> or
2525: * <code>insertRow</code> methods are called to update the database.
2526: *
2527: * @param columnIndex the first column is 1, the second is 2, and so on
2528: * @param x the new column value
2529: * @throws SQLException if a database access error occurs
2530: * or this rowset does not currently have a valid connection,
2531: * prepared statement, and result set
2532: *
2533: */
2534: public void updateDate(int columnIndex, java.sql.Date x)
2535: throws SQLException {
2536: checkState();
2537:
2538: // To check the type and concurrency of the ResultSet
2539: // to verify whether updates are possible or not
2540: checkTypeConcurrency();
2541:
2542: rs.updateDate(columnIndex, x);
2543: }
2544:
2545: /**
2546: * Updates the designated column with a <code>java.sql.Time</code> value.
2547: * The <code>updateXXX</code> methods are used to update column values in the
2548: * current row or the insert row. The <code>updateXXX</code> methods do not
2549: * update the underlying database; instead the <code>updateRow</code> or
2550: * <code>insertRow</code> methods are called to update the database.
2551: *
2552: * @param columnIndex the first column is 1, the second is 2, and so on
2553: * @param x the new column value
2554: * @throws SQLException if a database access error occurs
2555: * or this rowset does not currently have a valid connection,
2556: * prepared statement, and result set
2557: *
2558: */
2559: public void updateTime(int columnIndex, java.sql.Time x)
2560: throws SQLException {
2561: checkState();
2562:
2563: // To check the type and concurrency of the ResultSet
2564: // to verify whether updates are possible or not
2565: checkTypeConcurrency();
2566:
2567: rs.updateTime(columnIndex, x);
2568: }
2569:
2570: /**
2571: * Updates the designated column with a <code>java.sql.Timestamp</code>
2572: * value.
2573: * The <code>updateXXX</code> methods are used to update column values in the
2574: * current row or the insert row. The <code>updateXXX</code> methods do not
2575: * update the underlying database; instead the <code>updateRow</code> or
2576: * <code>insertRow</code> methods are called to update the database.
2577: *
2578: * @param columnIndex the first column is 1, the second is 2, and so on
2579: * @param x the new column value
2580: * @throws SQLException if a database access error occurs
2581: * or this rowset does not currently have a valid connection,
2582: * prepared statement, and result set
2583: *
2584: */
2585: public void updateTimestamp(int columnIndex, java.sql.Timestamp x)
2586: throws SQLException {
2587: checkState();
2588:
2589: // To check the type and concurrency of the ResultSet
2590: // to verify whether updates are possible or not
2591: checkTypeConcurrency();
2592:
2593: rs.updateTimestamp(columnIndex, x);
2594: }
2595:
2596: /**
2597: * Updates the designated column with an ascii stream value.
2598: * The <code>updateXXX</code> methods are used to update column values in the
2599: * current row or the insert row. The <code>updateXXX</code> methods do not
2600: * update the underlying database; instead the <code>updateRow</code> or
2601: * <code>insertRow</code> methods are called to update the database.
2602: *
2603: * @param columnIndex the first column is 1, the second is 2, and so on
2604: * @param x the new column value
2605: * @param length the length of the stream
2606: * @throws SQLException if (1) a database access error occurs
2607: * (2) or this rowset does not currently have a valid connection,
2608: * prepared statement, and result set
2609: *
2610: */
2611: public void updateAsciiStream(int columnIndex,
2612: java.io.InputStream x, int length) throws SQLException {
2613: checkState();
2614:
2615: // To check the type and concurrency of the ResultSet
2616: // to verify whether updates are possible or not
2617: checkTypeConcurrency();
2618:
2619: rs.updateAsciiStream(columnIndex, x, length);
2620: }
2621:
2622: /**
2623: * Updates the designated column with a binary stream value.
2624: * The <code>updateXXX</code> methods are used to update column values in the
2625: * current row or the insert row. The <code>updateXXX</code> methods do not
2626: * update the underlying database; instead the <code>updateRow</code> or
2627: * <code>insertRow</code> methods are called to update the database.
2628: *
2629: * @param columnIndex the first column is 1, the second is 2, and so on
2630: * @param x the new column value
2631: * @param length the length of the stream
2632: * @throws SQLException if a database access error occurs
2633: * or this rowset does not currently have a valid connection,
2634: * prepared statement, and result set
2635: *
2636: */
2637: public void updateBinaryStream(int columnIndex,
2638: java.io.InputStream x, int length) throws SQLException {
2639: checkState();
2640:
2641: // To check the type and concurrency of the ResultSet
2642: // to verify whether updates are possible or not
2643: checkTypeConcurrency();
2644:
2645: rs.updateBinaryStream(columnIndex, x, length);
2646: }
2647:
2648: /**
2649: * Updates the designated column with a character stream value.
2650: * The <code>updateXXX</code> methods are used to update column values in the
2651: * current row or the insert row. The <code>updateXXX</code> methods do not
2652: * update the underlying database; instead the <code>updateRow</code> or
2653: * <code>insertRow</code> methods are called to update the database.
2654: *
2655: * @param columnIndex the first column is 1, the second is 2, and so on
2656: * @param x the new column value
2657: * @param length the length of the stream
2658: * @throws SQLException if a database access error occurs
2659: * or this rowset does not currently have a valid connection,
2660: * prepared statement, and result set
2661: *
2662: */
2663: public void updateCharacterStream(int columnIndex,
2664: java.io.Reader x, int length) throws SQLException {
2665: checkState();
2666:
2667: // To check the type and concurrency of the ResultSet
2668: // to verify whether updates are possible or not
2669: checkTypeConcurrency();
2670:
2671: rs.updateCharacterStream(columnIndex, x, length);
2672: }
2673:
2674: /**
2675: * Updates the designated column with an <code>Object</code> value.
2676: * The <code>updateXXX</code> methods are used to update column values in the
2677: * current row or the insert row. The <code>updateXXX</code> methods do not
2678: * update the underlying database; instead the <code>updateRow</code> or
2679: * <code>insertRow</code> methods are called to update the database.
2680: *
2681: * @param columnIndex the first column is 1, the second is 2, and so on
2682: * @param x the new column value
2683: * @param scale for <code>java.sql.Types.DECIMAl</code>
2684: * or <code>java.sql.Types.NUMERIC</code> types,
2685: * this is the number of digits after the decimal point. For all other
2686: * types this value will be ignored.
2687: * @throws SQLException if a database access error occurs
2688: * or this rowset does not currently have a valid connection,
2689: * prepared statement, and result set
2690: *
2691: */
2692: public void updateObject(int columnIndex, Object x, int scale)
2693: throws SQLException {
2694: checkState();
2695:
2696: // To check the type and concurrency of the ResultSet
2697: // to verify whether updates are possible or not
2698: checkTypeConcurrency();
2699:
2700: rs.updateObject(columnIndex, x, scale);
2701: }
2702:
2703: /**
2704: * Updates the designated column with an <code>Object</code> value.
2705: * The <code>updateXXX</code> methods are used to update column values in the
2706: * current row or the insert row. The <code>updateXXX</code> methods do not
2707: * update the underlying database; instead the <code>updateRow</code> or
2708: * <code>insertRow</code> methods are called to update the database.
2709: *
2710: * @param columnIndex the first column is 1, the second is 2, and so on
2711: * @param x the new column value
2712: * @throws SQLException if a database access error occurs
2713: * or this rowset does not currently have a valid connection,
2714: * prepared statement, and result set
2715: *
2716: */
2717: public void updateObject(int columnIndex, Object x)
2718: throws SQLException {
2719: checkState();
2720:
2721: // To check the type and concurrency of the ResultSet
2722: // to verify whether updates are possible or not
2723: checkTypeConcurrency();
2724:
2725: rs.updateObject(columnIndex, x);
2726: }
2727:
2728: /**
2729: * Updates the designated column with a <code>null</code> value.
2730: * The <code>updateXXX</code> methods are used to update column values in the
2731: * current row or the insert row. The <code>updateXXX</code> methods do not
2732: * update the underlying database; instead the <code>updateRow</code> or
2733: * <code>insertRow</code> methods are called to update the database.
2734: *
2735: * @param columnName the name of the column
2736: * @throws SQLException if a database access error occurs
2737: * or this rowset does not currently have a valid connection,
2738: * prepared statement, and result set
2739: *
2740: */
2741: public void updateNull(String columnName) throws SQLException {
2742: updateNull(findColumn(columnName));
2743: }
2744:
2745: /**
2746: * Updates the designated column with a <code>boolean</code> value.
2747: * The <code>updateXXX</code> methods are used to update column values in the
2748: * current row or the insert row. The <code>updateXXX</code> methods do not
2749: * update the underlying database; instead the <code>updateRow</code> or
2750: * <code>insertRow</code> methods are called to update the database.
2751: *
2752: * @param columnName the name of the column
2753: * @param x the new column value
2754: * @throws SQLException if a database access error occurs
2755: *
2756: */
2757: public void updateBoolean(String columnName, boolean x)
2758: throws SQLException {
2759: updateBoolean(findColumn(columnName), x);
2760: }
2761:
2762: /**
2763: * Updates the designated column with a <code>byte</code> value.
2764: * The <code>updateXXX</code> methods are used to update column values in the
2765: * current row or the insert row. The <code>updateXXX</code> methods do not
2766: * update the underlying database; instead the <code>updateRow</code> or
2767: * <code>insertRow</code> methods are called to update the database.
2768: *
2769: * @param columnName the name of the column
2770: * @param x the new column value
2771: * @throws SQLException if a database access error occurs
2772: *
2773: */
2774: public void updateByte(String columnName, byte x)
2775: throws SQLException {
2776: updateByte(findColumn(columnName), x);
2777: }
2778:
2779: /**
2780: * Updates the designated column with a <code>short</code> value.
2781: * The <code>updateXXX</code> methods are used to update column values in the
2782: * current row or the insert row. The <code>updateXXX</code> methods do not
2783: * update the underlying database; instead the <code>updateRow</code> or
2784: * <code>insertRow</code> methods are called to update the database.
2785: *
2786: * @param columnName the name of the column
2787: * @param x the new column value
2788: * @throws SQLException if a database access error occurs
2789: *
2790: */
2791: public void updateShort(String columnName, short x)
2792: throws SQLException {
2793: updateShort(findColumn(columnName), x);
2794: }
2795:
2796: /**
2797: * Updates the designated column with an <code>int</code> value.
2798: * The <code>updateXXX</code> methods are used to update column values in the
2799: * current row or the insert row. The <code>updateXXX</code> methods do not
2800: * update the underlying database; instead the <code>updateRow</code> or
2801: * <code>insertRow</code> methods are called to update the database.
2802: *
2803: * @param columnName the name of the column
2804: * @param x the new column value
2805: * @throws SQLException if a database access error occurs
2806: *
2807: */
2808: public void updateInt(String columnName, int x) throws SQLException {
2809: updateInt(findColumn(columnName), x);
2810: }
2811:
2812: /**
2813: * Updates the designated column with a <code>long</code> value.
2814: * The <code>updateXXX</code> methods are used to update column values in the
2815: * current row or the insert row. The <code>updateXXX</code> methods do not
2816: * update the underlying database; instead the <code>updateRow</code> or
2817: * <code>insertRow</code> methods are called to update the database.
2818: *
2819: * @param columnName the name of the column
2820: * @param x the new column value
2821: * @throws SQLException if a database access error occurs
2822: *
2823: */
2824: public void updateLong(String columnName, long x)
2825: throws SQLException {
2826: updateLong(findColumn(columnName), x);
2827: }
2828:
2829: /**
2830: * Updates the designated column with a <code>float </code> value.
2831: * The <code>updateXXX</code> methods are used to update column values in the
2832: * current row or the insert row. The <code>updateXXX</code> methods do not
2833: * update the underlying database; instead the <code>updateRow</code> or
2834: * <code>insertRow</code> methods are called to update the database.
2835: *
2836: * @param columnName the name of the column
2837: * @param x the new column value
2838: * @throws SQLException if a database access error occurs
2839: *
2840: */
2841: public void updateFloat(String columnName, float x)
2842: throws SQLException {
2843: updateFloat(findColumn(columnName), x);
2844: }
2845:
2846: /**
2847: * Updates the designated column with a <code>double</code> value.
2848: * The <code>updateXXX</code> methods are used to update column values in the
2849: * current row or the insert row. The <code>updateXXX</code> methods do not
2850: * update the underlying database; instead the <code>updateRow</code> or
2851: * <code>insertRow</code> methods are called to update the database.
2852: *
2853: * @param columnName the name of the column
2854: * @param x the new column value
2855: * @throws SQLException if a database access error occurs
2856: *
2857: */
2858: public void updateDouble(String columnName, double x)
2859: throws SQLException {
2860: updateDouble(findColumn(columnName), x);
2861: }
2862:
2863: /**
2864: * Updates the designated column with a <code>java.sql.BigDecimal</code>
2865: * value.
2866: * The <code>updateXXX</code> methods are used to update column values in the
2867: * current row or the insert row. The <code>updateXXX</code> methods do not
2868: * update the underlying database; instead the <code>updateRow</code> or
2869: * <code>insertRow</code> methods are called to update the database.
2870: *
2871: * @param columnName the name of the column
2872: * @param x the new column value
2873: * @throws SQLException if a database access error occurs
2874: *
2875: */
2876: public void updateBigDecimal(String columnName, BigDecimal x)
2877: throws SQLException {
2878: updateBigDecimal(findColumn(columnName), x);
2879: }
2880:
2881: /**
2882: * Updates the designated column with a <code>String</code> value.
2883: * The <code>updateXXX</code> methods are used to update column values in the
2884: * current row or the insert row. The <code>updateXXX</code> methods do not
2885: * update the underlying database; instead the <code>updateRow</code> or
2886: * <code>insertRow</code> methods are called to update the database.
2887: *
2888: * @param columnName the name of the column
2889: * @param x the new column value
2890: * @throws SQLException if a database access error occurs
2891: *
2892: */
2893: public void updateString(String columnName, String x)
2894: throws SQLException {
2895: updateString(findColumn(columnName), x);
2896: }
2897:
2898: /**
2899: * Updates the designated column with a <code>boolean</code> value.
2900: * The <code>updateXXX</code> methods are used to update column values in the
2901: * current row or the insert row. The <code>updateXXX</code> methods do not
2902: * update the underlying database; instead the <code>updateRow</code> or
2903: * <code>insertRow</code> methods are called to update the database.
2904: *
2905: * JDBC 2.0
2906: *
2907: * Updates a column with a byte array value.
2908: *
2909: * The <code>updateXXX</code> methods are used to update column values in the
2910: * current row, or the insert row. The <code>updateXXX</code> methods do not
2911: * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
2912: * methods are called to update the database.
2913: *
2914: * @param columnName the name of the column
2915: * @param x the new column value
2916: * @throws SQLException if a database access error occurs
2917: *
2918: */
2919: public void updateBytes(String columnName, byte x[])
2920: throws SQLException {
2921: updateBytes(findColumn(columnName), x);
2922: }
2923:
2924: /**
2925: * Updates the designated column with a <code>java.sql.Date</code> value.
2926: * The <code>updateXXX</code> methods are used to update column values in the
2927: * current row or the insert row. The <code>updateXXX</code> methods do not
2928: * update the underlying database; instead the <code>updateRow</code> or
2929: * <code>insertRow</code> methods are called to update the database.
2930: *
2931: * @param columnName the name of the column
2932: * @param x the new column value
2933: * @throws SQLException if a database access error occurs
2934: *
2935: */
2936: public void updateDate(String columnName, java.sql.Date x)
2937: throws SQLException {
2938: updateDate(findColumn(columnName), x);
2939: }
2940:
2941: /**
2942: * Updates the designated column with a <code>java.sql.Time</code> value.
2943: * The <code>updateXXX</code> methods are used to update column values in the
2944: * current row or the insert row. The <code>updateXXX</code> methods do not
2945: * update the underlying database; instead the <code>updateRow</code> or
2946: * <code>insertRow</code> methods are called to update the database.
2947: *
2948: * @param columnName the name of the column
2949: * @param x the new column value
2950: * @throws SQLException if a database access error occurs
2951: *
2952: */
2953: public void updateTime(String columnName, java.sql.Time x)
2954: throws SQLException {
2955: updateTime(findColumn(columnName), x);
2956: }
2957:
2958: /**
2959: * Updates the designated column with a <code>java.sql.Timestamp</code>
2960: * value.
2961: * The <code>updateXXX</code> methods are used to update column values in the
2962: * current row or the insert row. The <code>updateXXX</code> methods do not
2963: * update the underlying database; instead the <code>updateRow</code> or
2964: * <code>insertRow</code> methods are called to update the database.
2965: *
2966: * @param columnName the name of the column
2967: * @param x the new column value
2968: * @throws SQLException if a database access error occurs
2969: *
2970: */
2971: public void updateTimestamp(String columnName, java.sql.Timestamp x)
2972: throws SQLException {
2973: updateTimestamp(findColumn(columnName), x);
2974: }
2975:
2976: /**
2977: * Updates the designated column with an ascii stream value.
2978: * The <code>updateXXX</code> methods are used to update column values in the
2979: * current row or the insert row. The <code>updateXXX</code> methods do not
2980: * update the underlying database; instead the <code>updateRow</code> or
2981: * <code>insertRow</code> methods are called to update the database.
2982: *
2983: * @param columnName the name of the column
2984: * @param x the new column value
2985: * @param length the length of the stream
2986: * @throws SQLException if a database access error occurs
2987: *
2988: */
2989: public void updateAsciiStream(String columnName,
2990: java.io.InputStream x, int length) throws SQLException {
2991: updateAsciiStream(findColumn(columnName), x, length);
2992: }
2993:
2994: /**
2995: * Updates the designated column with a binary stream value.
2996: * The <code>updateXXX</code> methods are used to update column values in the
2997: * current row or the insert row. The <code>updateXXX</code> methods do not
2998: * update the underlying database; instead the <code>updateRow</code> or
2999: * <code>insertRow</code> methods are called to update the database.
3000: *
3001: * @param columnName the name of the column
3002: * @param x the new column value
3003: * @param length the length of the stream
3004: * @throws SQLException if a database access error occurs
3005: *
3006: */
3007: public void updateBinaryStream(String columnName,
3008: java.io.InputStream x, int length) throws SQLException {
3009: updateBinaryStream(findColumn(columnName), x, length);
3010: }
3011:
3012: /**
3013: * Updates the designated column with a character stream value.
3014: * The <code>updateXXX</code> methods are used to update column values
3015: * in the current row or the insert row. The <code>updateXXX</code>
3016: * methods do not update the underlying database; instead the
3017: * <code>updateRow</code> or <code>insertRow</code> methods are called
3018: * to update the database.
3019: *
3020: * @param columnName the name of the column
3021: * @param reader the new column <code>Reader</code> stream value
3022: * @param length the length of the stream
3023: * @throws SQLException if a database access error occurs
3024: *
3025: */
3026: public void updateCharacterStream(String columnName,
3027: java.io.Reader reader, int length) throws SQLException {
3028: updateCharacterStream(findColumn(columnName), reader, length);
3029: }
3030:
3031: /**
3032: * Updates the designated column with an <code>Object</code> value.
3033: * The <code>updateXXX</code> methods are used to update column values in the
3034: * current row or the insert row. The <code>updateXXX</code> methods do not
3035: * update the underlying database; instead the <code>updateRow</code> or
3036: * <code>insertRow</code> methods are called to update the database.
3037: *
3038: * @param columnName the name of the column
3039: * @param x the new column value
3040: * @param scale for <code>java.sql.Types.DECIMAL</code>
3041: * or <code>java.sql.Types.NUMERIC</code> types,
3042: * this is the number of digits after the decimal point. For all other
3043: * types this value will be ignored.
3044: * @throws SQLException if a database access error occurs
3045: *
3046: */
3047: public void updateObject(String columnName, Object x, int scale)
3048: throws SQLException {
3049: updateObject(findColumn(columnName), x, scale);
3050: }
3051:
3052: /**
3053: * Updates the designated column with an <code>Object</code> value.
3054: * The <code>updateXXX</code> methods are used to update column values in the
3055: * current row or the insert row. The <code>updateXXX</code> methods do not
3056: * update the underlying database; instead the <code>updateRow</code> or
3057: * <code>insertRow</code> methods are called to update the database.
3058: *
3059: * @param columnName the name of the column
3060: * @param x the new column value
3061: * @throws SQLException if a database access error occurs
3062: *
3063: */
3064: public void updateObject(String columnName, Object x)
3065: throws SQLException {
3066: updateObject(findColumn(columnName), x);
3067: }
3068:
3069: /**
3070: * Inserts the contents of the insert row into this
3071: * <code>ResultSet</code> object and into the database
3072: * and also notifies listeners that a row has changed.
3073: * The cursor must be on the insert row when this method is called.
3074: *
3075: * @throws SQLException if (1) a database access error occurs,
3076: * (2) this method is called when the cursor is not
3077: * on the insert row, (3) not all non-nullable columns in
3078: * the insert row have been given a value, or (4) this
3079: * rowset does not currently have a valid connection,
3080: * prepared statement, and result set
3081: */
3082: public void insertRow() throws SQLException {
3083: checkState();
3084:
3085: rs.insertRow();
3086: notifyRowChanged();
3087: }
3088:
3089: /**
3090: * Updates the underlying database with the new contents of the
3091: * current row of this rowset's <code>ResultSet</code> object
3092: * and notifies listeners that a row has changed.
3093: * This method cannot be called when the cursor is on the insert row.
3094: *
3095: * @throws SQLException if (1) a database access error occurs,
3096: * (2) this method is called when the cursor is
3097: * on the insert row, (3) the concurrency of the result
3098: * set is <code>ResultSet.CONCUR_READ_ONLY</code>, or
3099: * (4) this rowset does not currently have a valid connection,
3100: * prepared statement, and result set
3101: */
3102: public void updateRow() throws SQLException {
3103: checkState();
3104:
3105: rs.updateRow();
3106: notifyRowChanged();
3107: }
3108:
3109: /**
3110: * Deletes the current row from this rowset's <code>ResultSet</code> object
3111: * and from the underlying database and also notifies listeners that a row
3112: * has changed. This method cannot be called when the cursor is on the insert
3113: * row.
3114: *
3115: * @throws SQLException if a database access error occurs
3116: * or if this method is called when the cursor is on the insert row
3117: * @throws SQLException if (1) a database access error occurs,
3118: * (2) this method is called when the cursor is before the
3119: * first row, after the last row, or on the insert row,
3120: * (3) the concurrency of this rowset's result
3121: * set is <code>ResultSet.CONCUR_READ_ONLY</code>, or
3122: * (4) this rowset does not currently have a valid connection,
3123: * prepared statement, and result set
3124: */
3125: public void deleteRow() throws SQLException {
3126: checkState();
3127:
3128: rs.deleteRow();
3129: notifyRowChanged();
3130: }
3131:
3132: /**
3133: * Refreshes the current row of this rowset's <code>ResultSet</code>
3134: * object with its most recent value in the database. This method
3135: * cannot be called when the cursor is on the insert row.
3136: *
3137: * <P>The <code>refreshRow</code> method provides a way for an
3138: * application to explicitly tell the JDBC driver to refetch
3139: * a row(s) from the database. An application may want to call
3140: * <code>refreshRow</code> when caching or prefetching is being
3141: * done by the JDBC driver to fetch the latest value of a row
3142: * from the database. The JDBC driver may actually refresh multiple
3143: * rows at once if the fetch size is greater than one.
3144: *
3145: * <P> All values are refetched subject to the transaction isolation
3146: * level and cursor sensitivity. If <code>refreshRow</code> is called after
3147: * calling an <code>updateXXX</code> method, but before calling
3148: * the method <code>updateRow</code>, then the
3149: * updates made to the row are lost. Calling the method
3150: * <code>refreshRow</code> frequently will likely slow performance.
3151: *
3152: * @throws SQLException if (1) a database access error occurs,
3153: * (2) this method is called when the cursor is
3154: * on the insert row, or (3) this rowset does not
3155: * currently have a valid connection, prepared statement,
3156: * and result set
3157: *
3158: */
3159: public void refreshRow() throws SQLException {
3160: checkState();
3161:
3162: rs.refreshRow();
3163: }
3164:
3165: /**
3166: * Cancels the updates made to the current row in this
3167: * <code>ResultSet</code> object and notifies listeners that a row
3168: * has changed. This method may be called after calling an
3169: * <code>updateXXX</code> method(s) and before calling
3170: * the method <code>updateRow</code> to roll back
3171: * the updates made to a row. If no updates have been made or
3172: * <code>updateRow</code> has already been called, this method has no
3173: * effect.
3174: *
3175: * @throws SQLException if (1) a database access error occurs,
3176: * (2) this method is called when the cursor is
3177: * on the insert row, or (3) this rowset does not
3178: * currently have a valid connection, prepared statement,
3179: * and result set
3180: */
3181: public void cancelRowUpdates() throws SQLException {
3182: checkState();
3183:
3184: rs.cancelRowUpdates();
3185:
3186: notifyRowChanged();
3187: }
3188:
3189: /**
3190: * Moves the cursor to the insert row. The current cursor position is
3191: * remembered while the cursor is positioned on the insert row.
3192: *
3193: * The insert row is a special row associated with an updatable
3194: * result set. It is essentially a buffer where a new row may
3195: * be constructed by calling the <code>updateXXX</code> methods prior to
3196: * inserting the row into the result set.
3197: *
3198: * Only the <code>updateXXX</code>, <code>getXXX</code>,
3199: * and <code>insertRow</code> methods may be
3200: * called when the cursor is on the insert row. All of the columns in
3201: * a result set must be given a value each time this method is
3202: * called before calling <code>insertRow</code>.
3203: * An <code>updateXXX</code> method must be called before a
3204: * <code>getXXX</code> method can be called on a column value.
3205: *
3206: * @throws SQLException if (1) a database access error occurs,
3207: * (2) this rowset's <code>ResultSet</code> object is
3208: * not updatable, or (3) this rowset does not
3209: * currently have a valid connection, prepared statement,
3210: * and result set
3211: *
3212: */
3213: public void moveToInsertRow() throws SQLException {
3214: checkState();
3215:
3216: rs.moveToInsertRow();
3217: }
3218:
3219: /**
3220: * Moves the cursor to the remembered cursor position, usually the
3221: * current row. This method has no effect if the cursor is not on
3222: * the insert row.
3223: *
3224: * @throws SQLException if (1) a database access error occurs,
3225: * (2) this rowset's <code>ResultSet</code> object is
3226: * not updatable, or (3) this rowset does not
3227: * currently have a valid connection, prepared statement,
3228: * and result set
3229: */
3230: public void moveToCurrentRow() throws SQLException {
3231: checkState();
3232:
3233: rs.moveToCurrentRow();
3234: }
3235:
3236: /**
3237: * Returns the <code>Statement</code> object that produced this
3238: * <code>ResultSet</code> object.
3239: * If the result set was generated some other way, such as by a
3240: * <code>DatabaseMetaData</code> method, this method returns
3241: * <code>null</code>.
3242: *
3243: * @return the <code>Statment</code> object that produced
3244: * this rowset's <code>ResultSet</code> object or <code>null</code>
3245: * if the result set was produced some other way
3246: * @throws SQLException if a database access error occurs
3247: */
3248: public java.sql.Statement getStatement() throws SQLException {
3249:
3250: if (rs != null) {
3251: return rs.getStatement();
3252: } else {
3253: return null;
3254: }
3255: }
3256:
3257: /**
3258: * Returns the value of the designated column in the current row
3259: * of this rowset's <code>ResultSet</code> object as an <code>Object</code>.
3260: * This method uses the given <code>Map</code> object
3261: * for the custom mapping of the
3262: * SQL structured or distinct type that is being retrieved.
3263: *
3264: * @param i the first column is 1, the second is 2, and so on
3265: * @param map a <code>java.util.Map</code> object that contains the mapping
3266: * from SQL type names to classes in the Java programming language
3267: * @return an <code>Object</code> in the Java programming language
3268: * representing the SQL value
3269: * @throws SQLException if (1) a database access error occurs
3270: * or (2) this rowset does not currently have a valid connection,
3271: * prepared statement, and result set
3272: */
3273: public Object getObject(int i, java.util.Map<String, Class<?>> map)
3274: throws SQLException {
3275: checkState();
3276:
3277: return rs.getObject(i, map);
3278: }
3279:
3280: /**
3281: * Returns the value of the designated column in the current row
3282: * of this rowset's <code>ResultSet</code> object as a <code>Ref</code> object.
3283: *
3284: * @param i the first column is 1, the second is 2, and so on
3285: * @return a <code>Ref</code> object representing an SQL <code>REF</code> value
3286: * @throws SQLException if (1) a database access error occurs
3287: * or (2) this rowset does not currently have a valid connection,
3288: * prepared statement, and result set
3289: */
3290: public Ref getRef(int i) throws SQLException {
3291: checkState();
3292:
3293: return rs.getRef(i);
3294: }
3295:
3296: /**
3297: * Returns the value of the designated column in the current row
3298: * of this rowset's <code>ResultSet</code> object as a <code>Blob</code> object.
3299: *
3300: * @param i the first column is 1, the second is 2, and so on
3301: * @return a <code>Blob</code> object representing the SQL <code>BLOB</code>
3302: * value in the specified column
3303: * @throws SQLException if (1) a database access error occurs
3304: * or (2) this rowset does not currently have a valid connection,
3305: * prepared statement, and result set
3306: */
3307: public Blob getBlob(int i) throws SQLException {
3308: checkState();
3309:
3310: return rs.getBlob(i);
3311: }
3312:
3313: /**
3314: * Returns the value of the designated column in the current row
3315: * of this rowset's <code>ResultSet</code> object as a <code>Clob</code> object.
3316: *
3317: * @param i the first column is 1, the second is 2, and so on
3318: * @return a <code>Clob</code> object representing the SQL <code>CLOB</code>
3319: * value in the specified column
3320: * @throws SQLException if (1) a database access error occurs
3321: * or (2) this rowset does not currently have a valid connection,
3322: * prepared statement, and result set
3323: */
3324: public Clob getClob(int i) throws SQLException {
3325: checkState();
3326:
3327: return rs.getClob(i);
3328: }
3329:
3330: /**
3331: * Returns the value of the designated column in the current row
3332: * of this rowset's <code>ResultSet</code> object as an <code>Array</code> object.
3333: *
3334: * @param i the first column is 1, the second is 2, and so on.
3335: * @return an <code>Array</code> object representing the SQL <code>ARRAY</code>
3336: * value in the specified column
3337: * @throws SQLException if (1) a database access error occurs
3338: * or (2) this rowset does not currently have a valid connection,
3339: * prepared statement, and result set
3340: */
3341: public Array getArray(int i) throws SQLException {
3342: checkState();
3343:
3344: return rs.getArray(i);
3345: }
3346:
3347: /**
3348: * Returns the value of the designated column in the current row
3349: * of this rowset's <code>ResultSet</code> object as an <code>Object</code>.
3350: * This method uses the specified <code>Map</code> object for
3351: * custom mapping if appropriate.
3352: *
3353: * @param colName the name of the column from which to retrieve the value
3354: * @param map a <code>java.util.Map</code> object that contains the mapping
3355: * from SQL type names to classes in the Java programming language
3356: * @return an <code>Object</code> representing the SQL
3357: * value in the specified column
3358: * @throws SQLException if (1) a database access error occurs
3359: * or (2) this rowset does not currently have a valid connection,
3360: * prepared statement, and result set
3361: */
3362: public Object getObject(String colName,
3363: java.util.Map<String, Class<?>> map) throws SQLException {
3364: return getObject(findColumn(colName), map);
3365: }
3366:
3367: /**
3368: * Returns the value of the designated column in the current row
3369: * of this rowset's <code>ResultSet</code> object as a <code>Ref</code> object.
3370: *
3371: * @param colName the column name
3372: * @return a <code>Ref</code> object representing the SQL <code>REF</code> value in
3373: * the specified column
3374: * @throws SQLException if (1) a database access error occurs
3375: * or (2) this rowset does not currently have a valid connection,
3376: * prepared statement, and result set
3377: */
3378: public Ref getRef(String colName) throws SQLException {
3379: return getRef(findColumn(colName));
3380: }
3381:
3382: /**
3383: * Returns the value of the designated column in the current row
3384: * of this rowset's <code>ResultSet</code> object as a <code>Blob</code> object.
3385: *
3386: * @param colName the name of the column from which to retrieve the value
3387: * @return a <code>Blob</code> object representing the SQL <code>BLOB</code>
3388: * value in the specified column
3389: * @throws SQLException if (1) a database access error occurs
3390: * or (2) this rowset does not currently have a valid connection,
3391: * prepared statement, and result set
3392: */
3393: public Blob getBlob(String colName) throws SQLException {
3394: return getBlob(findColumn(colName));
3395: }
3396:
3397: /**
3398: * Returns the value of the designated column in the current row
3399: * of this rowset's <code>ResultSet</code> object as a <code>Clob</code> object.
3400: *
3401: * @param colName the name of the column from which to retrieve the value
3402: * @return a <code>Clob</code> object representing the SQL <code>CLOB</code>
3403: * value in the specified column
3404: * @throws SQLException if (1) a database access error occurs
3405: * or (2) this rowset does not currently have a valid connection,
3406: * prepared statement, and result set
3407: */
3408: public Clob getClob(String colName) throws SQLException {
3409: return getClob(findColumn(colName));
3410: }
3411:
3412: /**
3413: * Returns the value of the designated column in the current row
3414: * of this rowset's <code>ResultSet</code> object as an <code>Array</code> object.
3415: *
3416: * @param colName the name of the column from which to retrieve the value
3417: * @return an <code>Array</code> object representing the SQL <code>ARRAY</code>
3418: * value in the specified column
3419: * @throws SQLException if (1) a database access error occurs
3420: * or (2) this rowset does not currently have a valid connection,
3421: * prepared statement, and result set
3422: */
3423: public Array getArray(String colName) throws SQLException {
3424: return getArray(findColumn(colName));
3425: }
3426:
3427: /**
3428: * Returns the value of the designated column in the current row
3429: * of this rowset's <code>ResultSet</code> object as a <code>java.sql.Date</code>
3430: * object. This method uses the given calendar to construct an appropriate
3431: * millisecond value for the date if the underlying database does not store
3432: * timezone information.
3433: *
3434: * @param columnIndex the first column is 1, the second is 2, and so on
3435: * @param cal the <code>java.util.Calendar</code> object
3436: * to use in constructing the date
3437: * @return the column value as a <code>java.sql.Date</code> object;
3438: * if the value is SQL <code>NULL</code>,
3439: * the value returned is <code>null</code>
3440: * @throws SQLException if (1) a database access error occurs
3441: * or (2) this rowset does not currently have a valid connection,
3442: * prepared statement, and result set
3443: */
3444: public java.sql.Date getDate(int columnIndex, Calendar cal)
3445: throws SQLException {
3446: checkState();
3447:
3448: return rs.getDate(columnIndex, cal);
3449: }
3450:
3451: /**
3452: * Returns the value of the designated column in the current row
3453: * of this rowset's <code>ResultSet</code> object as a <code>java.sql.Date</code>
3454: * object. This method uses the given calendar to construct an appropriate
3455: * millisecond value for the date if the underlying database does not store
3456: * timezone information.
3457: *
3458: * @param columnName the SQL name of the column from which to retrieve the value
3459: * @param cal the <code>java.util.Calendar</code> object
3460: * to use in constructing the date
3461: * @return the column value as a <code>java.sql.Date</code> object;
3462: * if the value is SQL <code>NULL</code>,
3463: * the value returned is <code>null</code>
3464: * @throws SQLException if a database access error occurs
3465: * or this rowset does not currently have a valid connection,
3466: * prepared statement, and result set
3467: *
3468: */
3469: public java.sql.Date getDate(String columnName, Calendar cal)
3470: throws SQLException {
3471: return getDate(findColumn(columnName), cal);
3472: }
3473:
3474: /**
3475: * Returns the value of the designated column in the current row
3476: * of this rowset's <code>ResultSet</code> object as a <code>java.sql.Time</code>
3477: * object. This method uses the given calendar to construct an appropriate
3478: * millisecond value for the date if the underlying database does not store
3479: * timezone information.
3480: *
3481: * @param columnIndex the first column is 1, the second is 2, and so on
3482: * @param cal the <code>java.util.Calendar</code> object
3483: * to use in constructing the time
3484: * @return the column value as a <code>java.sql.Time</code> object;
3485: * if the value is SQL <code>NULL</code>,
3486: * the value returned is <code>null</code> in the Java programming language
3487: * @throws SQLException if a database access error occurs
3488: * or this rowset does not currently have a valid connection,
3489: * prepared statement, and result set
3490: */
3491: public java.sql.Time getTime(int columnIndex, Calendar cal)
3492: throws SQLException {
3493: checkState();
3494:
3495: return rs.getTime(columnIndex, cal);
3496: }
3497:
3498: /**
3499: * Returns the value of the designated column in the current row
3500: * of this rowset's <code>ResultSet</code> object as a <code>java.sql.Time</code>
3501: * object. This method uses the given calendar to construct an appropriate
3502: * millisecond value for the date if the underlying database does not store
3503: * timezone information.
3504: *
3505: * @param columnName the SQL name of the column
3506: * @param cal the <code>java.util.Calendar</code> object
3507: * to use in constructing the time
3508: * @return the column value as a <code>java.sql.Time</code> object;
3509: * if the value is SQL <code>NULL</code>,
3510: * the value returned is <code>null</code> in the Java programming language
3511: * @throws SQLException if a database access error occurs
3512: * or this rowset does not currently have a valid connection,
3513: * prepared statement, and result set
3514: */
3515: public java.sql.Time getTime(String columnName, Calendar cal)
3516: throws SQLException {
3517: return getTime(findColumn(columnName), cal);
3518: }
3519:
3520: /**
3521: * Returns the value of the designated column in the current row
3522: * of this rowset's <code>ResultSet</code> object as a
3523: * <code>java.sql.Timestamp</code> object.
3524: * This method uses the given calendar to construct an appropriate millisecond
3525: * value for the timestamp if the underlying database does not store
3526: * timezone information.
3527: *
3528: * @param columnIndex the first column is 1, the second is 2, and so on
3529: * @param cal the <code>java.util.Calendar</code> object
3530: * to use in constructing the timestamp
3531: * @return the column value as a <code>java.sql.Timestamp</code> object;
3532: * if the value is SQL <code>NULL</code>,
3533: * the value returned is <code>null</code>
3534: * @throws SQLException if a database access error occurs
3535: * or this rowset does not currently have a valid connection,
3536: * prepared statement, and result set
3537: */
3538: public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal)
3539: throws SQLException {
3540: checkState();
3541:
3542: return rs.getTimestamp(columnIndex, cal);
3543: }
3544:
3545: /**
3546: * Returns the value of the designated column in the current row
3547: * of this rowset's <code>ResultSet</code> object as a
3548: * <code>java.sql.Timestamp</code> object.
3549: * This method uses the given calendar to construct an appropriate millisecond
3550: * value for the timestamp if the underlying database does not store
3551: * timezone information.
3552: *
3553: * @param columnName the SQL name of the column
3554: * @param cal the <code>java.util.Calendar</code> object
3555: * to use in constructing the timestamp
3556: * @return the column value as a <code>java.sql.Timestamp</code> object;
3557: * if the value is SQL <code>NULL</code>,
3558: * the value returned is <code>null</code>
3559: * @throws SQLException if a database access error occurs
3560: * or this rowset does not currently have a valid connection,
3561: * prepared statement, and result set
3562: */
3563: public java.sql.Timestamp getTimestamp(String columnName,
3564: Calendar cal) throws SQLException {
3565: return getTimestamp(findColumn(columnName), cal);
3566: }
3567:
3568: /**
3569: * Sets the designated column in either the current row or the insert
3570: * row of this <code>JdbcRowSetImpl</code> object with the given
3571: * <code>double</code> value.
3572: *
3573: * This method updates a column value in either the current row or
3574: * the insert row of this rowset, but it does not update the
3575: * database. If the cursor is on a row in the rowset, the
3576: * method {@link #updateRow} must be called to update the database.
3577: * If the cursor is on the insert row, the method {@link #insertRow}
3578: * must be called, which will insert the new row into both this rowset
3579: * and the database. Both of these methods must be called before the
3580: * cursor moves to another row.
3581: *
3582: * @param columnIndex the first column is <code>1</code>, the second
3583: * is <code>2</code>, and so on; must be <code>1</code> or larger
3584: * and equal to or less than the number of columns in this rowset
3585: * @param ref the new <code>Ref</code> column value
3586: * @throws SQLException if (1) the given column index is out of bounds,
3587: * (2) the cursor is not on one of this rowset's rows or its
3588: * insert row, or (3) this rowset is
3589: * <code>ResultSet.CONCUR_READ_ONLY</code>
3590: */
3591: public void updateRef(int columnIndex, java.sql.Ref ref)
3592: throws SQLException {
3593: checkState();
3594: rs.updateRef(columnIndex, ref);
3595: }
3596:
3597: /**
3598: * Sets the designated column in either the current row or the insert
3599: * row of this <code>JdbcRowSetImpl</code> object with the given
3600: * <code>double</code> value.
3601: *
3602: * This method updates a column value in either the current row or
3603: * the insert row of this rowset, but it does not update the
3604: * database. If the cursor is on a row in the rowset, the
3605: * method {@link #updateRow} must be called to update the database.
3606: * If the cursor is on the insert row, the method {@link #insertRow}
3607: * must be called, which will insert the new row into both this rowset
3608: * and the database. Both of these methods must be called before the
3609: * cursor moves to another row.
3610: *
3611: * @param columnName a <code>String</code> object that must match the
3612: * SQL name of a column in this rowset, ignoring case
3613: * @param ref the new column value
3614: * @throws SQLException if (1) the given column name does not match the
3615: * name of a column in this rowset, (2) the cursor is not on
3616: * one of this rowset's rows or its insert row, or (3) this
3617: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3618: */
3619: public void updateRef(String columnName, java.sql.Ref ref)
3620: throws SQLException {
3621: updateRef(findColumn(columnName), ref);
3622: }
3623:
3624: /**
3625: * Sets the designated column in either the current row or the insert
3626: * row of this <code>JdbcRowSetImpl</code> object with the given
3627: * <code>double</code> value.
3628: *
3629: * This method updates a column value in either the current row or
3630: * the insert row of this rowset, but it does not update the
3631: * database. If the cursor is on a row in the rowset, the
3632: * method {@link #updateRow} must be called to update the database.
3633: * If the cursor is on the insert row, the method {@link #insertRow}
3634: * must be called, which will insert the new row into both this rowset
3635: * and the database. Both of these methods must be called before the
3636: * cursor moves to another row.
3637: *
3638: * @param columnIndex the first column is <code>1</code>, the second
3639: * is <code>2</code>, and so on; must be <code>1</code> or larger
3640: * and equal to or less than the number of columns in this rowset
3641: * @param c the new column <code>Clob</code> value
3642: * @throws SQLException if (1) the given column index is out of bounds,
3643: * (2) the cursor is not on one of this rowset's rows or its
3644: * insert row, or (3) this rowset is
3645: * <code>ResultSet.CONCUR_READ_ONLY</code>
3646: */
3647: public void updateClob(int columnIndex, Clob c) throws SQLException {
3648: checkState();
3649: rs.updateClob(columnIndex, c);
3650: }
3651:
3652: /**
3653: * Sets the designated column in either the current row or the insert
3654: * row of this <code>JdbcRowSetImpl</code> object with the given
3655: * <code>double</code> value.
3656: *
3657: * This method updates a column value in either the current row or
3658: * the insert row of this rowset, but it does not update the
3659: * database. If the cursor is on a row in the rowset, the
3660: * method {@link #updateRow} must be called to update the database.
3661: * If the cursor is on the insert row, the method {@link #insertRow}
3662: * must be called, which will insert the new row into both this rowset
3663: * and the database. Both of these methods must be called before the
3664: * cursor moves to another row.
3665: *
3666: * @param columnName a <code>String</code> object that must match the
3667: * SQL name of a column in this rowset, ignoring case
3668: * @param c the new column <code>Clob</code> value
3669: * @throws SQLException if (1) the given column name does not match the
3670: * name of a column in this rowset, (2) the cursor is not on
3671: * one of this rowset's rows or its insert row, or (3) this
3672: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3673: */
3674: public void updateClob(String columnName, Clob c)
3675: throws SQLException {
3676: updateClob(findColumn(columnName), c);
3677: }
3678:
3679: /**
3680: * Sets the designated column in either the current row or the insert
3681: * row of this <code>JdbcRowSetImpl</code> object with the given
3682: * <code>java.sql.Blob</code> value.
3683: *
3684: * This method updates a column value in either the current row or
3685: * the insert row of this rowset, but it does not update the
3686: * database. If the cursor is on a row in the rowset, the
3687: * method {@link #updateRow} must be called to update the database.
3688: * If the cursor is on the insert row, the method {@link #insertRow}
3689: * must be called, which will insert the new row into both this rowset
3690: * and the database. Both of these methods must be called before the
3691: * cursor moves to another row.
3692: *
3693: * @param columnIndex the first column is <code>1</code>, the second
3694: * is <code>2</code>, and so on; must be <code>1</code> or larger
3695: * and equal to or less than the number of columns in this rowset
3696: * @param b the new column <code>Blob</code> value
3697: * @throws SQLException if (1) the given column index is out of bounds,
3698: * (2) the cursor is not on one of this rowset's rows or its
3699: * insert row, or (3) this rowset is
3700: * <code>ResultSet.CONCUR_READ_ONLY</code>
3701: */
3702: public void updateBlob(int columnIndex, Blob b) throws SQLException {
3703: checkState();
3704: rs.updateBlob(columnIndex, b);
3705: }
3706:
3707: /**
3708: * Sets the designated column in either the current row or the insert
3709: * row of this <code>JdbcRowSetImpl</code> object with the given
3710: * <code>java.sql.Blob </code> value.
3711: *
3712: * This method updates a column value in either the current row or
3713: * the insert row of this rowset, but it does not update the
3714: * database. If the cursor is on a row in the rowset, the
3715: * method {@link #updateRow} must be called to update the database.
3716: * If the cursor is on the insert row, the method {@link #insertRow}
3717: * must be called, which will insert the new row into both this rowset
3718: * and the database. Both of these methods must be called before the
3719: * cursor moves to another row.
3720: *
3721: * @param columnName a <code>String</code> object that must match the
3722: * SQL name of a column in this rowset, ignoring case
3723: * @param b the new column <code>Blob</code> value
3724: * @throws SQLException if (1) the given column name does not match the
3725: * name of a column in this rowset, (2) the cursor is not on
3726: * one of this rowset's rows or its insert row, or (3) this
3727: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3728: */
3729: public void updateBlob(String columnName, Blob b)
3730: throws SQLException {
3731: updateBlob(findColumn(columnName), b);
3732: }
3733:
3734: /**
3735: * Sets the designated column in either the current row or the insert
3736: * row of this <code>JdbcRowSetImpl</code> object with the given
3737: * <code>java.sql.Array</code> values.
3738: *
3739: * This method updates a column value in either the current row or
3740: * the insert row of this rowset, but it does not update the
3741: * database. If the cursor is on a row in the rowset, the
3742: * method {@link #updateRow} must be called to update the database.
3743: * If the cursor is on the insert row, the method {@link #insertRow}
3744: * must be called, which will insert the new row into both this rowset
3745: * and the database. Both of these methods must be called before the
3746: * cursor moves to another row.
3747: *
3748: * @param columnIndex the first column is <code>1</code>, the second
3749: * is <code>2</code>, and so on; must be <code>1</code> or larger
3750: * and equal to or less than the number of columns in this rowset
3751: * @param a the new column <code>Array</code> value
3752: * @throws SQLException if (1) the given column index is out of bounds,
3753: * (2) the cursor is not on one of this rowset's rows or its
3754: * insert row, or (3) this rowset is
3755: * <code>ResultSet.CONCUR_READ_ONLY</code>
3756: */
3757: public void updateArray(int columnIndex, Array a)
3758: throws SQLException {
3759: checkState();
3760: rs.updateArray(columnIndex, a);
3761: }
3762:
3763: /**
3764: * Sets the designated column in either the current row or the insert
3765: * row of this <code>JdbcRowSetImpl</code> object with the given
3766: * <code>java.sql.Array</code> value.
3767: *
3768: * This method updates a column value in either the current row or
3769: * the insert row of this rowset, but it does not update the
3770: * database. If the cursor is on a row in the rowset, the
3771: * method {@link #updateRow} must be called to update the database.
3772: * If the cursor is on the insert row, the method {@link #insertRow}
3773: * must be called, which will insert the new row into both this rowset
3774: * and the database. Both of these methods must be called before the
3775: * cursor moves to another row.
3776: *
3777: * @param columnName a <code>String</code> object that must match the
3778: * SQL name of a column in this rowset, ignoring case
3779: * @param a the new column <code>Array</code> value
3780: * @throws SQLException if (1) the given column name does not match the
3781: * name of a column in this rowset, (2) the cursor is not on
3782: * one of this rowset's rows or its insert row, or (3) this
3783: * rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
3784: */
3785: public void updateArray(String columnName, Array a)
3786: throws SQLException {
3787: updateArray(findColumn(columnName), a);
3788: }
3789:
3790: /**
3791: * Provide interface coverage for getURL(int) in ResultSet->RowSet
3792: */
3793: public java.net.URL getURL(int columnIndex) throws SQLException {
3794: checkState();
3795: return rs.getURL(columnIndex);
3796: }
3797:
3798: /**
3799: * Provide interface coverage for getURL(String) in ResultSet->RowSet
3800: */
3801: public java.net.URL getURL(String columnName) throws SQLException {
3802: return getURL(findColumn(columnName));
3803: }
3804:
3805: /**
3806: * Return the RowSetWarning object for the current row of a
3807: * <code>JdbcRowSetImpl</code>
3808: */
3809: public RowSetWarning getRowSetWarnings() throws SQLException {
3810: return null;
3811: }
3812:
3813: /**
3814: * Unsets the designated parameter to the given int array.
3815: * This was set using <code>setMatchColumn</code>
3816: * as the column which will form the basis of the join.
3817: * <P>
3818: * The parameter value unset by this method should be same
3819: * as was set.
3820: *
3821: * @param columnIdxes the index into this rowset
3822: * object's internal representation of parameter values
3823: * @throws SQLException if an error occurs or the
3824: * parameter index is out of bounds or if the columnIdx is
3825: * not the same as set using <code>setMatchColumn(int [])</code>
3826: */
3827: public void unsetMatchColumn(int[] columnIdxes) throws SQLException {
3828:
3829: int i_val;
3830: for (int j = 0; j < columnIdxes.length; j++) {
3831: i_val = (Integer.parseInt(iMatchColumns.get(j).toString()));
3832: if (columnIdxes[j] != i_val) {
3833: throw new SQLException(jdbcResBundle.handleGetObject(
3834: "jdbcrowsetimpl.matchcols").toString());
3835: }
3836: }
3837:
3838: for (int i = 0; i < columnIdxes.length; i++) {
3839: iMatchColumns.set(i, new Integer(-1));
3840: }
3841: }
3842:
3843: /**
3844: * Unsets the designated parameter to the given String array.
3845: * This was set using <code>setMatchColumn</code>
3846: * as the column which will form the basis of the join.
3847: * <P>
3848: * The parameter value unset by this method should be same
3849: * as was set.
3850: *
3851: * @param columnIdxes the index into this rowset
3852: * object's internal representation of parameter values
3853: * @throws SQLException if an error occurs or the
3854: * parameter index is out of bounds or if the columnName is
3855: * not the same as set using <code>setMatchColumn(String [])</code>
3856: */
3857: public void unsetMatchColumn(String[] columnIdxes)
3858: throws SQLException {
3859:
3860: for (int j = 0; j < columnIdxes.length; j++) {
3861: if (!columnIdxes[j].equals(strMatchColumns.get(j))) {
3862: throw new SQLException(jdbcResBundle.handleGetObject(
3863: "jdbcrowsetimpl.matchcols").toString());
3864: }
3865: }
3866:
3867: for (int i = 0; i < columnIdxes.length; i++) {
3868: strMatchColumns.set(i, null);
3869: }
3870: }
3871:
3872: /**
3873: * Retrieves the column name as <code>String</code> array
3874: * that was set using <code>setMatchColumn(String [])</code>
3875: * for this rowset.
3876: *
3877: * @return a <code>String</code> array object that contains the column names
3878: * for the rowset which has this the match columns
3879: *
3880: * @throws SQLException if an error occurs or column name is not set
3881: */
3882: public String[] getMatchColumnNames() throws SQLException {
3883:
3884: String[] str_temp = new String[strMatchColumns.size()];
3885:
3886: if (strMatchColumns.get(0) == null) {
3887: throw new SQLException(jdbcResBundle.handleGetObject(
3888: "jdbcrowsetimpl.setmatchcols").toString());
3889: }
3890:
3891: strMatchColumns.copyInto(str_temp);
3892: return str_temp;
3893: }
3894:
3895: /**
3896: * Retrieves the column id as <code>int</code> array that was set using
3897: * <code>setMatchColumn(int [])</code> for this rowset.
3898: *
3899: * @return a <code>int</code> array object that contains the column ids
3900: * for the rowset which has this as the match columns.
3901: *
3902: * @throws SQLException if an error occurs or column index is not set
3903: */
3904: public int[] getMatchColumnIndexes() throws SQLException {
3905:
3906: Integer[] int_temp = new Integer[iMatchColumns.size()];
3907: int[] i_temp = new int[iMatchColumns.size()];
3908: int i_val;
3909:
3910: i_val = ((Integer) iMatchColumns.get(0)).intValue();
3911:
3912: if (i_val == -1) {
3913: throw new SQLException(jdbcResBundle.handleGetObject(
3914: "jdbcrowsetimpl.setmatchcols").toString());
3915: }
3916:
3917: iMatchColumns.copyInto(int_temp);
3918:
3919: for (int i = 0; i < int_temp.length; i++) {
3920: i_temp[i] = (int_temp[i]).intValue();
3921: }
3922:
3923: return i_temp;
3924: }
3925:
3926: /**
3927: * Sets the designated parameter to the given int array.
3928: * This forms the basis of the join for the
3929: * <code>JoinRowSet</code> as the column which will form the basis of the
3930: * join.
3931: * <P>
3932: * The parameter value set by this method is stored internally and
3933: * will be supplied as the appropriate parameter in this rowset's
3934: * command when the method <code>getMatchColumnIndexes</code> is called.
3935: *
3936: * @param columnIdxes the indexes into this rowset
3937: * object's internal representation of parameter values; the
3938: * first parameter is 0, the second is 1, and so on; must be
3939: * <code>0</code> or greater
3940: * @throws SQLException if an error occurs or the
3941: * parameter index is out of bounds
3942: */
3943: public void setMatchColumn(int[] columnIdxes) throws SQLException {
3944:
3945: for (int j = 0; j < columnIdxes.length; j++) {
3946: if (columnIdxes[j] < 0) {
3947: throw new SQLException(jdbcResBundle.handleGetObject(
3948: "jdbcrowsetimpl.matchcols1").toString());
3949: }
3950: }
3951: for (int i = 0; i < columnIdxes.length; i++) {
3952: iMatchColumns.add(i, new Integer(columnIdxes[i]));
3953: }
3954: }
3955:
3956: /**
3957: * Sets the designated parameter to the given String array.
3958: * This forms the basis of the join for the
3959: * <code>JoinRowSet</code> as the column which will form the basis of the
3960: * join.
3961: * <P>
3962: * The parameter value set by this method is stored internally and
3963: * will be supplied as the appropriate parameter in this rowset's
3964: * command when the method <code>getMatchColumn</code> is called.
3965: *
3966: * @param columnNames the name of the column into this rowset
3967: * object's internal representation of parameter values
3968: * @throws SQLException if an error occurs or the
3969: * parameter index is out of bounds
3970: */
3971: public void setMatchColumn(String[] columnNames)
3972: throws SQLException {
3973:
3974: for (int j = 0; j < columnNames.length; j++) {
3975: if (columnNames[j] == null || columnNames[j].equals("")) {
3976: throw new SQLException(jdbcResBundle.handleGetObject(
3977: "jdbcrowsetimpl.matchcols2").toString());
3978: }
3979: }
3980: for (int i = 0; i < columnNames.length; i++) {
3981: strMatchColumns.add(i, columnNames[i]);
3982: }
3983: }
3984:
3985: /**
3986: * Sets the designated parameter to the given <code>int</code>
3987: * object. This forms the basis of the join for the
3988: * <code>JoinRowSet</code> as the column which will form the basis of the
3989: * join.
3990: * <P>
3991: * The parameter value set by this method is stored internally and
3992: * will be supplied as the appropriate parameter in this rowset's
3993: * command when the method <code>getMatchColumn</code> is called.
3994: *
3995: * @param columnIdx the index into this rowset
3996: * object's internal representation of parameter values; the
3997: * first parameter is 0, the second is 1, and so on; must be
3998: * <code>0</code> or greater
3999: * @throws SQLException if an error occurs or the
4000: * parameter index is out of bounds
4001: */
4002: public void setMatchColumn(int columnIdx) throws SQLException {
4003: // validate, if col is ok to be set
4004: if (columnIdx < 0) {
4005: throw new SQLException(jdbcResBundle.handleGetObject(
4006: "jdbcrowsetimpl.matchcols1").toString());
4007: } else {
4008: // set iMatchColumn
4009: iMatchColumns.set(0, new Integer(columnIdx));
4010: //strMatchColumn = null;
4011: }
4012: }
4013:
4014: /**
4015: * Sets the designated parameter to the given <code>String</code>
4016: * object. This forms the basis of the join for the
4017: * <code>JoinRowSet</code> as the column which will form the basis of the
4018: * join.
4019: * <P>
4020: * The parameter value set by this method is stored internally and
4021: * will be supplied as the appropriate parameter in this rowset's
4022: * command when the method <code>getMatchColumn</code> is called.
4023: *
4024: * @param columnName the name of the column into this rowset
4025: * object's internal representation of parameter values
4026: * @throws SQLException if an error occurs or the
4027: * parameter index is out of bounds
4028: */
4029: public void setMatchColumn(String columnName) throws SQLException {
4030: // validate, if col is ok to be set
4031: if (columnName.equals(null)
4032: || ((columnName = columnName.trim()) == "")) {
4033: throw new SQLException(jdbcResBundle.handleGetObject(
4034: "jdbcrowsetimpl.matchcols2").toString());
4035: } else {
4036: // set strMatchColumn
4037: strMatchColumns.set(0, columnName);
4038: //iMatchColumn = -1;
4039: }
4040: }
4041:
4042: /**
4043: * Unsets the designated parameter to the given <code>int</code>
4044: * object. This was set using <code>setMatchColumn</code>
4045: * as the column which will form the basis of the join.
4046: * <P>
4047: * The parameter value unset by this method should be same
4048: * as was set.
4049: *
4050: * @param columnIdx the index into this rowset
4051: * object's internal representation of parameter values
4052: * @throws SQLException if an error occurs or the
4053: * parameter index is out of bounds or if the columnIdx is
4054: * not the same as set using <code>setMatchColumn(int)</code>
4055: */
4056: public void unsetMatchColumn(int columnIdx) throws SQLException {
4057: // check if we are unsetting the SAME column
4058: if (!iMatchColumns.get(0).equals(new Integer(columnIdx))) {
4059: throw new SQLException(jdbcResBundle.handleGetObject(
4060: "jdbcrowsetimpl.unsetmatch").toString());
4061: } else if (strMatchColumns.get(0) != null) {
4062: throw new SQLException(jdbcResBundle.handleGetObject(
4063: "jdbcrowsetimpl.usecolname").toString());
4064: } else {
4065: // that is, we are unsetting it.
4066: iMatchColumns.set(0, new Integer(-1));
4067: }
4068: }
4069:
4070: /**
4071: * Unsets the designated parameter to the given <code>String</code>
4072: * object. This was set using <code>setMatchColumn</code>
4073: * as the column which will form the basis of the join.
4074: * <P>
4075: * The parameter value unset by this method should be same
4076: * as was set.
4077: *
4078: * @param columnName the index into this rowset
4079: * object's internal representation of parameter values
4080: * @throws SQLException if an error occurs or the
4081: * parameter index is out of bounds or if the columnName is
4082: * not the same as set using <code>setMatchColumn(String)</code>
4083: *
4084: */
4085: public void unsetMatchColumn(String columnName) throws SQLException {
4086: // check if we are unsetting the same column
4087: columnName = columnName.trim();
4088:
4089: if (!((strMatchColumns.get(0)).equals(columnName))) {
4090: throw new SQLException(jdbcResBundle.handleGetObject(
4091: "jdbcrowsetimpl.unsetmatch").toString());
4092: } else if (((Integer) (iMatchColumns.get(0))).intValue() > 0) {
4093: throw new SQLException(jdbcResBundle.handleGetObject(
4094: "jdbcrowsetimpl.usecolid").toString());
4095: } else {
4096: strMatchColumns.set(0, null); // that is, we are unsetting it.
4097: }
4098: }
4099:
4100: /**
4101: * Retrieves the <code>DatabaseMetaData</code> associated with
4102: * the connection handle associated this this
4103: * <code>JdbcRowSet</code> object.
4104: *
4105: * @return the <code>DatabaseMetadata</code> associated
4106: * with the rowset's connection.
4107: * @throws SQLException if a database access error occurs
4108: */
4109: public DatabaseMetaData getDatabaseMetaData() throws SQLException {
4110: Connection con = connect();
4111: return con.getMetaData();
4112: }
4113:
4114: /**
4115: * Retrieves the <code>ParameterMetaData</code> associated with
4116: * the connection handle associated this this
4117: * <code>JdbcRowSet</code> object.
4118: *
4119: * @return the <code>ParameterMetadata</code> associated
4120: * with the rowset's connection.
4121: * @throws SQLException if a database access error occurs
4122: */
4123: public ParameterMetaData getParameterMetaData() throws SQLException {
4124: prepare();
4125: return (ps.getParameterMetaData());
4126: }
4127:
4128: /**
4129: * Commits all updates in this <code>JdbcRowSet</code> object by
4130: * wrapping the internal <code>Connection</code> object and calling
4131: * its <code>commit</code> method.
4132: * This method sets this <code>JdbcRowSet</code> object's private field
4133: * <code>rs</code> to <code>null</code> after saving its value to another
4134: * object, but only if the <code>ResultSet</code>
4135: * constant <code>HOLD_CURSORS_OVER_COMMIT</code> has not been set.
4136: * (The field <code>rs</code> is this <code>JdbcRowSet</code> object's
4137: * <code>ResultSet</code> object.)
4138: *
4139: * @throws SQLException if autoCommit is set to true or if a database
4140: * access error occurs
4141: */
4142: public void commit() throws SQLException {
4143: conn.commit();
4144:
4145: // Checking the holadbility value and making the result set handle null
4146: // Added as per Rave requirements
4147:
4148: if (conn.getHoldability() != HOLD_CURSORS_OVER_COMMIT) {
4149: ResultSet oldVal = rs;
4150: rs = null;
4151: // propertyChangeSupport.firePropertyChange("ResultSet",oldVal,rs);
4152: }
4153: }
4154:
4155: /**
4156: * Sets auto-commit on the internal <code>Connection</code> object with this
4157: * <code>JdbcRowSet</code>
4158: *
4159: * @throws SQLException if a database access error occurs
4160: */
4161: public void setAutoCommit(boolean autoCommit) throws SQLException {
4162: // The connection object should be there
4163: // in order to commit the connection handle on or off.
4164:
4165: if (conn != null) {
4166: conn.setAutoCommit(autoCommit);
4167: } else {
4168: // Coming here means the connection object is null.
4169: // So generate a connection handle internally, since
4170: // a JdbcRowSet is always connected to a db, it is fine
4171: // to get a handle to the connection.
4172:
4173: // Get hold of a connection handle
4174: // and change the autcommit as passesd.
4175: conn = connect();
4176:
4177: // After setting the below the conn.getAutoCommit()
4178: // should return the same value.
4179: conn.setAutoCommit(autoCommit);
4180:
4181: }
4182: }
4183:
4184: /**
4185: * Returns the auto-commit status with this <code>JdbcRowSet</code>.
4186: *
4187: * @return true if auto commit is true; false otherwise
4188: * @throws SQLException if a database access error occurs
4189: */
4190: public boolean getAutoCommit() throws SQLException {
4191: return conn.getAutoCommit();
4192: }
4193:
4194: /**
4195: * Rolls back all the updates in this <code>JdbcRowSet</code> object by
4196: * wrapping the internal <code>Connection</code> object and calling its
4197: * <code>rollback</code> method.
4198: * This method sets this <code>JdbcRowSet</code> object's private field
4199: * <code>rs</code> to <code>null</code> after saving its value to another object.
4200: * (The field <code>rs</code> is this <code>JdbcRowSet</code> object's
4201: * internal <code>ResultSet</code> object.)
4202: *
4203: * @throws SQLException if autoCommit is set to true or a database
4204: * access error occurs
4205: */
4206: public void rollback() throws SQLException {
4207: conn.rollback();
4208:
4209: // Makes the result ste handle null after rollback
4210: // Added as per Rave requirements
4211:
4212: ResultSet oldVal = rs;
4213: rs = null;
4214: // propertyChangeSupport.firePropertyChange("ResultSet", oldVal,rs);
4215: }
4216:
4217: /**
4218: * Rollbacks all the updates in the <code>JdbcRowSet</code> back to the
4219: * last <code>Savepoint</code> transaction marker. Wraps the internal
4220: * <code>Connection</code> object and call it's rollback method
4221: *
4222: * @param s the <code>Savepoint</code> transaction marker to roll the
4223: * transaction to.
4224: * @throws SQLException if autoCommit is set to true; or ia a database
4225: * access error occurs
4226: */
4227: public void rollback(Savepoint s) throws SQLException {
4228: conn.rollback(s);
4229: }
4230:
4231: // Setting the ResultSet Type and Concurrency
4232: protected void setParams() throws SQLException {
4233: if (rs == null) {
4234: setType(ResultSet.TYPE_SCROLL_INSENSITIVE);
4235: setConcurrency(ResultSet.CONCUR_UPDATABLE);
4236: } else {
4237: setType(rs.getType());
4238: setConcurrency(rs.getConcurrency());
4239: }
4240: }
4241:
4242: // Checking ResultSet Type and Concurrency
4243: private void checkTypeConcurrency() throws SQLException {
4244: if (rs.getType() == TYPE_FORWARD_ONLY
4245: || rs.getConcurrency() == CONCUR_READ_ONLY) {
4246: throw new SQLException(jdbcResBundle.handleGetObject(
4247: "jdbcrowsetimpl.resnotupd").toString());
4248: }
4249: }
4250:
4251: // Returns a Connection Handle
4252: // Added as per Rave requirements
4253:
4254: /**
4255: * Gets this <code>JdbcRowSet</code> object's Connection property
4256: *
4257: *
4258: * @return the <code>Connection</code> object associated with this rowset;
4259: */
4260:
4261: protected Connection getConnection() {
4262: return conn;
4263: }
4264:
4265: // Sets the connection handle with the parameter
4266: // Added as per rave requirements
4267:
4268: /**
4269: * Sets this <code>JdbcRowSet</code> object's connection property
4270: * to the given <code>Connection</code> object.
4271: *
4272: * @param connection the <code>Connection</code> object.
4273: */
4274:
4275: protected void setConnection(Connection connection) {
4276: conn = connection;
4277: }
4278:
4279: // Returns a PreparedStatement Handle
4280: // Added as per Rave requirements
4281:
4282: /**
4283: * Gets this <code>JdbcRowSet</code> object's PreparedStatement property
4284: *
4285: *
4286: * @return the <code>PreparedStatement</code> object associated with this rowset;
4287: */
4288:
4289: protected PreparedStatement getPreparedStatement() {
4290: return ps;
4291: }
4292:
4293: //Sets the prepared statement handle to the parameter
4294: // Added as per Rave requirements
4295:
4296: /**
4297: * Sets this <code>JdbcRowSet</code> object's preparedtsatement property
4298: * to the given <code>PreparedStatemennt</code> object.
4299: *
4300: * @param preparedStatement the <code>PreparedStatement</code> object
4301: *
4302: */
4303: protected void setPreparedStatement(
4304: PreparedStatement preparedStatement) {
4305: ps = preparedStatement;
4306: }
4307:
4308: // Returns a ResultSet handle
4309: // Added as per Rave requirements
4310:
4311: /**
4312: * Gets this <code>JdbcRowSet</code> object's ResultSet property
4313: *
4314: *
4315: * @return the <code>ResultSet</code> object associated with this rowset;
4316: */
4317:
4318: protected ResultSet getResultSet() throws SQLException {
4319:
4320: checkState();
4321:
4322: return rs;
4323: }
4324:
4325: // Sets the result set handle to the parameter
4326: // Added as per Rave requirements
4327:
4328: /**
4329: * Sets this <code>JdbcRowSet</code> object's resultset property
4330: * to the given <code>ResultSet</code> object.
4331: *
4332: * @param resultSet the <code>ResultSet</code> object
4333: *
4334: */
4335: protected void setResultSet(ResultSet resultSet) {
4336: rs = resultSet;
4337: }
4338:
4339: // Over riding the setCommand from BaseRowSet for
4340: // firing the propertyChangeSupport Event for
4341: // Rave requirements when this property's value
4342: // changes.
4343:
4344: /**
4345: * Sets this <code>JdbcRowSet</code> object's <code>command</code> property to
4346: * the given <code>String</code> object and clears the parameters, if any,
4347: * that were set for the previous command. In addition,
4348: * if the <code>command</code> property has previously been set to a
4349: * non-null value and it is
4350: * different from the <code>String</code> object supplied,
4351: * this method sets this <code>JdbcRowSet</code> object's private fields
4352: * <code>ps</code> and <code>rs</code> to <code>null</code>.
4353: * (The field <code>ps</code> is its <code>PreparedStatement</code> object, and
4354: * the field <code>rs</code> is its <code>ResultSet</code> object.)
4355: * <P>
4356: * The <code>command</code> property may not be needed if the <code>RowSet</code>
4357: * object gets its data from a source that does not support commands,
4358: * such as a spreadsheet or other tabular file.
4359: * Thus, this property is optional and may be <code>null</code>.
4360: *
4361: * @param command a <code>String</code> object containing an SQL query
4362: * that will be set as this <code>RowSet</code> object's command
4363: * property; may be <code>null</code> but may not be an empty string
4364: * @throws SQLException if an empty string is provided as the command value
4365: * @see #getCommand
4366: */
4367: public void setCommand(String command) throws SQLException {
4368: String oldVal;
4369:
4370: if (getCommand() != null) {
4371: if (!getCommand().equals(command)) {
4372: oldVal = getCommand();
4373: super .setCommand(command);
4374: ps = null;
4375: rs = null;
4376: propertyChangeSupport.firePropertyChange("command",
4377: oldVal, command);
4378: }
4379: } else {
4380: super .setCommand(command);
4381: propertyChangeSupport.firePropertyChange("command", null,
4382: command);
4383: }
4384: }
4385:
4386: // Over riding the setDataSourceName from BaseRowSet for
4387: // firing the propertyChangeSupport Event for
4388: // Rave requirements when this property's values
4389: // changes.
4390:
4391: /**
4392: * Sets the <code>dataSourceName</code> property for this <code>JdbcRowSet</code>
4393: * object to the given logical name and sets this <code>JdbcRowSet</code> object's
4394: * Url property to <code>null</code>. In addition, if the <code>dataSourceName</code>
4395: * property has previously been set and is different from the one supplied,
4396: * this method sets this <code>JdbcRowSet</code> object's private fields
4397: * <code>ps</code>, <code>rs</code>, and <code>conn</code> to <code>null</code>.
4398: * (The field <code>ps</code> is its <code>PreparedStatement</code> object,
4399: * the field <code>rs</code> is its <code>ResultSet</code> object, and
4400: * the field <code>conn</code> is its <code>Connection</code> object.)
4401: * <P>
4402: * The name supplied to this method must have been bound to a
4403: * <code>DataSource</code> object in a JNDI naming service so that an
4404: * application can do a lookup using that name to retrieve the
4405: * <code>DataSource</code> object bound to it. The <code>DataSource</code>
4406: * object can then be used to establish a connection to the data source it
4407: * represents.
4408: * <P>
4409: * Users should set either the Url property or the dataSourceName property.
4410: * If both properties are set, the driver will use the property set most recently.
4411: *
4412: * @param dsName a <code>String</code> object with the name that can be supplied
4413: * to a naming service based on JNDI technology to retrieve the
4414: * <code>DataSource</code> object that can be used to get a connection;
4415: * may be <code>null</code>
4416: * @throws SQLException if there is a problem setting the
4417: * <code>dataSourceName</code> property
4418: * @see #getDataSourceName
4419: */
4420: public void setDataSourceName(String dsName) throws SQLException {
4421: String oldVal;
4422:
4423: if (getDataSourceName() != null) {
4424: if (!getDataSourceName().equals(dsName)) {
4425: oldVal = getDataSourceName();
4426: super .setDataSourceName(dsName);
4427: conn = null;
4428: ps = null;
4429: rs = null;
4430: propertyChangeSupport.firePropertyChange(
4431: "dataSourceName", oldVal, dsName);
4432: }
4433: } else {
4434: super .setDataSourceName(dsName);
4435: propertyChangeSupport.firePropertyChange("dataSourceName",
4436: null, dsName);
4437: }
4438: }
4439:
4440: // Over riding the setUrl from BaseRowSet for
4441: // firing the propertyChangeSupport Event for
4442: // Rave requirements when this property's values
4443: // changes.
4444:
4445: /**
4446: * Sets the Url property for this <code>JdbcRowSet</code> object
4447: * to the given <code>String</code> object and sets the dataSource name
4448: * property to <code>null</code>. In addition, if the Url property has
4449: * previously been set to a non <code>null</code> value and its value
4450: * is different from the value to be set,
4451: * this method sets this <code>JdbcRowSet</code> object's private fields
4452: * <code>ps</code>, <code>rs</code>, and <code>conn</code> to <code>null</code>.
4453: * (The field <code>ps</code> is its <code>PreparedStatement</code> object,
4454: * the field <code>rs</code> is its <code>ResultSet</code> object, and
4455: * the field <code>conn</code> is its <code>Connection</code> object.)
4456: * <P>
4457: * The Url property is a JDBC URL that is used when
4458: * the connection is created using a JDBC technology-enabled driver
4459: * ("JDBC driver") and the <code>DriverManager</code>.
4460: * The correct JDBC URL for the specific driver to be used can be found
4461: * in the driver documentation. Although there are guidelines for for how
4462: * a JDBC URL is formed,
4463: * a driver vendor can specify any <code>String</code> object except
4464: * one with a length of <code>0</code> (an empty string).
4465: * <P>
4466: * Setting the Url property is optional if connections are established using
4467: * a <code>DataSource</code> object instead of the <code>DriverManager</code>.
4468: * The driver will use either the URL property or the
4469: * dataSourceName property to create a connection, whichever was
4470: * specified most recently. If an application uses a JDBC URL, it
4471: * must load a JDBC driver that accepts the JDBC URL before it uses the
4472: * <code>RowSet</code> object to connect to a database. The <code>RowSet</code>
4473: * object will use the URL internally to create a database connection in order
4474: * to read or write data.
4475: *
4476: * @param url a <code>String</code> object that contains the JDBC URL
4477: * that will be used to establish the connection to a database for this
4478: * <code>RowSet</code> object; may be <code>null</code> but must not
4479: * be an empty string
4480: * @throws SQLException if an error occurs setting the Url property or the
4481: * parameter supplied is a string with a length of <code>0</code> (an
4482: * empty string)
4483: * @see #getUrl
4484: */
4485:
4486: public void setUrl(String url) throws SQLException {
4487: String oldVal;
4488:
4489: if (getUrl() != null) {
4490: if (!getUrl().equals(url)) {
4491: oldVal = getUrl();
4492: super .setUrl(url);
4493: conn = null;
4494: ps = null;
4495: rs = null;
4496: propertyChangeSupport.firePropertyChange("url", oldVal,
4497: url);
4498: }
4499: } else {
4500: super .setUrl(url);
4501: propertyChangeSupport.firePropertyChange("url", null, url);
4502: }
4503: }
4504:
4505: // Over riding the setUsername from BaseRowSet for
4506: // firing the propertyChangeSupport Event for
4507: // Rave requirements when this property's values
4508: // changes.
4509:
4510: /**
4511: * Sets the username property for this <code>JdbcRowSet</code> object
4512: * to the given user name. Because it
4513: * is not serialized, the username property is set at run time before
4514: * calling the method <code>execute</code>. In addition,
4515: * if the <code>username</code> property is already set with a
4516: * non-null value and that value is different from the <code>String</code>
4517: * object to be set,
4518: * this method sets this <code>JdbcRowSet</code> object's private fields
4519: * <code>ps</code>, <code>rs</code>, and <code>conn</code> to <code>null</code>.
4520: * (The field <code>ps</code> is its <code>PreparedStatement</code> object,
4521: * <code>rs</code> is its <code>ResultSet</code> object, and
4522: * <code>conn</code> is its <code>Connection</code> object.)
4523: * Setting these fields to <code>null</code> ensures that only current
4524: * values will be used.
4525: *
4526: * @param uname the <code>String</code> object containing the user name that
4527: * is supplied to the data source to create a connection. It may be null.
4528: * @see #getUsername
4529: */
4530: public void setUsername(String uname) {
4531: String oldVal;
4532:
4533: if (getUsername() != null) {
4534: if (!getUsername().equals(uname)) {
4535: oldVal = getUsername();
4536: super .setUsername(uname);
4537: conn = null;
4538: ps = null;
4539: rs = null;
4540: propertyChangeSupport.firePropertyChange("username",
4541: oldVal, uname);
4542: }
4543: } else {
4544: super .setUsername(uname);
4545: propertyChangeSupport.firePropertyChange("username", null,
4546: uname);
4547: }
4548: }
4549:
4550: // Over riding the setPassword from BaseRowSet for
4551: // firing the propertyChangeSupport Event for
4552: // Rave requirements when this property's values
4553: // changes.
4554:
4555: /**
4556: * Sets the password property for this <code>JdbcRowSet</code> object
4557: * to the given <code>String</code> object. Because it
4558: * is not serialized, the password property is set at run time before
4559: * calling the method <code>execute</code>. Its default valus is
4560: * <code>null</code>. In addition,
4561: * if the <code>password</code> property is already set with a
4562: * non-null value and that value is different from the one being set,
4563: * this method sets this <code>JdbcRowSet</code> object's private fields
4564: * <code>ps</code>, <code>rs</code>, and <code>conn</code> to <code>null</code>.
4565: * (The field <code>ps</code> is its <code>PreparedStatement</code> object,
4566: * <code>rs</code> is its <code>ResultSet</code> object, and
4567: * <code>conn</code> is its <code>Connection</code> object.)
4568: * Setting these fields to <code>null</code> ensures that only current
4569: * values will be used.
4570: *
4571: * @param password the <code>String</code> object that represents the password
4572: * that must be supplied to the database to create a connection
4573: */
4574: public void setPassword(String password) {
4575: String oldVal;
4576:
4577: if (getPassword() != null) {
4578: if (!getPassword().equals(password)) {
4579: oldVal = getPassword();
4580: super .setPassword(password);
4581: conn = null;
4582: ps = null;
4583: rs = null;
4584: propertyChangeSupport.firePropertyChange("password",
4585: oldVal, password);
4586: }
4587: } else {
4588: super .setPassword(password);
4589: propertyChangeSupport.firePropertyChange("password", null,
4590: password);
4591: }
4592: }
4593:
4594: /**
4595: * Sets the type for this <code>RowSet</code> object to the specified type.
4596: * The default type is <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>.
4597: *
4598: * @param type one of the following constants:
4599: * <code>ResultSet.TYPE_FORWARD_ONLY</code>,
4600: * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
4601: * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
4602: * @throws SQLException if the parameter supplied is not one of the
4603: * following constants:
4604: * <code>ResultSet.TYPE_FORWARD_ONLY</code> or
4605: * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>
4606: * <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
4607: * @see #getConcurrency
4608: * @see #getType
4609: */
4610:
4611: public void setType(int type) throws SQLException {
4612:
4613: int oldVal;
4614:
4615: try {
4616: oldVal = getType();
4617: } catch (SQLException ex) {
4618: oldVal = 0;
4619: }
4620:
4621: if (oldVal != type) {
4622: super .setType(type);
4623: propertyChangeSupport.firePropertyChange("type", oldVal,
4624: type);
4625: }
4626:
4627: }
4628:
4629: /**
4630: * Sets the concurrency for this <code>RowSet</code> object to
4631: * the specified concurrency. The default concurrency for any <code>RowSet</code>
4632: * object (connected or disconnected) is <code>ResultSet.CONCUR_UPDATABLE</code>,
4633: * but this method may be called at any time to change the concurrency.
4634: *
4635: * @param concur one of the following constants:
4636: * <code>ResultSet.CONCUR_READ_ONLY</code> or
4637: * <code>ResultSet.CONCUR_UPDATABLE</code>
4638: * @throws SQLException if the parameter supplied is not one of the
4639: * following constants:
4640: * <code>ResultSet.CONCUR_UPDATABLE</code> or
4641: * <code>ResultSet.CONCUR_READ_ONLY</code>
4642: * @see #getConcurrency
4643: * @see #isReadOnly
4644: */
4645: public void setConcurrency(int concur) throws SQLException {
4646:
4647: int oldVal;
4648:
4649: try {
4650: oldVal = getConcurrency();
4651: } catch (NullPointerException ex) {
4652: oldVal = 0;
4653: }
4654:
4655: if (oldVal != concur) {
4656: super .setConcurrency(concur);
4657: propertyChangeSupport.firePropertyChange("concurrency",
4658: oldVal, concur);
4659: }
4660:
4661: }
4662:
4663: /**
4664: * Sets the transaction isolation property for this JDBC <code>RowSet</code> object to the given
4665: * constant. The DBMS will use this transaction isolation level for
4666: * transactions if it can.
4667: * <p>
4668: * For <code>RowSet</code> implementations such as
4669: * the <code>CachedRowSet</code> that operate in a disconnected environment,
4670: * the <code>SyncProvider</code> object being used
4671: * offers complementary locking and data integrity options. The
4672: * options described below are pertinent only to connected <code>RowSet</code>
4673: * objects (<code>JdbcRowSet</code> objects).
4674: *
4675: * @param transIso one of the following constants, listed in ascending order:
4676: * <code>Connection.TRANSACTION_NONE</code>,
4677: * <code>Connection.TRANSACTION_READ_UNCOMMITTED</code>,
4678: * <code>Connection.TRANSACTION_READ_COMMITTED</code>,
4679: * <code>Connection.TRANSACTION_REPEATABLE_READ</code>, or
4680: * <code>Connection.TRANSACTION_SERIALIZABLE</code>
4681: * @throws SQLException if the given parameter is not one of the Connection
4682: * constants
4683: * @see javax.sql.rowset.spi.SyncFactory
4684: * @see javax.sql.rowset.spi.SyncProvider
4685: * @see #getTransactionIsolation
4686: */
4687: public void setTransactionIsolation(int transIso)
4688: throws SQLException {
4689:
4690: int oldVal;
4691:
4692: try {
4693: oldVal = getTransactionIsolation();
4694: } catch (NullPointerException ex) {
4695: oldVal = 0;
4696: }
4697:
4698: if (oldVal != transIso) {
4699: super .setTransactionIsolation(transIso);
4700: propertyChangeSupport.firePropertyChange(
4701: "transactionIsolation", oldVal, transIso);
4702: }
4703:
4704: }
4705:
4706: /**
4707: * Sets the maximum number of rows that this <code>RowSet</code> object may contain to
4708: * the given number. If this limit is exceeded, the excess rows are
4709: * silently dropped.
4710: *
4711: * @param mRows an <code>int</code> indicating the current maximum number
4712: * of rows; zero means that there is no limit
4713: * @throws SQLException if an error occurs internally setting the
4714: * maximum limit on the number of rows that a JDBC <code>RowSet</code> object
4715: * can contain; or if <i>max</i> is less than <code>0</code>; or
4716: * if <i>max</i> is less than the <code>fetchSize</code> of the
4717: * <code>RowSet</code>
4718: */
4719: public void setMaxRows(int mRows) throws SQLException {
4720:
4721: int oldVal;
4722:
4723: try {
4724: oldVal = getMaxRows();
4725: } catch (NullPointerException ex) {
4726: oldVal = 0;
4727: }
4728:
4729: if (oldVal != mRows) {
4730: super .setMaxRows(mRows);
4731: propertyChangeSupport.firePropertyChange("maxRows", oldVal,
4732: mRows);
4733: }
4734:
4735: }
4736:
4737: /**
4738: * Retrieves the value of the designated <code>SQL XML</code> parameter as a
4739: * <code>SQLXML</code> object in the Java programming language.
4740: * @param columnIndex the first column is 1, the second is 2, ...
4741: * @return a SQLXML object that maps an SQL XML value
4742: * @throws SQLException if a database access error occurs
4743: * @since 6.0
4744: */
4745: public SQLXML getSQLXML(int columnIndex) throws SQLException {
4746: throw new SQLFeatureNotSupportedException(jdbcResBundle
4747: .handleGetObject("jdbcrowsetimpl.featnotsupp")
4748: .toString());
4749: }
4750:
4751: /**
4752: * Retrieves the value of the designated <code>SQL XML</code> parameter as a
4753: * <code>SQLXML</code> object in the Java programming language.
4754: * @param colName the name of the column from which to retrieve the value
4755: * @return a SQLXML object that maps an SQL XML value
4756: * @throws SQLException if a database access error occurs
4757: */
4758: public SQLXML getSQLXML(String colName) throws SQLException {
4759: throw new SQLFeatureNotSupportedException(jdbcResBundle
4760: .handleGetObject("jdbcrowsetimpl.featnotsupp")
4761: .toString());
4762: }
4763:
4764: /**
4765: * Retrieves the value of the designated column in the current row of this
4766: * <code>ResultSet</code> object as a java.sql.RowId object in the Java
4767: * programming language.
4768: *
4769: * @param columnIndex the first column is 1, the second 2, ...
4770: * @return the column value if the value is a SQL <code>NULL</code> the
4771: * value returned is <code>null</code>
4772: * @throws SQLException if a database access error occurs
4773: * @since 6.0
4774: */
4775: public RowId getRowId(int columnIndex) throws SQLException {
4776: throw new SQLFeatureNotSupportedException(jdbcResBundle
4777: .handleGetObject("jdbcrowsetimpl.featnotsupp")
4778: .toString());
4779: }
4780:
4781: /**
4782: * Retrieves the value of the designated column in the current row of this
4783: * <code>ResultSet</code> object as a java.sql.RowId object in the Java
4784: * programming language.
4785: *
4786: * @param columnName the name of the column
4787: * @return the column value if the value is a SQL <code>NULL</code> the
4788: * value returned is <code>null</code>
4789: * @throws SQLException if a database access error occurs
4790: * @since 6.0
4791: */
4792: public RowId getRowId(String columnName) throws SQLException {
4793: throw new SQLFeatureNotSupportedException(jdbcResBundle
4794: .handleGetObject("jdbcrowsetimpl.featnotsupp")
4795: .toString());
4796: }
4797:
4798: /**
4799: * Updates the designated column with a <code>RowId</code> value. The updater
4800: * methods are used to update column values in the current row or the insert
4801: * row. The updater methods do not update the underlying database; instead
4802: * the <code>updateRow<code> or <code>insertRow</code> methods are called
4803: * to update the database.
4804: *
4805: * @param columnIndex the first column is 1, the second 2, ...
4806: * @param x the column value
4807: * @throws SQLException if a database access occurs
4808: * @since 6.0
4809: */
4810: public void updateRowId(int columnIndex, RowId x)
4811: throws SQLException {
4812: throw new SQLFeatureNotSupportedException(jdbcResBundle
4813: .handleGetObject("jdbcrowsetimpl.featnotsupp")
4814: .toString());
4815: }
4816:
4817: /**
4818: * Updates the designated column with a <code>RowId</code> value. The updater
4819: * methods are used to update column values in the current row or the insert
4820: * row. The updater methods do not update the underlying database; instead
4821: * the <code>updateRow<code> or <code>insertRow</code> methods are called
4822: * to update the database.
4823: *
4824: * @param columnName the name of the column
4825: * @param x the column value
4826: * @throws SQLException if a database access occurs
4827: * @since 6.0
4828: */
4829: public void updateRowId(String columnName, RowId x)
4830: throws SQLException {
4831: throw new SQLFeatureNotSupportedException(jdbcResBundle
4832: .handleGetObject("jdbcrowsetimpl.featnotsupp")
4833: .toString());
4834: }
4835:
4836: /**
4837: * Retrieves the holdability of this ResultSet object
4838: * @return either ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
4839: * @throws SQLException if a database error occurs
4840: * @since 6.0
4841: */
4842: public int getHoldability() throws SQLException {
4843: throw new SQLFeatureNotSupportedException(jdbcResBundle
4844: .handleGetObject("jdbcrowsetimpl.featnotsupp")
4845: .toString());
4846: }
4847:
4848: /**
4849: * Retrieves whether this ResultSet object has been closed. A ResultSet is closed if the
4850: * method close has been called on it, or if it is automatically closed.
4851: * @return true if this ResultSet object is closed; false if it is still open
4852: * @throws SQLException if a database access error occurs
4853: * @since 6.0
4854: */
4855: public boolean isClosed() throws SQLException {
4856: throw new SQLFeatureNotSupportedException(jdbcResBundle
4857: .handleGetObject("jdbcrowsetimpl.featnotsupp")
4858: .toString());
4859: }
4860:
4861: /**
4862: * This method is used for updating columns that support National Character sets.
4863: * It can be used for updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
4864: * @param columnIndex the first column is 1, the second 2, ...
4865: * @param nString the value for the column to be updated
4866: * @throws SQLException if a database access error occurs
4867: * @since 6.0
4868: */
4869: public void updateNString(int columnIndex, String nString)
4870: throws SQLException {
4871: throw new SQLFeatureNotSupportedException(jdbcResBundle
4872: .handleGetObject("jdbcrowsetimpl.featnotsupp")
4873: .toString());
4874: }
4875:
4876: /**
4877: * This method is used for updating columns that support National Character sets.
4878: * It can be used for updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
4879: * @param columnName name of the Column
4880: * @param nString the value for the column to be updated
4881: * @throws SQLException if a database access error occurs
4882: * @since 6.0
4883: */
4884: public void updateNString(String columnName, String nString)
4885: throws SQLException {
4886: throw new SQLFeatureNotSupportedException(jdbcResBundle
4887: .handleGetObject("jdbcrowsetimpl.featnotsupp")
4888: .toString());
4889: }
4890:
4891: /*o
4892: * This method is used for updating SQL <code>NCLOB</code> type that maps
4893: * to <code>java.sql.Types.NCLOB</code>
4894: * @param columnIndex the first column is 1, the second 2, ...
4895: * @param nClob the value for the column to be updated
4896: * @throws SQLException if a database access error occurs
4897: * @since 6.0
4898: */
4899: public void updateNClob(int columnIndex, NClob nClob)
4900: throws SQLException {
4901: throw new SQLFeatureNotSupportedException(jdbcResBundle
4902: .handleGetObject("jdbcrowsetimpl.featnotsupp")
4903: .toString());
4904: }
4905:
4906: /**
4907: * This method is used for updating SQL <code>NCLOB</code> type that maps
4908: * to <code>java.sql.Types.NCLOB</code>
4909: * @param columnName name of the column
4910: * @param nClob the value for the column to be updated
4911: * @throws SQLException if a database access error occurs
4912: * @since 6.0
4913: */
4914: public void updateNClob(String columnName, NClob nClob)
4915: throws SQLException {
4916: throw new SQLFeatureNotSupportedException(jdbcResBundle
4917: .handleGetObject("jdbcrowsetimpl.featnotsupp")
4918: .toString());
4919: }
4920:
4921: /**
4922: * Retrieves the value of the designated column in the current row
4923: * of this <code>ResultSet</code> object as a <code>NClob</code> object
4924: * in the Java programming language.
4925: *
4926: * @param i the first column is 1, the second is 2, ...
4927: * @return a <code>NClob</code> object representing the SQL
4928: * <code>NCLOB</code> value in the specified column
4929: * @exception SQLException if a database access error occurs
4930: * @since 6.0
4931: */
4932: public NClob getNClob(int i) throws SQLException {
4933: throw new SQLFeatureNotSupportedException(jdbcResBundle
4934: .handleGetObject("jdbcrowsetimpl.featnotsupp")
4935: .toString());
4936: }
4937:
4938: /**
4939: * Retrieves the value of the designated column in the current row
4940: * of this <code>ResultSet</code> object as a <code>NClob</code> object
4941: * in the Java programming language.
4942: *
4943: * @param colName the name of the column from which to retrieve the value
4944: * @return a <code>NClob</code> object representing the SQL <code>NCLOB</code>
4945: * value in the specified column
4946: * @exception SQLException if a database access error occurs
4947: * @since 6.0
4948: */
4949: public NClob getNClob(String colName) throws SQLException {
4950: throw new SQLFeatureNotSupportedException(jdbcResBundle
4951: .handleGetObject("jdbcrowsetimpl.featnotsupp")
4952: .toString());
4953: }
4954:
4955: public <T> T unwrap(java.lang.Class<T> iface)
4956: throws java.sql.SQLException {
4957: return null;
4958: }
4959:
4960: public boolean isWrapperFor(Class<?> interfaces)
4961: throws SQLException {
4962: return false;
4963: }
4964:
4965: /**
4966: * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
4967: * SQL <code>XML</code> value when it sends it to the database.
4968: * @param parameterIndex index of the first parameter is 1, the second is 2, ...
4969: * @param xmlObject a <code>SQLXML</code> object that maps an SQL <code>XML</code> value
4970: * @throws SQLException if a database access error occurs
4971: * @since 1.6
4972: */
4973: public void setSQLXML(int parameterIndex, SQLXML xmlObject)
4974: throws SQLException {
4975: throw new SQLFeatureNotSupportedException(jdbcResBundle
4976: .handleGetObject("jdbcrowsetimpl.featnotsupp")
4977: .toString());
4978: }
4979:
4980: /**
4981: * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
4982: * <code>SQL XML</code> value when it sends it to the database.
4983: * @param parameterName the name of the parameter
4984: * @param xmlObject a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
4985: * @throws SQLException if a database access error occurs
4986: * @since 1.6
4987: */
4988: public void setSQLXML(String parameterName, SQLXML xmlObject)
4989: throws SQLException {
4990: throw new SQLFeatureNotSupportedException(jdbcResBundle
4991: .handleGetObject("jdbcrowsetimpl.featnotsupp")
4992: .toString());
4993: }
4994:
4995: /**
4996: * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
4997: * driver converts this to a SQL <code>ROWID</code> value when it sends it
4998: * to the database
4999: *
5000: * @param parameterIndex the first parameter is 1, the second is 2, ...
5001: * @param x the parameter value
5002: * @throws SQLException if a database access error occurs
5003: *
5004: * @since 1.6
5005: */
5006: public void setRowId(int parameterIndex, RowId x)
5007: throws SQLException {
5008: throw new SQLFeatureNotSupportedException(jdbcResBundle
5009: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5010: .toString());
5011: }
5012:
5013: /**
5014: * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
5015: * driver converts this to a SQL <code>ROWID</code> when it sends it to the
5016: * database.
5017: *
5018: * @param parameterName the name of the parameter
5019: * @param x the parameter value
5020: * @throws SQLException if a database access error occurs
5021: * @since 1.6
5022: */
5023: public void setRowId(String parameterName, RowId x)
5024: throws SQLException {
5025: throw new SQLFeatureNotSupportedException(jdbcResBundle
5026: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5027: .toString());
5028: }
5029:
5030: /**
5031: * Sets the designated paramter to the given <code>String</code> object.
5032: * The driver converts this to a SQL <code>NCHAR</code> or
5033: * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
5034: * (depending on the argument's
5035: * size relative to the driver's limits on <code>NVARCHAR</code> values)
5036: * when it sends it to the database.
5037: *
5038: * @param parameterIndex of the first parameter is 1, the second is 2, ...
5039: * @param value the parameter value
5040: * @throws SQLException if the driver does not support national
5041: * character sets; if the driver can detect that a data conversion
5042: * error could occur ; or if a database access error occurs
5043: * @since 1.6
5044: */
5045: public void setNString(int parameterIndex, String value)
5046: throws SQLException {
5047: throw new SQLFeatureNotSupportedException(jdbcResBundle
5048: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5049: .toString());
5050: }
5051:
5052: /**
5053: * Sets the designated parameter in this <code>RowSet</code> object's command
5054: * to a <code>Reader</code> object. The
5055: * <code>Reader</code> reads the data till end-of-file is reached. The
5056: * driver does the necessary conversion from Java character format to
5057: * the national character set in the database.
5058:
5059: * <P><B>Note:</B> This stream object can either be a standard
5060: * Java stream object or your own subclass that implements the
5061: * standard interface.
5062: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
5063: * it might be more efficient to use a version of
5064: * <code>setNCharacterStream</code> which takes a length parameter.
5065: *
5066: * @param parameterIndex of the first parameter is 1, the second is 2, ...
5067: * @param value the parameter value
5068: * @throws SQLException if the driver does not support national
5069: * character sets; if the driver can detect that a data conversion
5070: * error could occur ; if a database access error occurs; or
5071: * this method is called on a closed <code>PreparedStatement</code>
5072: * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
5073: * @since 1.6
5074: */
5075: public void setNCharacterStream(int parameterIndex, Reader value)
5076: throws SQLException {
5077: throw new SQLFeatureNotSupportedException(jdbcResBundle
5078: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5079: .toString());
5080: }
5081:
5082: /**
5083: * Sets the designated parameter to a <code>java.sql.NClob</code> object. The object
5084: * implements the <code>java.sql.NClob</code> interface. This <code>NClob</code>
5085: * object maps to a SQL <code>NCLOB</code>.
5086: * @param parameterName the name of the column to be set
5087: * @param value the parameter value
5088: * @throws SQLException if the driver does not support national
5089: * character sets; if the driver can detect that a data conversion
5090: * error could occur; or if a database access error occurs
5091: * @since 1.6
5092: */
5093: public void setNClob(String parameterName, NClob value)
5094: throws SQLException {
5095: throw new SQLFeatureNotSupportedException(jdbcResBundle
5096: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5097: .toString());
5098: }
5099:
5100: /**
5101: * Retrieves the value of the designated column in the current row
5102: * of this <code>ResultSet</code> object as a
5103: * <code>java.io.Reader</code> object.
5104: * It is intended for use when
5105: * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
5106: * and <code>LONGNVARCHAR</code> columns.
5107: *
5108: * @return a <code>java.io.Reader</code> object that contains the column
5109: * value; if the value is SQL <code>NULL</code>, the value returned is
5110: * <code>null</code> in the Java programming language.
5111: * @param columnIndex the first column is 1, the second is 2, ...
5112: * @exception SQLException if a database access error occurs
5113: * @since 1.6
5114: */
5115: public java.io.Reader getNCharacterStream(int columnIndex)
5116: throws SQLException {
5117: throw new SQLFeatureNotSupportedException(jdbcResBundle
5118: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5119: .toString());
5120: }
5121:
5122: /**
5123: * Retrieves the value of the designated column in the current row
5124: * of this <code>ResultSet</code> object as a
5125: * <code>java.io.Reader</code> object.
5126: * It is intended for use when
5127: * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
5128: * and <code>LONGNVARCHAR</code> columns.
5129: *
5130: * @param columnName the name of the column
5131: * @return a <code>java.io.Reader</code> object that contains the column
5132: * value; if the value is SQL <code>NULL</code>, the value returned is
5133: * <code>null</code> in the Java programming language
5134: * @exception SQLException if a database access error occurs
5135: * @since 1.6
5136: */
5137: public java.io.Reader getNCharacterStream(String columnName)
5138: throws SQLException {
5139: throw new SQLFeatureNotSupportedException(jdbcResBundle
5140: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5141: .toString());
5142: }
5143:
5144: /**
5145: * Updates the designated column with a <code>java.sql.SQLXML</code> value.
5146: * The updater
5147: * methods are used to update column values in the current row or the insert
5148: * row. The updater methods do not update the underlying database; instead
5149: * the <code>updateRow</code> or <code>insertRow</code> methods are called
5150: * to update the database.
5151: * @param columnIndex the first column is 1, the second 2, ...
5152: * @param xmlObject the value for the column to be updated
5153: * @throws SQLException if a database access error occurs
5154: * @since 1.6
5155: */
5156: public void updateSQLXML(int columnIndex, SQLXML xmlObject)
5157: throws SQLException {
5158: throw new SQLFeatureNotSupportedException(jdbcResBundle
5159: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5160: .toString());
5161: }
5162:
5163: /**
5164: * Updates the designated column with a <code>java.sql.SQLXML</code> value.
5165: * The updater
5166: * methods are used to update column values in the current row or the insert
5167: * row. The updater methods do not update the underlying database; instead
5168: * the <code>updateRow</code> or <code>insertRow</code> methods are called
5169: * to update the database.
5170: *
5171: * @param columnName the name of the column
5172: * @param xmlObject the column value
5173: * @throws SQLException if a database access occurs
5174: * @since 1.6
5175: */
5176: public void updateSQLXML(String columnName, SQLXML xmlObject)
5177: throws SQLException {
5178: throw new SQLFeatureNotSupportedException(jdbcResBundle
5179: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5180: .toString());
5181: }
5182:
5183: /**
5184: * Retrieves the value of the designated column in the current row
5185: * of this <code>ResultSet</code> object as
5186: * a <code>String</code> in the Java programming language.
5187: * It is intended for use when
5188: * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
5189: * and <code>LONGNVARCHAR</code> columns.
5190: *
5191: * @param columnIndex the first column is 1, the second is 2, ...
5192: * @return the column value; if the value is SQL <code>NULL</code>, the
5193: * value returned is <code>null</code>
5194: * @exception SQLException if a database access error occurs
5195: * @since 1.6
5196: */
5197: public String getNString(int columnIndex) throws SQLException {
5198: throw new SQLFeatureNotSupportedException(jdbcResBundle
5199: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5200: .toString());
5201: }
5202:
5203: /**
5204: * Retrieves the value of the designated column in the current row
5205: * of this <code>ResultSet</code> object as
5206: * a <code>String</code> in the Java programming language.
5207: * It is intended for use when
5208: * accessing <code>NCHAR</code>,<code>NVARCHAR</code>
5209: * and <code>LONGNVARCHAR</code> columns.
5210: *
5211: * @param columnName the SQL name of the column
5212: * @return the column value; if the value is SQL <code>NULL</code>, the
5213: * value returned is <code>null</code>
5214: * @exception SQLException if a database access error occurs
5215: * @since 1.6
5216: */
5217: public String getNString(String columnName) throws SQLException {
5218: throw new SQLFeatureNotSupportedException(jdbcResBundle
5219: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5220: .toString());
5221: }
5222:
5223: /**
5224: * Updates the designated column with a character stream value, which will
5225: * have the specified number of bytes. The driver does the necessary conversion
5226: * from Java character format to the national character set in the database.
5227: * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
5228: * The updater methods are used to update column values in the current row or
5229: * the insert row. The updater methods do not update the underlying database;
5230: * instead the updateRow or insertRow methods are called to update the database.
5231: *
5232: * @param columnIndex - the first column is 1, the second is 2, ...
5233: * @param x - the new column value
5234: * @param length - the length of the stream
5235: * @exception SQLException if a database access error occurs
5236: * @since 1.6
5237: */
5238: public void updateNCharacterStream(int columnIndex,
5239: java.io.Reader x, long length) throws SQLException {
5240: throw new SQLFeatureNotSupportedException(jdbcResBundle
5241: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5242: .toString());
5243: }
5244:
5245: /**
5246: * Updates the designated column with a character stream value, which will
5247: * have the specified number of bytes. The driver does the necessary conversion
5248: * from Java character format to the national character set in the database.
5249: * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
5250: * The updater methods are used to update column values in the current row or
5251: * the insert row. The updater methods do not update the underlying database;
5252: * instead the updateRow or insertRow methods are called to update the database.
5253: *
5254: * @param columnName - name of the Column
5255: * @param x - the new column value
5256: * @param length - the length of the stream
5257: * @exception SQLException if a database access error occurs
5258: * @since 1.6
5259: */
5260: public void updateNCharacterStream(String columnName,
5261: java.io.Reader x, long length) throws SQLException {
5262: throw new SQLFeatureNotSupportedException(jdbcResBundle
5263: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5264: .toString());
5265: }
5266:
5267: /**
5268: * Updates the designated column with a character stream value. The
5269: * driver does the necessary conversion from Java character format to
5270: * the national character set in the database.
5271: * It is intended for use when
5272: * updating <code>NCHAR</code>,<code>NVARCHAR</code>
5273: * and <code>LONGNVARCHAR</code> columns.
5274: *
5275: * The updater methods are used to update column values in the
5276: * current row or the insert row. The updater methods do not
5277: * update the underlying database; instead the <code>updateRow</code> or
5278: * <code>insertRow</code> methods are called to update the database.
5279: *
5280: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
5281: * it might be more efficient to use a version of
5282: * <code>updateNCharacterStream</code> which takes a length parameter.
5283: *
5284: * @param columnIndex the first column is 1, the second is 2, ...
5285: * @param x the new column value
5286: * @exception SQLException if a database access error occurs,
5287: * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
5288: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5289: * this method
5290: * @since 1.6
5291: */
5292: public void updateNCharacterStream(int columnIndex, java.io.Reader x)
5293: throws SQLException {
5294: throw new SQLFeatureNotSupportedException(jdbcResBundle
5295: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5296: .toString());
5297: }
5298:
5299: /**
5300: * Updates the designated column with a character stream value. The
5301: * driver does the necessary conversion from Java character format to
5302: * the national character set in the database.
5303: * It is intended for use when
5304: * updating <code>NCHAR</code>,<code>NVARCHAR</code>
5305: * and <code>LONGNVARCHAR</code> columns.
5306: *
5307: * The updater methods are used to update column values in the
5308: * current row or the insert row. The updater methods do not
5309: * update the underlying database; instead the <code>updateRow</code> or
5310: * <code>insertRow</code> methods are called to update the database.
5311: *
5312: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
5313: * it might be more efficient to use a version of
5314: * <code>updateNCharacterStream</code> which takes a length parameter.
5315: *
5316: * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la
5317: bel is the name of the column
5318: * @param reader the <code>java.io.Reader</code> object containing
5319: * the new column value
5320: * @exception SQLException if a database access error occurs,
5321: * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
5322: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5323: * this method
5324: * @since 1.6
5325: */
5326: public void updateNCharacterStream(String columnLabel,
5327: java.io.Reader reader) throws SQLException {
5328: throw new SQLFeatureNotSupportedException(jdbcResBundle
5329: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5330: .toString());
5331: }
5332:
5333: /**
5334: * Updates the designated column using the given input stream, which
5335: * will have the specified number of bytes.
5336: * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
5337: * parameter, it may be more practical to send it via a
5338: * <code>java.io.InputStream</code>. Data will be read from the stream
5339: * as needed until end-of-file is reached. The JDBC driver will
5340: * do any necessary conversion from ASCII to the database char format.
5341: *
5342: * <P><B>Note:</B> This stream object can either be a standard
5343: * Java stream object or your own subclass that implements the
5344: * standard interface.
5345: * <p>
5346: * The updater methods are used to update column values in the
5347: * current row or the insert row. The updater methods do not
5348: * update the underlying database; instead the <code>updateRow</code> or
5349: * <code>insertRow</code> methods are called to update the database.
5350: *
5351: * @param columnIndex the first column is 1, the second is 2, ...
5352: * @param inputStream An object that contains the data to set the parameter
5353: * value to.
5354: * @param length the number of bytes in the parameter data.
5355: * @exception SQLException if a database access error occurs,
5356: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5357: * or this method is called on a closed result set
5358: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5359: * this method
5360: * @since 1.6
5361: */
5362: public void updateBlob(int columnIndex, InputStream inputStream,
5363: long length) throws SQLException {
5364: throw new SQLFeatureNotSupportedException(jdbcResBundle
5365: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5366: .toString());
5367: }
5368:
5369: /**
5370: * Updates the designated column using the given input stream, which
5371: * will have the specified number of bytes.
5372: * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
5373: * parameter, it may be more practical to send it via a
5374: * <code>java.io.InputStream</code>. Data will be read from the stream
5375: * as needed until end-of-file is reached. The JDBC driver will
5376: * do any necessary conversion from ASCII to the database char format.
5377: *
5378: * <P><B>Note:</B> This stream object can either be a standard
5379: * Java stream object or your own subclass that implements the
5380: * standard interface.
5381: * <p>
5382: * The updater methods are used to update column values in the
5383: * current row or the insert row. The updater methods do not
5384: * update the underlying database; instead the <code>updateRow</code> or
5385: * <code>insertRow</code> methods are called to update the database.
5386: *
5387: * @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
5388: * @param inputStream An object that contains the data to set the parameter
5389: * value to.
5390: * @param length the number of bytes in the parameter data.
5391: * @exception SQLException if a database access error occurs,
5392: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5393: * or this method is called on a closed result set
5394: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5395: * this method
5396: * @since 1.6
5397: */
5398: public void updateBlob(String columnLabel, InputStream inputStream,
5399: long length) throws SQLException {
5400: throw new SQLFeatureNotSupportedException(jdbcResBundle
5401: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5402: .toString());
5403: }
5404:
5405: /**
5406: * Updates the designated column using the given input stream.
5407: * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
5408: * parameter, it may be more practical to send it via a
5409: * <code>java.io.InputStream</code>. Data will be read from the stream
5410: * as needed until end-of-file is reached. The JDBC driver will
5411: * do any necessary conversion from ASCII to the database char format.
5412: *
5413: * <P><B>Note:</B> This stream object can either be a standard
5414: * Java stream object or your own subclass that implements the
5415: * standard interface.
5416: *
5417: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
5418: * it might be more efficient to use a version of
5419: * <code>updateBlob</code> which takes a length parameter.
5420: * <p>
5421: * The updater methods are used to update column values in the
5422: * current row or the insert row. The updater methods do not
5423: * update the underlying database; instead the <code>updateRow</code> or
5424: * <code>insertRow</code> methods are called to update the database.
5425: *
5426: * @param columnIndex the first column is 1, the second is 2, ...
5427: * @param inputStream An object that contains the data to set the parameter
5428: * value to.
5429: * @exception SQLException if a database access error occurs,
5430: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5431: * or this method is called on a closed result set
5432: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5433: * this method
5434: * @since 1.6
5435: */
5436: public void updateBlob(int columnIndex, InputStream inputStream)
5437: throws SQLException {
5438: throw new SQLFeatureNotSupportedException(jdbcResBundle
5439: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5440: .toString());
5441: }
5442:
5443: /**
5444: * Updates the designated column using the given input stream.
5445: * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
5446: * parameter, it may be more practical to send it via a
5447: * <code>java.io.InputStream</code>. Data will be read from the stream
5448: * as needed until end-of-file is reached. The JDBC driver will
5449: * do any necessary conversion from ASCII to the database char format.
5450: *
5451: * <P><B>Note:</B> This stream object can either be a standard
5452: * Java stream object or your own subclass that implements the
5453: * standard interface.
5454: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
5455: * it might be more efficient to use a version of
5456: * <code>updateBlob</code> which takes a length parameter.
5457: * <p>
5458: * The updater methods are used to update column values in the
5459: * current row or the insert row. The updater methods do not
5460: * update the underlying database; instead the <code>updateRow</code> or
5461: * <code>insertRow</code> methods are called to update the database.
5462: *
5463: * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la
5464: bel is the name of the column
5465: * @param inputStream An object that contains the data to set the parameter
5466: * value to.
5467: * @exception SQLException if a database access error occurs,
5468: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5469: * or this method is called on a closed result set
5470: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5471: * this method
5472: * @since 1.6
5473: */
5474: public void updateBlob(String columnLabel, InputStream inputStream)
5475: throws SQLException {
5476: throw new SQLFeatureNotSupportedException(jdbcResBundle
5477: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5478: .toString());
5479: }
5480:
5481: /**
5482: * Updates the designated column using the given <code>Reader</code>
5483: * object, which is the given number of characters long.
5484: * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
5485: * parameter, it may be more practical to send it via a
5486: * <code>java.io.Reader</code> object. The data will be read from the stream
5487: * as needed until end-of-file is reached. The JDBC driver will
5488: * do any necessary conversion from UNICODE to the database char format.
5489: *
5490: * <P><B>Note:</B> This stream object can either be a standard
5491: * Java stream object or your own subclass that implements the
5492: * standard interface.
5493: * <p>
5494: * The updater methods are used to update column values in the
5495: * current row or the insert row. The updater methods do not
5496: * update the underlying database; instead the <code>updateRow</code> or
5497: * <code>insertRow</code> methods are called to update the database.
5498: *
5499: * @param columnIndex the first column is 1, the second is 2, ...
5500: * @param reader An object that contains the data to set the parameter value to.
5501: * @param length the number of characters in the parameter data.
5502: * @exception SQLException if a database access error occurs,
5503: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5504: * or this method is called on a closed result set
5505: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5506: * this method
5507: * @since 1.6
5508: */
5509: public void updateClob(int columnIndex, Reader reader, long length)
5510: throws SQLException {
5511: throw new SQLFeatureNotSupportedException(jdbcResBundle
5512: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5513: .toString());
5514: }
5515:
5516: /**
5517: * Updates the designated column using the given <code>Reader</code>
5518: * object, which is the given number of characters long.
5519: * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
5520: * parameter, it may be more practical to send it via a
5521: * <code>java.io.Reader</code> object. The data will be read from the stream
5522: * as needed until end-of-file is reached. The JDBC driver will
5523: * do any necessary conversion from UNICODE to the database char format.
5524: *
5525: * <P><B>Note:</B> This stream object can either be a standard
5526: * Java stream object or your own subclass that implements the
5527: * standard interface.
5528: * <p>
5529: * The updater methods are used to update column values in the
5530: * current row or the insert row. The updater methods do not
5531: * update the underlying database; instead the <code>updateRow</code> or
5532: * <code>insertRow</code> methods are called to update the database.
5533: *
5534: * @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
5535: * @param reader An object that contains the data to set the parameter value to.
5536: * @param length the number of characters in the parameter data.
5537: * @exception SQLException if a database access error occurs,
5538: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5539: * or this method is called on a closed result set
5540: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5541: * this method
5542: * @since 1.6
5543: */
5544: public void updateClob(String columnLabel, Reader reader,
5545: long length) throws SQLException {
5546: throw new SQLFeatureNotSupportedException(jdbcResBundle
5547: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5548: .toString());
5549: }
5550:
5551: /**
5552: * Updates the designated column using the given <code>Reader</code>
5553: * object.
5554: * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
5555: * parameter, it may be more practical to send it via a
5556: * <code>java.io.Reader</code> object. The data will be read from the stream
5557: * as needed until end-of-file is reached. The JDBC driver will
5558: * do any necessary conversion from UNICODE to the database char format.
5559: *
5560: * <P><B>Note:</B> This stream object can either be a standard
5561: * Java stream object or your own subclass that implements the
5562: * standard interface.
5563: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
5564: * it might be more efficient to use a version of
5565: * <code>updateClob</code> which takes a length parameter.
5566: * <p>
5567: * The updater methods are used to update column values in the
5568: * current row or the insert row. The updater methods do not
5569: * update the underlying database; instead the <code>updateRow</code> or
5570: * <code>insertRow</code> methods are called to update the database.
5571: *
5572: * @param columnIndex the first column is 1, the second is 2, ...
5573: * @param reader An object that contains the data to set the parameter value to.
5574: * @exception SQLException if a database access error occurs,
5575: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5576: * or this method is called on a closed result set
5577: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5578: * this method
5579: * @since 1.6
5580: */
5581: public void updateClob(int columnIndex, Reader reader)
5582: throws SQLException {
5583: throw new SQLFeatureNotSupportedException(jdbcResBundle
5584: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5585: .toString());
5586: }
5587:
5588: /**
5589: * Updates the designated column using the given <code>Reader</code>
5590: * object.
5591: * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
5592: * parameter, it may be more practical to send it via a
5593: * <code>java.io.Reader</code> object. The data will be read from the stream
5594: * as needed until end-of-file is reached. The JDBC driver will
5595: * do any necessary conversion from UNICODE to the database char format.
5596: *
5597: * <P><B>Note:</B> This stream object can either be a standard
5598: * Java stream object or your own subclass that implements the
5599: * standard interface.
5600: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
5601: * it might be more efficient to use a version of
5602: * <code>updateClob</code> which takes a length parameter.
5603: * <p>
5604: * The updater methods are used to update column values in the
5605: * current row or the insert row. The updater methods do not
5606: * update the underlying database; instead the <code>updateRow</code> or
5607: * <code>insertRow</code> methods are called to update the database.
5608: *
5609: * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la
5610: bel is the name of the column
5611: * @param reader An object that contains the data to set the parameter value to.
5612: * @exception SQLException if a database access error occurs,
5613: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5614: * or this method is called on a closed result set
5615: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5616: * this method
5617: * @since 1.6
5618: */
5619: public void updateClob(String columnLabel, Reader reader)
5620: throws SQLException {
5621: throw new SQLFeatureNotSupportedException(jdbcResBundle
5622: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5623: .toString());
5624: }
5625:
5626: /**
5627: * Updates the designated column using the given <code>Reader</code>
5628: * object, which is the given number of characters long.
5629: * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
5630: * parameter, it may be more practical to send it via a
5631: * <code>java.io.Reader</code> object. The data will be read from the stream
5632: * as needed until end-of-file is reached. The JDBC driver will
5633: * do any necessary conversion from UNICODE to the database char format.
5634: *
5635: * <P><B>Note:</B> This stream object can either be a standard
5636: * Java stream object or your own subclass that implements the
5637: * standard interface.
5638: * <p>
5639: * The updater methods are used to update column values in the
5640: * current row or the insert row. The updater methods do not
5641: * update the underlying database; instead the <code>updateRow</code> or
5642: * <code>insertRow</code> methods are called to update the database.
5643: *
5644: * @param columnIndex the first column is 1, the second 2, ...
5645: * @param reader An object that contains the data to set the parameter value to.
5646: * @param length the number of characters in the parameter data.
5647: * @throws SQLException if the driver does not support national
5648: * character sets; if the driver can detect that a data conversion
5649: * error could occur; this method is called on a closed result set,
5650: * if a database access error occurs or
5651: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5652: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5653: * this method
5654: * @since 1.6
5655: */
5656: public void updateNClob(int columnIndex, Reader reader, long length)
5657: throws SQLException {
5658: throw new SQLFeatureNotSupportedException(jdbcResBundle
5659: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5660: .toString());
5661: }
5662:
5663: /**
5664: * Updates the designated column using the given <code>Reader</code>
5665: * object, which is the given number of characters long.
5666: * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
5667: * parameter, it may be more practical to send it via a
5668: * <code>java.io.Reader</code> object. The data will be read from the stream
5669: * as needed until end-of-file is reached. The JDBC driver will
5670: * do any necessary conversion from UNICODE to the database char format.
5671: *
5672: * <P><B>Note:</B> This stream object can either be a standard
5673: * Java stream object or your own subclass that implements the
5674: * standard interface.
5675: * <p>
5676: * The updater methods are used to update column values in the
5677: * current row or the insert row. The updater methods do not
5678: * update the underlying database; instead the <code>updateRow</code> or
5679: * <code>insertRow</code> methods are called to update the database.
5680: *
5681: * @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
5682: * @param reader An object that contains the data to set the parameter value to.
5683: * @param length the number of characters in the parameter data.
5684: * @throws SQLException if the driver does not support national
5685: * character sets; if the driver can detect that a data conversion
5686: * error could occur; this method is called on a closed result set;
5687: * if a database access error occurs or
5688: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5689: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5690: * this method
5691: * @since 1.6
5692: */
5693: public void updateNClob(String columnLabel, Reader reader,
5694: long length) throws SQLException {
5695: throw new SQLFeatureNotSupportedException(jdbcResBundle
5696: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5697: .toString());
5698: }
5699:
5700: /**
5701: * Updates the designated column using the given <code>Reader</code>
5702: * object.
5703: * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
5704: * parameter, it may be more practical to send it via a
5705: * <code>java.io.Reader</code> object. The data will be read from the stream
5706: * as needed until end-of-file is reached. The JDBC driver will
5707: * do any necessary conversion from UNICODE to the database char format.
5708: *
5709: * <P><B>Note:</B> This stream object can either be a standard
5710: * Java stream object or your own subclass that implements the
5711: * standard interface.
5712: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
5713: * it might be more efficient to use a version of
5714: * <code>updateNClob</code> which takes a length parameter.
5715: * <p>
5716: * The updater methods are used to update column values in the
5717: * current row or the insert row. The updater methods do not
5718: * update the underlying database; instead the <code>updateRow</code> or
5719: * <code>insertRow</code> methods are called to update the database.
5720: *
5721: * @param columnIndex the first column is 1, the second 2, ...
5722: * @param reader An object that contains the data to set the parameter value to.
5723: * @throws SQLException if the driver does not support national
5724: * character sets; if the driver can detect that a data conversion
5725: * error could occur; this method is called on a closed result set,
5726: * if a database access error occurs or
5727: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5728: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5729: * this method
5730: * @since 1.6
5731: */
5732: public void updateNClob(int columnIndex, Reader reader)
5733: throws SQLException {
5734: throw new SQLFeatureNotSupportedException(jdbcResBundle
5735: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5736: .toString());
5737: }
5738:
5739: /**
5740: * Updates the designated column using the given <code>Reader</code>
5741: * object.
5742: * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
5743: * parameter, it may be more practical to send it via a
5744: * <code>java.io.Reader</code> object. The data will be read from the stream
5745: * as needed until end-of-file is reached. The JDBC driver will
5746: * do any necessary conversion from UNICODE to the database char format.
5747: *
5748: * <P><B>Note:</B> This stream object can either be a standard
5749: * Java stream object or your own subclass that implements the
5750: * standard interface.
5751: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
5752: * it might be more efficient to use a version of
5753: * <code>updateNClob</code> which takes a length parameter.
5754: * <p>
5755: * The updater methods are used to update column values in the
5756: * current row or the insert row. The updater methods do not
5757: * update the underlying database; instead the <code>updateRow</code> or
5758: * <code>insertRow</code> methods are called to update the database.
5759: *
5760: * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la
5761: bel is the name of the column
5762: * @param reader An object that contains the data to set the parameter value to.
5763: * @throws SQLException if the driver does not support national
5764: * character sets; if the driver can detect that a data conversion
5765: * error could occur; this method is called on a closed result set;
5766: * if a database access error occurs or
5767: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5768: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5769: * this method
5770: * @since 1.6
5771: */
5772: public void updateNClob(String columnLabel, Reader reader)
5773: throws SQLException {
5774: throw new SQLFeatureNotSupportedException(jdbcResBundle
5775: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5776: .toString());
5777: }
5778:
5779: /**
5780: * Updates the designated column with an ascii stream value, which will have
5781: * the specified number of bytes.
5782: * The updater methods are used to update column values in the
5783: * current row or the insert row. The updater methods do not
5784: * update the underlying database; instead the <code>updateRow</code> or
5785: * <code>insertRow</code> methods are called to update the database.
5786: *
5787: * @param columnIndex the first column is 1, the second is 2, ...
5788: * @param x the new column value
5789: * @param length the length of the stream
5790: * @exception SQLException if a database access error occurs,
5791: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5792: * or this method is called on a closed result set
5793: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5794: * this method
5795: * @since 1.6
5796: */
5797: public void updateAsciiStream(int columnIndex,
5798: java.io.InputStream x, long length) throws SQLException {
5799: throw new SQLFeatureNotSupportedException(jdbcResBundle
5800: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5801: .toString());
5802: }
5803:
5804: /**
5805: * Updates the designated column with a binary stream value, which will have
5806: * the specified number of bytes.
5807: * The updater methods are used to update column values in the
5808: * current row or the insert row. The updater methods do not
5809: * update the underlying database; instead the <code>updateRow</code> or
5810: * <code>insertRow</code> methods are called to update the database.
5811: *
5812: * @param columnIndex the first column is 1, the second is 2, ...
5813: * @param x the new column value
5814: * @param length the length of the stream
5815: * @exception SQLException if a database access error occurs,
5816: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5817: * or this method is called on a closed result set
5818: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5819: * this method
5820: * @since 1.6
5821: */
5822: public void updateBinaryStream(int columnIndex,
5823: java.io.InputStream x, long length) throws SQLException {
5824: throw new SQLFeatureNotSupportedException(jdbcResBundle
5825: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5826: .toString());
5827: }
5828:
5829: /**
5830: * Updates the designated column with a character stream value, which will have
5831: * the specified number of bytes.
5832: * The updater methods are used to update column values in the
5833: * current row or the insert row. The updater methods do not
5834: * update the underlying database; instead the <code>updateRow</code> or
5835: * <code>insertRow</code> methods are called to update the database.
5836: *
5837: * @param columnIndex the first column is 1, the second is 2, ...
5838: * @param x the new column value
5839: * @param length the length of the stream
5840: * @exception SQLException if a database access error occurs,
5841: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5842: * or this method is called on a closed result set
5843: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5844: * this method
5845: * @since 1.6
5846: */
5847: public void updateCharacterStream(int columnIndex,
5848: java.io.Reader x, long length) throws SQLException {
5849: throw new SQLFeatureNotSupportedException(jdbcResBundle
5850: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5851: .toString());
5852: }
5853:
5854: /**
5855: * Updates the designated column with an ascii stream value, which will have
5856: * the specified number of bytes..
5857: * The updater methods are used to update column values in the
5858: * current row or the insert row. The updater methods do not
5859: * update the underlying database; instead the <code>updateRow</code> or
5860: * <code>insertRow</code> methods are called to update the database.
5861: *
5862: * @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
5863: * @param x the new column value
5864: * @param length the length of the stream
5865: * @exception SQLException if a database access error occurs,
5866: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5867: * or this method is called on a closed result set
5868: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5869: * this method
5870: * @since 1.6
5871: */
5872: public void updateAsciiStream(String columnLabel,
5873: java.io.InputStream x, long length) throws SQLException {
5874: throw new SQLFeatureNotSupportedException(jdbcResBundle
5875: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5876: .toString());
5877: }
5878:
5879: /**
5880: * Updates the designated column with an ascii stream value.
5881: * The updater methods are used to update column values in the
5882: * current row or the insert row. The updater methods do not
5883: * update the underlying database; instead the <code>updateRow</code> or
5884: * <code>insertRow</code> methods are called to update the database.
5885: *
5886: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
5887: * it might be more efficient to use a version of
5888: * <code>updateAsciiStream</code> which takes a length parameter.
5889: *
5890: * @param columnIndex the first column is 1, the second is 2, ...
5891: * @param x the new column value
5892: * @exception SQLException if a database access error occurs,
5893: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5894: * or this method is called on a closed result set
5895: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5896: * this method
5897: * @since 1.6
5898: */
5899: public void updateAsciiStream(int columnIndex, java.io.InputStream x)
5900: throws SQLException {
5901: throw new SQLFeatureNotSupportedException(jdbcResBundle
5902: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5903: .toString());
5904: }
5905:
5906: /**
5907: * Updates the designated column with an ascii stream value.
5908: * The updater methods are used to update column values in the
5909: * current row or the insert row. The updater methods do not
5910: * update the underlying database; instead the <code>updateRow</code> or
5911: * <code>insertRow</code> methods are called to update the database.
5912: *
5913: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
5914: * it might be more efficient to use a version of
5915: * <code>updateAsciiStream</code> which takes a length parameter.
5916: *
5917: * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la
5918: bel is the name of the column
5919: * @param x the new column value
5920: * @exception SQLException if a database access error occurs,
5921: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5922: * or this method is called on a closed result set
5923: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5924: * this method
5925: * @since 1.6
5926: */
5927: public void updateAsciiStream(String columnLabel,
5928: java.io.InputStream x) throws SQLException {
5929: throw new SQLFeatureNotSupportedException(jdbcResBundle
5930: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5931: .toString());
5932: }
5933:
5934: /**
5935: * Updates the designated column with a binary stream value, which will have
5936: * the specified number of bytes.
5937: * The updater methods are used to update column values in the
5938: * current row or the insert row. The updater methods do not
5939: * update the underlying database; instead the <code>updateRow</code> or
5940: * <code>insertRow</code> methods are called to update the database.
5941: *
5942: * @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
5943: * @param x the new column value
5944: * @param length the length of the stream
5945: * @exception SQLException if a database access error occurs,
5946: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5947: * or this method is called on a closed result set
5948: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5949: * this method
5950: * @since 1.6
5951: */
5952: public void updateBinaryStream(String columnLabel,
5953: java.io.InputStream x, long length) throws SQLException {
5954: throw new SQLFeatureNotSupportedException(jdbcResBundle
5955: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5956: .toString());
5957: }
5958:
5959: /**
5960: * Updates the designated column with a binary stream value.
5961: * The updater methods are used to update column values in the
5962: * current row or the insert row. The updater methods do not
5963: * update the underlying database; instead the <code>updateRow</code> or
5964: * <code>insertRow</code> methods are called to update the database.
5965: *
5966: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
5967: * it might be more efficient to use a version of
5968: * <code>updateBinaryStream</code> which takes a length parameter.
5969: *
5970: * @param columnIndex the first column is 1, the second is 2, ...
5971: * @param x the new column value
5972: * @exception SQLException if a database access error occurs,
5973: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
5974: * or this method is called on a closed result set
5975: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
5976: * this method
5977: * @since 1.6
5978: */
5979: public void updateBinaryStream(int columnIndex,
5980: java.io.InputStream x) throws SQLException {
5981: throw new SQLFeatureNotSupportedException(jdbcResBundle
5982: .handleGetObject("jdbcrowsetimpl.featnotsupp")
5983: .toString());
5984: }
5985:
5986: /**
5987: * Updates the designated column with a binary stream value.
5988: * The updater methods are used to update column values in the
5989: * current row or the insert row. The updater methods do not
5990: * update the underlying database; instead the <code>updateRow</code> or
5991: * <code>insertRow</code> methods are called to update the database.
5992: *
5993: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
5994: * it might be more efficient to use a version of
5995: * <code>updateBinaryStream</code> which takes a length parameter.
5996: *
5997: * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la
5998: bel is the name of the column
5999: * @param x the new column value
6000: * @exception SQLException if a database access error occurs,
6001: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
6002: * or this method is called on a closed result set
6003: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6004: * this method
6005: * @since 1.6
6006: */
6007: public void updateBinaryStream(String columnLabel,
6008: java.io.InputStream x) throws SQLException {
6009: throw new SQLFeatureNotSupportedException(jdbcResBundle
6010: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6011: .toString());
6012: }
6013:
6014: /**
6015: * Updates the designated column with a character stream value, which will have
6016: * the specified number of bytes.
6017: * The updater methods are used to update column values in the
6018: * current row or the insert row. The updater methods do not
6019: * update the underlying database; instead the <code>updateRow</code> or
6020: * <code>insertRow</code> methods are called to update the database.
6021: *
6022: * @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
6023: * @param reader the <code>java.io.Reader</code> object containing
6024: * the new column value
6025: * @param length the length of the stream
6026: * @exception SQLException if a database access error occurs,
6027: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
6028: * or this method is called on a closed result set
6029: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6030: * this method
6031: * @since 1.6
6032: */
6033: public void updateCharacterStream(String columnLabel,
6034: java.io.Reader reader, long length) throws SQLException {
6035: throw new SQLFeatureNotSupportedException(jdbcResBundle
6036: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6037: .toString());
6038: }
6039:
6040: /**
6041: * Updates the designated column with a character stream value.
6042: * The updater methods are used to update column values in the
6043: * current row or the insert row. The updater methods do not
6044: * update the underlying database; instead the <code>updateRow</code> or
6045: * <code>insertRow</code> methods are called to update the database.
6046: *
6047: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
6048: * it might be more efficient to use a version of
6049: * <code>updateCharacterStream</code> which takes a length parameter.
6050: *
6051: * @param columnIndex the first column is 1, the second is 2, ...
6052: * @param x the new column value
6053: * @exception SQLException if a database access error occurs,
6054: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
6055: * or this method is called on a closed result set
6056: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6057: * this method
6058: * @since 1.6
6059: */
6060: public void updateCharacterStream(int columnIndex, java.io.Reader x)
6061: throws SQLException {
6062: throw new SQLFeatureNotSupportedException(jdbcResBundle
6063: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6064: .toString());
6065: }
6066:
6067: /**
6068: * Updates the designated column with a character stream value.
6069: * The updater methods are used to update column values in the
6070: * current row or the insert row. The updater methods do not
6071: * update the underlying database; instead the <code>updateRow</code> or
6072: * <code>insertRow</code> methods are called to update the database.
6073: *
6074: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
6075: * it might be more efficient to use a version of
6076: * <code>updateCharacterStream</code> which takes a length parameter.
6077: *
6078: * @param columnLabel the label for the column specified with the SQL AS clause. If the SQL AS clause was not specified, then the la
6079: bel is the name of the column
6080: * @param reader the <code>java.io.Reader</code> object containing
6081: * the new column value
6082: * @exception SQLException if a database access error occurs,
6083: * the result set concurrency is <code>CONCUR_READ_ONLY</code>
6084: * or this method is called on a closed result set
6085: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6086: * this method
6087: * @since 1.6
6088: */
6089: public void updateCharacterStream(String columnLabel,
6090: java.io.Reader reader) throws SQLException {
6091: throw new SQLFeatureNotSupportedException(jdbcResBundle
6092: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6093: .toString());
6094: }
6095:
6096: /**
6097: * Sets the designated parameter to the given <code>java.net.URL</code> value.
6098: * The driver converts this to an SQL <code>DATALINK</code> value
6099: * when it sends it to the database.
6100: *
6101: * @param parameterIndex the first parameter is 1, the second is 2, ...
6102: * @param x the <code>java.net.URL</code> object to be set
6103: * @exception SQLException if a database access error occurs or
6104: * this method is called on a closed <code>PreparedStatement</code>
6105: * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
6106: * @since 1.4
6107: */
6108: public void setURL(int parameterIndex, java.net.URL x)
6109: throws SQLException {
6110: throw new SQLFeatureNotSupportedException(jdbcResBundle
6111: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6112: .toString());
6113: }
6114:
6115: /**
6116: * Sets the designated parameter to a <code>Reader</code> object.
6117: * This method differs from the <code>setCharacterStream (int, Reader)</code> method
6118: * because it informs the driver that the parameter value should be sent to
6119: * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
6120: * driver may have to do extra work to determine whether the parameter
6121: * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
6122: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
6123: * it might be more efficient to use a version of
6124: * <code>setNClob</code> which takes a length parameter.
6125: *
6126: * @param parameterIndex index of the first parameter is 1, the second is 2, ...
6127: * @param reader An object that contains the data to set the parameter value to.
6128: * @throws SQLException if parameterIndex does not correspond to a parameter
6129: * marker in the SQL statement;
6130: * if the driver does not support national character sets;
6131: * if the driver can detect that a data conversion
6132: * error could occur; if a database access error occurs or
6133: * this method is called on a closed <code>PreparedStatement</code>
6134: * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
6135: *
6136: * @since 1.6
6137: */
6138: public void setNClob(int parameterIndex, Reader reader)
6139: throws SQLException {
6140: throw new SQLFeatureNotSupportedException(jdbcResBundle
6141: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6142: .toString());
6143: }
6144:
6145: /**
6146: * Sets the designated parameter to a <code>Reader</code> object. The <code>reader</code> must contain the number
6147: * of characters specified by length otherwise a <code>SQLException</code> will be
6148: * generated when the <code>CallableStatement</code> is executed.
6149: * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
6150: * because it informs the driver that the parameter value should be sent to
6151: * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
6152: * driver may have to do extra work to determine whether the parameter
6153: * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
6154: *
6155: * @param parameterName the name of the parameter to be set
6156: * @param reader An object that contains the data to set the parameter value to.
6157: * @param length the number of characters in the parameter data.
6158: * @throws SQLException if parameterIndex does not correspond to a parameter
6159: * marker in the SQL statement; if the length specified is less than zero;
6160: * if the driver does not support national
6161: * character sets; if the driver can detect that a data conversion
6162: * error could occur; if a database access error occurs or
6163: * this method is called on a closed <code>CallableStatement</code>
6164: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6165: * this method
6166: * @since 1.6
6167: */
6168: public void setNClob(String parameterName, Reader reader,
6169: long length) throws SQLException {
6170: throw new SQLFeatureNotSupportedException(jdbcResBundle
6171: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6172: .toString());
6173: }
6174:
6175: /**
6176: * Sets the designated parameter to a <code>Reader</code> object.
6177: * This method differs from the <code>setCharacterStream (int, Reader)</code> method
6178: * because it informs the driver that the parameter value should be sent to
6179: * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
6180: * driver may have to do extra work to determine whether the parameter
6181: * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
6182: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
6183: * it might be more efficient to use a version of
6184: * <code>setNClob</code> which takes a length parameter.
6185: *
6186: * @param parameterName the name of the parameter
6187: * @param reader An object that contains the data to set the parameter value to.
6188: * @throws SQLException if the driver does not support national character sets;
6189: * if the driver can detect that a data conversion
6190: * error could occur; if a database access error occurs or
6191: * this method is called on a closed <code>CallableStatement</code>
6192: * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
6193: *
6194: * @since 1.6
6195: */
6196: public void setNClob(String parameterName, Reader reader)
6197: throws SQLException {
6198: throw new SQLFeatureNotSupportedException(jdbcResBundle
6199: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6200: .toString());
6201: }
6202:
6203: /**
6204: ** of characters specified by length otherwise a <code>SQLException</code> will becontain the number
6205: * generated when the <code>PreparedStatement</code> is executed.
6206: * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
6207: * because it informs the driver that the parameter value should be sent to
6208: * the server as a <code>NCLOB</code>. When the <code>setCharacterStream</code> method is used, the
6209: * driver may have to do extra work to determine whether the parameter
6210: * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
6211: * @param parameterIndex index of the first parameter is 1, the second is 2, ...
6212: * @param reader An object that contains the data to set the parameter value to.
6213: * @param length the number of characters in the parameter data.
6214: * @throws SQLException if parameterIndex does not correspond to a parameter
6215: * marker in the SQL statement; if the length specified is less than zero;
6216: * if the driver does not support national character sets;
6217: * if the driver can detect that a data conversion
6218: * error could occur; if a database access error occurs or
6219: * this method is called on a closed <code>PreparedStatement</code>
6220: * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
6221: *
6222: * @since 1.6
6223: */
6224: public void setNClob(int parameterIndex, Reader reader, long length)
6225: throws SQLException {
6226: throw new SQLFeatureNotSupportedException(jdbcResBundle
6227: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6228: .toString());
6229: }
6230:
6231: /**
6232: * Sets the designated parameter to a <code>java.sql.NClob</code> object. The driver converts this to
6233: a
6234: * SQL <code>NCLOB</code> value when it sends it to the database.
6235: * @param parameterIndex of the first parameter is 1, the second is 2, ...
6236: * @param value the parameter value
6237: * @throws SQLException if the driver does not support national
6238: * character sets; if the driver can detect that a data conversion
6239: * error could occur ; or if a database access error occurs
6240: * @since 1.6
6241: */
6242: public void setNClob(int parameterIndex, NClob value)
6243: throws SQLException {
6244: throw new SQLFeatureNotSupportedException(jdbcResBundle
6245: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6246: .toString());
6247: }
6248:
6249: /**
6250: * Sets the designated paramter to the given <code>String</code> object.
6251: * The driver converts this to a SQL <code>NCHAR</code> or
6252: * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code>
6253: * @param parameterName the name of the column to be set
6254: * @param value the parameter value
6255: * @throws SQLException if the driver does not support national
6256: * character sets; if the driver can detect that a data conversion
6257: * error could occur; or if a database access error occurs
6258: * @since 1.6
6259: */
6260: public void setNString(String parameterName, String value)
6261: throws SQLException {
6262: throw new SQLFeatureNotSupportedException(jdbcResBundle
6263: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6264: .toString());
6265: }
6266:
6267: /**
6268: * Sets the designated parameter to a <code>Reader</code> object. The
6269: * <code>Reader</code> reads the data till end-of-file is reached. The
6270: * driver does the necessary conversion from Java character format to
6271: * the national character set in the database.
6272: * @param parameterIndex of the first parameter is 1, the second is 2, ...
6273: * @param value the parameter value
6274: * @param length the number of characters in the parameter data.
6275: * @throws SQLException if the driver does not support national
6276: * character sets; if the driver can detect that a data conversion
6277: * error could occur ; or if a database access error occurs
6278: * @since 1.6
6279: */
6280: public void setNCharacterStream(int parameterIndex, Reader value,
6281: long length) throws SQLException {
6282: throw new SQLFeatureNotSupportedException(jdbcResBundle
6283: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6284: .toString());
6285: }
6286:
6287: /**
6288: * Sets the designated parameter to a <code>Reader</code> object. The
6289: * <code>Reader</code> reads the data till end-of-file is reached. The
6290: * driver does the necessary conversion from Java character format to
6291: * the national character set in the database.
6292: * @param parameterName the name of the column to be set
6293: * @param value the parameter value
6294: * @param length the number of characters in the parameter data.
6295: * @throws SQLException if the driver does not support national
6296: * character sets; if the driver can detect that a data conversion
6297: * error could occur; or if a database access error occurs
6298: * @since 1.6
6299: */
6300: public void setNCharacterStream(String parameterName, Reader value,
6301: long length) throws SQLException {
6302: throw new SQLFeatureNotSupportedException(jdbcResBundle
6303: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6304: .toString());
6305: }
6306:
6307: /**
6308: * Sets the designated parameter to a <code>Reader</code> object. The
6309: * <code>Reader</code> reads the data till end-of-file is reached. The
6310: * driver does the necessary conversion from Java character format to
6311: * the national character set in the database.
6312:
6313: * <P><B>Note:</B> This stream object can either be a standard
6314: * Java stream object or your own subclass that implements the
6315: * standard interface.
6316: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
6317: * it might be more efficient to use a version of
6318: * <code>setNCharacterStream</code> which takes a length parameter.
6319: *
6320: * @param parameterName the name of the parameter
6321: * @param value the parameter value
6322: * @throws SQLException if the driver does not support national
6323: * character sets; if the driver can detect that a data conversion
6324: * error could occur ; if a database access error occurs; or
6325: * this method is called on a closed <code>CallableStatement</code>
6326: * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
6327: * @since 1.6
6328: */
6329: public void setNCharacterStream(String parameterName, Reader value)
6330: throws SQLException {
6331: throw new SQLFeatureNotSupportedException(jdbcResBundle
6332: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6333: .toString());
6334: }
6335:
6336: /**
6337: * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value,
6338: * using the given <code>Calendar</code> object. The driver uses
6339: * the <code>Calendar</code> object to construct an SQL <code>TIMESTAMP</code> value,
6340: * which the driver then sends to the database. With a
6341: * a <code>Calendar</code> object, the driver can calculate the timestamp
6342: * taking into account a custom timezone. If no
6343: * <code>Calendar</code> object is specified, the driver uses the default
6344: * timezone, which is that of the virtual machine running the application.
6345: *
6346: * @param parameterName the name of the parameter
6347: * @param x the parameter value
6348: * @param cal the <code>Calendar</code> object the driver will use
6349: * to construct the timestamp
6350: * @exception SQLException if a database access error occurs or
6351: * this method is called on a closed <code>CallableStatement</code>
6352: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6353: * this method
6354: * @see #getTimestamp
6355: * @since 1.4
6356: */
6357: public void setTimestamp(String parameterName,
6358: java.sql.Timestamp x, Calendar cal) throws SQLException {
6359: throw new SQLFeatureNotSupportedException(jdbcResBundle
6360: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6361: .toString());
6362: }
6363:
6364: /**
6365: * Sets the designated parameter to a <code>Reader</code> object. The <code>reader</code> must contain the number
6366: * of characters specified by length otherwise a <code>SQLException</code> will be
6367: * generated when the <code>CallableStatement</code> is executed.
6368: * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
6369: * because it informs the driver that the parameter value should be sent to
6370: * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
6371: * driver may have to do extra work to determine whether the parameter
6372: * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
6373: * @param parameterName the name of the parameter to be set
6374: * @param reader An object that contains the data to set the parameter value to.
6375: * @param length the number of characters in the parameter data.
6376: * @throws SQLException if parameterIndex does not correspond to a parameter
6377: * marker in the SQL statement; if the length specified is less than zero;
6378: * a database access error occurs or
6379: * this method is called on a closed <code>CallableStatement</code>
6380: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6381: * this method
6382: *
6383: * @since 1.6
6384: */
6385: public void setClob(String parameterName, Reader reader, long length)
6386: throws SQLException {
6387: throw new SQLFeatureNotSupportedException(jdbcResBundle
6388: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6389: .toString());
6390: }
6391:
6392: /**
6393: * Sets the designated parameter to the given <code>java.sql.Clob</code> object.
6394: * The driver converts this to an SQL <code>CLOB</code> value when it
6395: * sends it to the database.
6396: *
6397: * @param parameterName the name of the parameter
6398: * @param x a <code>Clob</code> object that maps an SQL <code>CLOB</code> value
6399: * @exception SQLException if a database access error occurs or
6400: * this method is called on a closed <code>CallableStatement</code>
6401: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6402: * this method
6403: * @since 1.6
6404: */
6405: public void setClob(String parameterName, Clob x)
6406: throws SQLException {
6407: throw new SQLFeatureNotSupportedException(jdbcResBundle
6408: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6409: .toString());
6410: }
6411:
6412: /**
6413: * Sets the designated parameter to a <code>Reader</code> object.
6414: * This method differs from the <code>setCharacterStream (int, Reader)</code> method
6415: * because it informs the driver that the parameter value should be sent to
6416: * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
6417: * driver may have to do extra work to determine whether the parameter
6418: * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
6419: *
6420: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
6421: * it might be more efficient to use a version of
6422: * <code>setClob</code> which takes a length parameter.
6423: *
6424: * @param parameterName the name of the parameter
6425: * @param reader An object that contains the data to set the parameter value to.
6426: * @throws SQLException if a database access error occurs or this method is called on
6427: * a closed <code>CallableStatement</code>
6428: *
6429: * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
6430: * @since 1.6
6431: */
6432: public void setClob(String parameterName, Reader reader)
6433: throws SQLException {
6434: throw new SQLFeatureNotSupportedException(jdbcResBundle
6435: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6436: .toString());
6437: }
6438:
6439: /**
6440: * Sets the designated parameter to the given <code>java.sql.Date</code> value
6441: * using the default time zone of the virtual machine that is running
6442: * the application.
6443: * The driver converts this
6444: * to an SQL <code>DATE</code> value when it sends it to the database.
6445: *
6446: * @param parameterName the name of the parameter
6447: * @param x the parameter value
6448: * @exception SQLException if a database access error occurs or
6449: * this method is called on a closed <code>CallableStatement</code>
6450: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6451: * this method
6452: * @see #getDate
6453: * @since 1.4
6454: */
6455: public void setDate(String parameterName, java.sql.Date x)
6456: throws SQLException {
6457: throw new SQLFeatureNotSupportedException(jdbcResBundle
6458: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6459: .toString());
6460: }
6461:
6462: /**
6463: * Sets the designated parameter to the given <code>java.sql.Date</code> value,
6464: * using the given <code>Calendar</code> object. The driver uses
6465: * the <code>Calendar</code> object to construct an SQL <code>DATE</code> value,
6466: * which the driver then sends to the database. With a
6467: * a <code>Calendar</code> object, the driver can calculate the date
6468: * taking into account a custom timezone. If no
6469: * <code>Calendar</code> object is specified, the driver uses the default
6470: * timezone, which is that of the virtual machine running the application.
6471: *
6472: * @param parameterName the name of the parameter
6473: * @param x the parameter value
6474: * @param cal the <code>Calendar</code> object the driver will use
6475: * to construct the date
6476: * @exception SQLException if a database access error occurs or
6477: * this method is called on a closed <code>CallableStatement</code>
6478: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6479: * this method
6480: * @see #getDate
6481: * @since 1.4
6482: */
6483: public void setDate(String parameterName, java.sql.Date x,
6484: Calendar cal) throws SQLException {
6485: throw new SQLFeatureNotSupportedException(jdbcResBundle
6486: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6487: .toString());
6488: }
6489:
6490: /**
6491: * Sets the designated parameter to the given <code>java.sql.Time</code> value.
6492: * The driver converts this
6493: * to an SQL <code>TIME</code> value when it sends it to the database.
6494: *
6495: * @param parameterName the name of the parameter
6496: * @param x the parameter value
6497: * @exception SQLException if a database access error occurs or
6498: * this method is called on a closed <code>CallableStatement</code>
6499: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6500: * this method
6501: * @see #getTime
6502: * @since 1.4
6503: */
6504: public void setTime(String parameterName, java.sql.Time x)
6505: throws SQLException {
6506: throw new SQLFeatureNotSupportedException(jdbcResBundle
6507: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6508: .toString());
6509: }
6510:
6511: /**
6512: * Sets the designated parameter to the given <code>java.sql.Time</code> value,
6513: * using the given <code>Calendar</code> object. The driver uses
6514: * the <code>Calendar</code> object to construct an SQL <code>TIME</code> value,
6515: * which the driver then sends to the database. With a
6516: * a <code>Calendar</code> object, the driver can calculate the time
6517: * taking into account a custom timezone. If no
6518: * <code>Calendar</code> object is specified, the driver uses the default
6519: * timezone, which is that of the virtual machine running the application.
6520: *
6521: * @param parameterName the name of the parameter
6522: * @param x the parameter value
6523: * @param cal the <code>Calendar</code> object the driver will use
6524: * to construct the time
6525: * @exception SQLException if a database access error occurs or
6526: * this method is called on a closed <code>CallableStatement</code>
6527: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6528: * this method
6529: * @see #getTime
6530: * @since 1.4
6531: */
6532: public void setTime(String parameterName, java.sql.Time x,
6533: Calendar cal) throws SQLException {
6534: throw new SQLFeatureNotSupportedException(jdbcResBundle
6535: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6536: .toString());
6537: }
6538:
6539: /**
6540: * Sets the designated parameter to a <code>Reader</code> object.
6541: * This method differs from the <code>setCharacterStream (int, Reader)</code> method
6542: * because it informs the driver that the parameter value should be sent to
6543: * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
6544: * driver may have to do extra work to determine whether the parameter
6545: * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
6546: *
6547: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
6548: * it might be more efficient to use a version of
6549: * <code>setClob</code> which takes a length parameter.
6550: *
6551: * @param parameterIndex index of the first parameter is 1, the second is 2, ...
6552: * @param reader An object that contains the data to set the parameter value to.
6553: * @throws SQLException if a database access error occurs, this method is called on
6554: * a closed <code>PreparedStatement</code>or if parameterIndex does not correspond to a parameter
6555: * marker in the SQL statement
6556: *
6557: * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
6558: * @since 1.6
6559: */
6560: public void setClob(int parameterIndex, Reader reader)
6561: throws SQLException {
6562: throw new SQLFeatureNotSupportedException(jdbcResBundle
6563: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6564: .toString());
6565: }
6566:
6567: /**
6568: * Sets the designated parameter to a <code>Reader</code> object. The reader must contain the number
6569: * of characters specified by length otherwise a <code>SQLException</code> will be
6570: * generated when the <code>PreparedStatement</code> is executed.
6571: *This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
6572: * because it informs the driver that the parameter value should be sent to
6573: * the server as a <code>CLOB</code>. When the <code>setCharacterStream</code> method is used, the
6574: * driver may have to do extra work to determine whether the parameter
6575: * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
6576: * @param parameterIndex index of the first parameter is 1, the second is 2, ...
6577: * @param reader An object that contains the data to set the parameter value to.
6578: * @param length the number of characters in the parameter data.
6579: * @throws SQLException if a database access error occurs, this method is called on
6580: * a closed <code>PreparedStatement</code>, if parameterIndex does not correspond to a parameter
6581: * marker in the SQL statement, or if the length specified is less than zero.
6582: *
6583: * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
6584: * @since 1.6
6585: */
6586: public void setClob(int parameterIndex, Reader reader, long length)
6587: throws SQLException {
6588: throw new SQLFeatureNotSupportedException(jdbcResBundle
6589: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6590: .toString());
6591: }
6592:
6593: /**
6594: * Sets the designated parameter to a <code>InputStream</code> object. The inputstream must contain the number
6595: * of characters specified by length otherwise a <code>SQLException</code> will be
6596: * generated when the <code>PreparedStatement</code> is executed.
6597: * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
6598: * method because it informs the driver that the parameter value should be
6599: * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
6600: * the driver may have to do extra work to determine whether the parameter
6601: * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
6602: * @param parameterIndex index of the first parameter is 1,
6603: * the second is 2, ...
6604: * @param inputStream An object that contains the data to set the parameter
6605: * value to.
6606: * @param length the number of bytes in the parameter data.
6607: * @throws SQLException if a database access error occurs,
6608: * this method is called on a closed <code>PreparedStatement</code>,
6609: * if parameterIndex does not correspond
6610: * to a parameter marker in the SQL statement, if the length specified
6611: * is less than zero or if the number of bytes in the inputstream does not match
6612: * the specfied length.
6613: * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
6614: *
6615: * @since 1.6
6616: */
6617: public void setBlob(int parameterIndex, InputStream inputStream,
6618: long length) throws SQLException {
6619: throw new SQLFeatureNotSupportedException(jdbcResBundle
6620: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6621: .toString());
6622: }
6623:
6624: /**
6625: * Sets the designated parameter to a <code>InputStream</code> object.
6626: * This method differs from the <code>setBinaryStream (int, InputStream)</code>
6627: * This method differs from the <code>setBinaryStream (int, InputStream)</code>
6628: * method because it informs the driver that the parameter value should be
6629: * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
6630: * the driver may have to do extra work to determine whether the parameter
6631: * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
6632: *
6633: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
6634: * it might be more efficient to use a version of
6635: * <code>setBlob</code> which takes a length parameter.
6636: *
6637: * @param parameterIndex index of the first parameter is 1,
6638: * the second is 2, ...
6639:
6640:
6641: * @param inputStream An object that contains the data to set the parameter
6642: * value to.
6643: * @throws SQLException if a database access error occurs,
6644: * this method is called on a closed <code>PreparedStatement</code> or
6645: * if parameterIndex does not correspond
6646: * to a parameter marker in the SQL statement,
6647: * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
6648: *
6649: * @since 1.6
6650: */
6651: public void setBlob(int parameterIndex, InputStream inputStream)
6652: throws SQLException {
6653: throw new SQLFeatureNotSupportedException(jdbcResBundle
6654: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6655: .toString());
6656: }
6657:
6658: /**
6659: * Sets the designated parameter to a <code>InputStream</code> object. The <code>inputstream</code> must contain the number
6660: * of characters specified by length, otherwise a <code>SQLException</code> will be
6661: * generated when the <code>CallableStatement</code> is executed.
6662: * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
6663: * method because it informs the driver that the parameter value should be
6664: * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
6665: * the driver may have to do extra work to determine whether the parameter
6666: * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
6667: *
6668: * @param parameterName the name of the parameter to be set
6669: * the second is 2, ...
6670: *
6671: * @param inputStream An object that contains the data to set the parameter
6672: * value to.
6673: * @param length the number of bytes in the parameter data.
6674: * @throws SQLException if parameterIndex does not correspond
6675: * to a parameter marker in the SQL statement, or if the length specified
6676: * is less than zero; if the number of bytes in the inputstream does not match
6677: * the specfied length; if a database access error occurs or
6678: * this method is called on a closed <code>CallableStatement</code>
6679: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6680: * this method
6681: *
6682: * @since 1.6
6683: */
6684: public void setBlob(String parameterName, InputStream inputStream,
6685: long length) throws SQLException {
6686: throw new SQLFeatureNotSupportedException(jdbcResBundle
6687: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6688: .toString());
6689: }
6690:
6691: /**
6692: * Sets the designated parameter to the given <code>java.sql.Blob</code> object.
6693: * The driver converts this to an SQL <code>BLOB</code> value when it
6694: * sends it to the database.
6695: *
6696: * @param parameterName the name of the parameter
6697: * @param x a <code>Blob</code> object that maps an SQL <code>BLOB</code> value
6698: * @exception SQLException if a database access error occurs or
6699: * this method is called on a closed <code>CallableStatement</code>
6700: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6701: * this method
6702: * @since 1.6
6703: */
6704: public void setBlob(String parameterName, Blob x)
6705: throws SQLException {
6706: throw new SQLFeatureNotSupportedException(jdbcResBundle
6707: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6708: .toString());
6709: }
6710:
6711: /**
6712: * Sets the designated parameter to a <code>InputStream</code> object.
6713: * This method differs from the <code>setBinaryStream (int, InputStream)</code>
6714: * method because it informs the driver that the parameter value should be
6715: * sent to the server as a <code>BLOB</code>. When the <code>setBinaryStream</code> method is used,
6716: * the driver may have to do extra work to determine whether the parameter
6717: * data should be send to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
6718: *
6719: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
6720: * it might be more efficient to use a version of
6721: * <code>setBlob</code> which takes a length parameter.
6722: *
6723: * @param parameterName the name of the parameter
6724: * @param inputStream An object that contains the data to set the parameter
6725: * value to.
6726: * @throws SQLException if a database access error occurs or
6727: * this method is called on a closed <code>CallableStatement</code>
6728: * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
6729: *
6730: * @since 1.6
6731: */
6732: public void setBlob(String parameterName, InputStream inputStream)
6733: throws SQLException {
6734: throw new SQLFeatureNotSupportedException(jdbcResBundle
6735: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6736: .toString());
6737: }
6738:
6739: /**
6740: * Sets the value of the designated parameter with the given object. The second
6741: * argument must be an object type; for integral values, the
6742: * <code>java.lang</code> equivalent objects should be used.
6743: *
6744: * <p>The given Java object will be converted to the given targetSqlType
6745: * before being sent to the database.
6746: *
6747: * If the object has a custom mapping (is of a class implementing the
6748: * interface <code>SQLData</code>),
6749: * the JDBC driver should call the method <code>SQLData.writeSQL</code> to write it
6750: * to the SQL data stream.
6751: * If, on the other hand, the object is of a class implementing
6752: * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>NClob</code>,
6753: * <code>Struct</code>, <code>java.net.URL</code>,
6754: * or <code>Array</code>, the driver should pass it to the database as a
6755: * value of the corresponding SQL type.
6756: * <P>
6757: * Note that this method may be used to pass datatabase-
6758: * specific abstract data types.
6759: *
6760: * @param parameterName the name of the parameter
6761: * @param x the object containing the input parameter value
6762: * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
6763: * sent to the database. The scale argument may further qualify this type.
6764: * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,
6765: * this is the number of digits after the decimal point. For all other
6766: * types, this value will be ignored.
6767: * @exception SQLException if a database access error occurs or
6768: * this method is called on a closed <code>CallableStatement</code>
6769: * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is
6770: * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
6771: * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
6772: * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
6773: * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
6774: * or <code>STRUCT</code> data type and the JDBC driver does not support
6775: * this data type
6776: * @see Types
6777: * @see #getObject
6778: * @since 1.4
6779: */
6780: public void setObject(String parameterName, Object x,
6781: int targetSqlType, int scale) throws SQLException {
6782: throw new SQLFeatureNotSupportedException(jdbcResBundle
6783: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6784: .toString());
6785: }
6786:
6787: /**
6788: * Sets the value of the designated parameter with the given object.
6789: * This method is like the method <code>setObject</code>
6790: * above, except that it assumes a scale of zero.
6791: *
6792: * @param parameterName the name of the parameter
6793: * @param x the object containing the input parameter value
6794: * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
6795: * sent to the database
6796: * @exception SQLException if a database access error occurs or
6797: * this method is called on a closed <code>CallableStatement</code>
6798: * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is
6799: * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
6800: * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
6801: * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
6802: * <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
6803: * or <code>STRUCT</code> data type and the JDBC driver does not support
6804: * this data type
6805: * @see #getObject
6806: * @since 1.4
6807: */
6808: public void setObject(String parameterName, Object x,
6809: int targetSqlType) throws SQLException {
6810: throw new SQLFeatureNotSupportedException(jdbcResBundle
6811: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6812: .toString());
6813: }
6814:
6815: /**
6816: * Sets the value of the designated parameter with the given object.
6817: * The second parameter must be of type <code>Object</code>; therefore, the
6818: * <code>java.lang</code> equivalent objects should be used for built-in types.
6819: *
6820: * <p>The JDBC specification specifies a standard mapping from
6821: * Java <code>Object</code> types to SQL types. The given argument
6822: * will be converted to the corresponding SQL type before being
6823: * sent to the database.
6824: *
6825: * <p>Note that this method may be used to pass datatabase-
6826: * specific abstract data types, by using a driver-specific Java
6827: * type.
6828: *
6829: * If the object is of a class implementing the interface <code>SQLData</code>,
6830: * the JDBC driver should call the method <code>SQLData.writeSQL</code>
6831: * to write it to the SQL data stream.
6832: * If, on the other hand, the object is of a class implementing
6833: * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>, <code>NClob</code>,
6834: * <code>Struct</code>, <code>java.net.URL</code>,
6835: * or <code>Array</code>, the driver should pass it to the database as a
6836: * value of the corresponding SQL type.
6837: * <P>
6838: * This method throws an exception if there is an ambiguity, for example, if the
6839: * object is of a class implementing more than one of the interfaces named above.
6840: *
6841: * @param parameterName the name of the parameter
6842: * @param x the object containing the input parameter value
6843: * @exception SQLException if a database access error occurs,
6844: * this method is called on a closed <code>CallableStatement</code> or if the given
6845: * <code>Object</code> parameter is ambiguous
6846: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6847: * this method
6848: * @see #getObject
6849: * @since 1.4
6850: */
6851: public void setObject(String parameterName, Object x)
6852: throws SQLException {
6853: throw new SQLFeatureNotSupportedException(jdbcResBundle
6854: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6855: .toString());
6856: }
6857:
6858: /**
6859: * Sets the designated parameter to the given input stream, which will have
6860: * the specified number of bytes.
6861: * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
6862: * parameter, it may be more practical to send it via a
6863: * <code>java.io.InputStream</code>. Data will be read from the stream
6864: * as needed until end-of-file is reached. The JDBC driver will
6865: * do any necessary conversion from ASCII to the database char format.
6866: *
6867: * <P><B>Note:</B> This stream object can either be a standard
6868: * Java stream object or your own subclass that implements the
6869: * standard interface.
6870: *
6871: * @param parameterName the name of the parameter
6872: * @param x the Java input stream that contains the ASCII parameter value
6873: * @param length the number of bytes in the stream
6874: * @exception SQLException if a database access error occurs or
6875: * this method is called on a closed <code>CallableStatement</code>
6876: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6877: * this method
6878: * @since 1.4
6879: */
6880: public void setAsciiStream(String parameterName,
6881: java.io.InputStream x, int length) throws SQLException {
6882: throw new SQLFeatureNotSupportedException(jdbcResBundle
6883: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6884: .toString());
6885: }
6886:
6887: /**
6888: * Sets the designated parameter to the given input stream, which will have
6889: * the specified number of bytes.
6890: * When a very large binary value is input to a <code>LONGVARBINARY</code>
6891: * parameter, it may be more practical to send it via a
6892: * <code>java.io.InputStream</code> object. The data will be read from the stream
6893: * as needed until end-of-file is reached.
6894: *
6895: * <P><B>Note:</B> This stream object can either be a standard
6896: * Java stream object or your own subclass that implements the
6897: * standard interface.
6898: *
6899: * @param parameterName the name of the parameter
6900: * @param x the java input stream which contains the binary parameter value
6901: * @param length the number of bytes in the stream
6902: * @exception SQLException if a database access error occurs or
6903: * this method is called on a closed <code>CallableStatement</code>
6904: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6905: * this method
6906: * @since 1.4
6907: */
6908: public void setBinaryStream(String parameterName,
6909: java.io.InputStream x, int length) throws SQLException {
6910: throw new SQLFeatureNotSupportedException(jdbcResBundle
6911: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6912: .toString());
6913: }
6914:
6915: /**
6916: * Sets the designated parameter to the given <code>Reader</code>
6917: * object, which is the given number of characters long.
6918: * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
6919: * parameter, it may be more practical to send it via a
6920: * <code>java.io.Reader</code> object. The data will be read from the stream
6921: * as needed until end-of-file is reached. The JDBC driver will
6922: * do any necessary conversion from UNICODE to the database char format.
6923: *
6924: * <P><B>Note:</B> This stream object can either be a standard
6925: * Java stream object or your own subclass that implements the
6926: * standard interface.
6927: *
6928: * @param parameterName the name of the parameter
6929: * @param reader the <code>java.io.Reader</code> object that
6930: * contains the UNICODE data used as the designated parameter
6931: * @param length the number of characters in the stream
6932: * @exception SQLException if a database access error occurs or
6933: * this method is called on a closed <code>CallableStatement</code>
6934: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
6935: * this method
6936: * @since 1.4
6937: */
6938: public void setCharacterStream(String parameterName,
6939: java.io.Reader reader, int length) throws SQLException {
6940: throw new SQLFeatureNotSupportedException(jdbcResBundle
6941: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6942: .toString());
6943: }
6944:
6945: /**
6946: * Sets the designated parameter to the given input stream.
6947: * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
6948: * parameter, it may be more practical to send it via a
6949: * <code>java.io.InputStream</code>. Data will be read from the stream
6950: * as needed until end-of-file is reached. The JDBC driver will
6951: * do any necessary conversion from ASCII to the database char format.
6952: *
6953: * <P><B>Note:</B> This stream object can either be a standard
6954: * Java stream object or your own subclass that implements the
6955: * standard interface.
6956: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
6957: * it might be more efficient to use a version of
6958: * <code>setAsciiStream</code> which takes a length parameter.
6959: *
6960: * @param parameterName the name of the parameter
6961: * @param x the Java input stream that contains the ASCII parameter value
6962: * @exception SQLException if a database access error occurs or
6963: * this method is called on a closed <code>CallableStatement</code>
6964: * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
6965: * @since 1.6
6966: */
6967: public void setAsciiStream(String parameterName,
6968: java.io.InputStream x) throws SQLException {
6969: throw new SQLFeatureNotSupportedException(jdbcResBundle
6970: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6971: .toString());
6972: }
6973:
6974: /**
6975: * Sets the designated parameter to the given input stream.
6976: * When a very large binary value is input to a <code>LONGVARBINARY</code>
6977: * parameter, it may be more practical to send it via a
6978: * <code>java.io.InputStream</code> object. The data will be read from the
6979: * stream as needed until end-of-file is reached.
6980: *
6981: * <P><B>Note:</B> This stream object can either be a standard
6982: * Java stream object or your own subclass that implements the
6983: * standard interface.
6984: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
6985: * it might be more efficient to use a version of
6986: * <code>setBinaryStream</code> which takes a length parameter.
6987: *
6988: * @param parameterName the name of the parameter
6989: * @param x the java input stream which contains the binary parameter value
6990: * @exception SQLException if a database access error occurs or
6991: * this method is called on a closed <code>CallableStatement</code>
6992: * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
6993: * @since 1.6
6994: */
6995: public void setBinaryStream(String parameterName,
6996: java.io.InputStream x) throws SQLException {
6997: throw new SQLFeatureNotSupportedException(jdbcResBundle
6998: .handleGetObject("jdbcrowsetimpl.featnotsupp")
6999: .toString());
7000: }
7001:
7002: /**
7003: * Sets the designated parameter to the given <code>Reader</code>
7004: * object.
7005: * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
7006: * parameter, it may be more practical to send it via a
7007: * <code>java.io.Reader</code> object. The data will be read from the stream
7008: * as needed until end-of-file is reached. The JDBC driver will
7009: * do any necessary conversion from UNICODE to the database char format.
7010: *
7011: * <P><B>Note:</B> This stream object can either be a standard
7012: * Java stream object or your own subclass that implements the
7013: * standard interface.
7014: * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
7015: * it might be more efficient to use a version of
7016: * <code>setCharacterStream</code> which takes a length parameter.
7017: *
7018: * @param parameterName the name of the parameter
7019: * @param reader the <code>java.io.Reader</code> object that contains the
7020: * Unicode data
7021: * @exception SQLException if a database access error occurs or
7022: * this method is called on a closed <code>CallableStatement</code>
7023: * @throws SQLFeatureNotSupportedException if the JDBC driver does not support this method
7024: * @since 1.6
7025: */
7026: public void setCharacterStream(String parameterName,
7027: java.io.Reader reader) throws SQLException {
7028: throw new SQLFeatureNotSupportedException(jdbcResBundle
7029: .handleGetObject("jdbcrowsetimpl.featnotsupp")
7030: .toString());
7031: }
7032:
7033: /**
7034: * Sets the designated parameter to the given
7035: * <code>java.math.BigDecimal</code> value.
7036: * The driver converts this to an SQL <code>NUMERIC</code> value when
7037: * it sends it to the database.
7038: *
7039: * @param parameterName the name of the parameter
7040: * @param x the parameter value
7041: * @exception SQLException if a database access error occurs or
7042: * this method is called on a closed <code>CallableStatement</code>
7043: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
7044: * this method
7045: * @see #getBigDecimal
7046: * @since 1.4
7047: */
7048: public void setBigDecimal(String parameterName, BigDecimal x)
7049: throws SQLException {
7050: throw new SQLFeatureNotSupportedException(jdbcResBundle
7051: .handleGetObject("jdbcrowsetimpl.featnotsupp")
7052: .toString());
7053: }
7054:
7055: /**
7056: * Sets the designated parameter to the given Java <code>String</code> value.
7057: * The driver converts this
7058: * to an SQL <code>VARCHAR</code> or <code>LONGVARCHAR</code> value
7059: * (depending on the argument's
7060: * size relative to the driver's limits on <code>VARCHAR</code> values)
7061: * when it sends it to the database.
7062: *
7063: * @param parameterName the name of the parameter
7064: * @param x the parameter value
7065: * @exception SQLException if a database access error occurs or
7066: * this method is called on a closed <code>CallableStatement</code>
7067: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
7068: * this method
7069: * @see #getString
7070: * @since 1.4
7071: */
7072: public void setString(String parameterName, String x)
7073: throws SQLException {
7074: throw new SQLFeatureNotSupportedException(jdbcResBundle
7075: .handleGetObject("jdbcrowsetimpl.featnotsupp")
7076: .toString());
7077: }
7078:
7079: /**
7080: * Sets the designated parameter to the given Java array of bytes.
7081: * The driver converts this to an SQL <code>VARBINARY</code> or
7082: * <code>LONGVARBINARY</code> (depending on the argument's size relative
7083: * to the driver's limits on <code>VARBINARY</code> values) when it sends
7084: * it to the database.
7085: *
7086: * @param parameterName the name of the parameter
7087: * @param x the parameter value
7088: * @exception SQLException if a database access error occurs or
7089: * this method is called on a closed <code>CallableStatement</code>
7090: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
7091: * this method
7092: * @see #getBytes
7093: * @since 1.4
7094: */
7095: public void setBytes(String parameterName, byte x[])
7096: throws SQLException {
7097: throw new SQLFeatureNotSupportedException(jdbcResBundle
7098: .handleGetObject("jdbcrowsetimpl.featnotsupp")
7099: .toString());
7100: }
7101:
7102: /**
7103: * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value.
7104: * The driver
7105: * converts this to an SQL <code>TIMESTAMP</code> value when it sends it to the
7106: * database.
7107: *
7108: * @param parameterName the name of the parameter
7109: * @param x the parameter value
7110: * @exception SQLException if a database access error occurs or
7111: * this method is called on a closed <code>CallableStatement</code>
7112: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
7113: * this method
7114: * @see #getTimestamp
7115: * @since 1.4
7116: */
7117: public void setTimestamp(String parameterName, java.sql.Timestamp x)
7118: throws SQLException {
7119: throw new SQLFeatureNotSupportedException(jdbcResBundle
7120: .handleGetObject("jdbcrowsetimpl.featnotsupp")
7121: .toString());
7122: }
7123:
7124: /**
7125: * Sets the designated parameter to SQL <code>NULL</code>.
7126: *
7127: * <P><B>Note:</B> You must specify the parameter's SQL type.
7128: *
7129: * @param parameterName the name of the parameter
7130: * @param sqlType the SQL type code defined in <code>java.sql.Types</code>
7131: * @exception SQLException if a database access error occurs or
7132: * this method is called on a closed <code>CallableStatement</code>
7133: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
7134: * this method
7135: * @since 1.4
7136: */
7137: public void setNull(String parameterName, int sqlType)
7138: throws SQLException {
7139: throw new SQLFeatureNotSupportedException(jdbcResBundle
7140: .handleGetObject("jdbcrowsetimpl.featnotsupp")
7141: .toString());
7142: }
7143:
7144: /**
7145: * Sets the designated parameter to SQL <code>NULL</code>.
7146: * This version of the method <code>setNull</code> should
7147: * be used for user-defined types and REF type parameters. Examples
7148: * of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and
7149: * named array types.
7150: *
7151: * <P><B>Note:</B> To be portable, applications must give the
7152: * SQL type code and the fully-qualified SQL type name when specifying
7153: * a NULL user-defined or REF parameter. In the case of a user-defined type
7154: * the name is the type name of the parameter itself. For a REF
7155: * parameter, the name is the type name of the referenced type. If
7156: * a JDBC driver does not need the type code or type name information,
7157: * it may ignore it.
7158: *
7159: * Although it is intended for user-defined and Ref parameters,
7160: * this method may be used to set a null parameter of any JDBC type.
7161: * If the parameter does not have a user-defined or REF type, the given
7162: * typeName is ignored.
7163: *
7164: *
7165: * @param parameterName the name of the parameter
7166: * @param sqlType a value from <code>java.sql.Types</code>
7167: * @param typeName the fully-qualified name of an SQL user-defined type;
7168: * ignored if the parameter is not a user-defined type or
7169: * SQL <code>REF</code> value
7170: * @exception SQLException if a database access error occurs or
7171: * this method is called on a closed <code>CallableStatement</code>
7172: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
7173: * this method
7174: * @since 1.4
7175: */
7176: public void setNull(String parameterName, int sqlType,
7177: String typeName) throws SQLException {
7178: throw new SQLFeatureNotSupportedException(jdbcResBundle
7179: .handleGetObject("jdbcrowsetimpl.featnotsupp")
7180: .toString());
7181: }
7182:
7183: /**
7184: * Sets the designated parameter to the given Java <code>boolean</code> value.
7185: * The driver converts this
7186: * to an SQL <code>BIT</code> or <code>BOOLEAN</code> value when it sends it to the database.
7187: *
7188: * @param parameterName the name of the parameter
7189: * @param x the parameter value
7190: * @exception SQLException if a database access error occurs or
7191: * this method is called on a closed <code>CallableStatement</code>
7192: * @see #getBoolean
7193: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
7194: * this method
7195: * @since 1.4
7196: */
7197: public void setBoolean(String parameterName, boolean x)
7198: throws SQLException {
7199: throw new SQLFeatureNotSupportedException(jdbcResBundle
7200: .handleGetObject("jdbcrowsetimpl.featnotsupp")
7201: .toString());
7202: }
7203:
7204: /**
7205: * Sets the designated parameter to the given Java <code>byte</code> value.
7206: * The driver converts this
7207: * to an SQL <code>TINYINT</code> value when it sends it to the database.
7208: *
7209: * @param parameterName the name of the parameter
7210: * @param x the parameter value
7211: * @exception SQLException if a database access error occurs or
7212: * this method is called on a closed <code>CallableStatement</code>
7213: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
7214: * this method
7215: * @see #getByte
7216: * @since 1.4
7217: */
7218: public void setByte(String parameterName, byte x)
7219: throws SQLException {
7220: throw new SQLFeatureNotSupportedException(jdbcResBundle
7221: .handleGetObject("jdbcrowsetimpl.featnotsupp")
7222: .toString());
7223: }
7224:
7225: /**
7226: * Sets the designated parameter to the given Java <code>short</code> value.
7227: * The driver converts this
7228: * to an SQL <code>SMALLINT</code> value when it sends it to the database.
7229: *
7230: * @param parameterName the name of the parameter
7231: * @param x the parameter value
7232: * @exception SQLException if a database access error occurs or
7233: * this method is called on a closed <code>CallableStatement</code>
7234: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
7235: * this method
7236: * @see #getShort
7237: * @since 1.4
7238: */
7239: public void setShort(String parameterName, short x)
7240: throws SQLException {
7241: throw new SQLFeatureNotSupportedException(jdbcResBundle
7242: .handleGetObject("jdbcrowsetimpl.featnotsupp")
7243: .toString());
7244: }
7245:
7246: /**
7247: * Sets the designated parameter to the given Java <code>int</code> value.
7248: * The driver converts this
7249: * to an SQL <code>INTEGER</code> value when it sends it to the database.
7250: *
7251: * @param parameterName the name of the parameter
7252: * @param x the parameter value
7253: * @exception SQLException if a database access error occurs or
7254: * this method is called on a closed <code>CallableStatement</code>
7255: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
7256: * this method
7257: * @see #getInt
7258: * @since 1.4
7259: */
7260: public void setInt(String parameterName, int x) throws SQLException {
7261: throw new SQLFeatureNotSupportedException(jdbcResBundle
7262: .handleGetObject("jdbcrowsetimpl.featnotsupp")
7263: .toString());
7264: }
7265:
7266: /**
7267: * Sets the designated parameter to the given Java <code>long</code> value.
7268: * The driver converts this
7269: * to an SQL <code>BIGINT</code> value when it sends it to the database.
7270: *
7271: * @param parameterName the name of the parameter
7272: * @param x the parameter value
7273: * @exception SQLException if a database access error occurs or
7274: * this method is called on a closed <code>CallableStatement</code>
7275: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
7276: * this method
7277: * @see #getLong
7278: * @since 1.4
7279: */
7280: public void setLong(String parameterName, long x)
7281: throws SQLException {
7282: throw new SQLFeatureNotSupportedException(jdbcResBundle
7283: .handleGetObject("jdbcrowsetimpl.featnotsupp")
7284: .toString());
7285: }
7286:
7287: /**
7288: * Sets the designated parameter to the given Java <code>float</code> value.
7289: * The driver converts this
7290: * to an SQL <code>FLOAT</code> value when it sends it to the database.
7291: *
7292: * @param parameterName the name of the parameter
7293: * @param x the parameter value
7294: * @exception SQLException if a database access error occurs or
7295: * this method is called on a closed <code>CallableStatement</code>
7296: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
7297: * this method
7298: * @see #getFloat
7299: * @since 1.4
7300: */
7301: public void setFloat(String parameterName, float x)
7302: throws SQLException {
7303: throw new SQLFeatureNotSupportedException(jdbcResBundle
7304: .handleGetObject("jdbcrowsetimpl.featnotsupp")
7305: .toString());
7306: }
7307:
7308: /**
7309: * Sets the designated parameter to the given Java <code>double</code> value.
7310: * The driver converts this
7311: * to an SQL <code>DOUBLE</code> value when it sends it to the database.
7312: *
7313: * @param parameterName the name of the parameter
7314: * @param x the parameter value
7315: * @exception SQLException if a database access error occurs or
7316: * this method is called on a closed <code>CallableStatement</code>
7317: * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
7318: * this method
7319: * @see #getDouble
7320: * @since 1.4
7321: */
7322: public void setDouble(String parameterName, double x)
7323: throws SQLException {
7324: throw new SQLFeatureNotSupportedException(jdbcResBundle
7325: .handleGetObject("jdbcrowsetimpl.featnotsupp")
7326: .toString());
7327: }
7328:
7329: /**
7330: * This method re populates the resBundle
7331: * during the deserialization process
7332: *
7333: */
7334: protected void readObject(ObjectInputStream ois)
7335: throws IOException, ClassNotFoundException {
7336: // Default state initialization happens here
7337: ois.defaultReadObject();
7338: // Initialization of transient Res Bundle happens here .
7339: try {
7340: jdbcResBundle = JdbcRowSetResourceBundle
7341: .getJdbcRowSetResourceBundle();
7342: } catch (IOException ioe) {
7343: }
7344:
7345: }
7346:
7347: static final long serialVersionUID = -3591946023893483003L;
7348: }
|