Save This Page
Home » openjdk-7 » com.sun » rowset » [javadoc | source]
    1   /*
    2    * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
    3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    4    *
    5    * This code is free software; you can redistribute it and/or modify it
    6    * under the terms of the GNU General Public License version 2 only, as
    7    * published by the Free Software Foundation.  Oracle designates this
    8    * particular file as subject to the "Classpath" exception as provided
    9    * by Oracle in the LICENSE file that accompanied this code.
   10    *
   11    * This code is distributed in the hope that it will be useful, but WITHOUT
   12    * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   13    * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   14    * version 2 for more details (a copy is included in the LICENSE file that
   15    * accompanied this code).
   16    *
   17    * You should have received a copy of the GNU General Public License version
   18    * 2 along with this work; if not, write to the Free Software Foundation,
   19    * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   20    *
   21    * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   22    * or visit www.oracle.com if you need additional information or have any
   23    * questions.
   24    */
   25   
   26   package com.sun.rowset;
   27   
   28   import java.sql;
   29   import javax.sql;
   30   import javax.naming;
   31   import java.io;
   32   import java.math;
   33   import java.util;
   34   import java.beans;
   35   
   36   import javax.sql.rowset;
   37   
   38   /**
   39    * The standard implementation of the <code>JdbcRowSet</code> interface. See the interface
   40    * defintion for full behavior and implementation requirements.
   41    *
   42    * @author Jonathan Bruce, Amit Handa
   43    */
   44   
   45   public class JdbcRowSetImpl extends BaseRowSet implements JdbcRowSet, Joinable {
   46   
   47       /**
   48        * The <code>Connection</code> object that is this rowset's
   49        * current connection to the database.  This field is set
   50        * internally when the connection is established.
   51        */
   52       private Connection conn;
   53   
   54       /**
   55        * The <code>PreparedStatement</code> object that is this rowset's
   56        * current command.  This field is set internally when the method
   57        * <code>execute</code> creates the <code>PreparedStatement</code>
   58        * object.
   59        */
   60       private PreparedStatement ps;
   61   
   62       /**
   63        * The <code>ResultSet</code> object that is this rowset's
   64        * current result set.  This field is set internally when the method
   65        * <code>execute</code> executes the rowset's command and thereby
   66        * creates the rowset's <code>ResultSet</code> object.
   67        */
   68       private ResultSet rs;
   69   
   70       /**
   71        * The <code>RowSetMetaDataImpl</code> object that is contructed when
   72        * a <code>ResultSet</code> object is passed to the <code>JdbcRowSet</code>
   73        * constructor. This helps in constructing all metadata associated
   74        * with the <code>ResultSet</code> object using the setter methods of
   75        * <code>RowSetMetaDataImpl</code>.
   76        */
   77       private RowSetMetaDataImpl rowsMD;
   78   
   79       /**
   80        * The <code>ResultSetMetaData</code> object from which this
   81        * <code>RowSetMetaDataImpl</code> is formed and which  helps in getting
   82        * the metadata information.
   83        */
   84       private ResultSetMetaData resMD;
   85   
   86       /**
   87        * The property that helps to fire the property changed event when certain
   88        * properties are changed in the <code>JdbcRowSet</code> object. This property
   89        * is being added to satisfy Rave requirements.
   90        */
   91       private PropertyChangeSupport propertyChangeSupport;
   92   
   93       /**
   94        * The Vector holding the Match Columns
   95        */
   96       private Vector<Integer> iMatchColumns;
   97   
   98       /**
   99        * The Vector that will hold the Match Column names.
  100        */
  101       private Vector<String> strMatchColumns;
  102   
  103   
  104       protected transient JdbcRowSetResourceBundle resBundle;
  105   
  106       /**
  107        * Constructs a default <code>JdbcRowSet</code> object.
  108        * The new instance of <code>JdbcRowSet</code> will serve as a proxy
  109        * for the <code>ResultSet</code> object it creates, and by so doing,
  110        * it will make it possible to use the result set as a JavaBeans
  111        * component.
  112        * <P>
  113        * The following is true of a default <code>JdbcRowSet</code> instance:
  114        * <UL>
  115        *   <LI>Does not show deleted rows
  116        *   <LI>Has no time limit for how long a driver may take to
  117        *       execute the rowset's command
  118        *   <LI>Has no limit for the number of rows it may contain
  119        *   <LI>Has no limit for the number of bytes a column may contain
  120        *   <LI>Has a scrollable cursor and does not show changes
  121        *       made by others
  122        *   <LI>Will not see uncommitted data (make "dirty" reads)
  123        *   <LI>Has escape processing turned on
  124        *   <LI>Has its connection's type map set to <code>null</code>
  125        *   <LI>Has an empty <code>Hashtable</code> object for storing any
  126        *       parameters that are set
  127        * </UL>
  128        * A newly created <code>JdbcRowSet</code> object must have its
  129        * <code>execute</code> method invoked before other public methods
  130        * are called on it; otherwise, such method calls will cause an
  131        * exception to be thrown.
  132        *
  133        * @throws SQLException [1] if any of its public methods are called prior
  134        * to calling the <code>execute</code> method; [2] if invalid JDBC driver
  135        * properties are set or [3] if no connection to a data source exists.
  136        */
  137       public JdbcRowSetImpl() {
  138           conn = null;
  139           ps   = null;
  140           rs   = null;
  141   
  142           try {
  143              resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
  144           } catch(IOException ioe) {
  145               throw new RuntimeException(ioe);
  146           }
  147   
  148           propertyChangeSupport = new PropertyChangeSupport(this);
  149   
  150           initParams();
  151   
  152           // set the defaults
  153   
  154           try {
  155               setShowDeleted(false);
  156           } catch(SQLException sqle) {
  157                System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setshowdeleted").toString() +
  158                                   sqle.getLocalizedMessage());
  159           }
  160   
  161           try {
  162               setQueryTimeout(0);
  163           } catch(SQLException sqle) {
  164               System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setquerytimeout").toString() +
  165                                   sqle.getLocalizedMessage());
  166           }
  167   
  168           try {
  169               setMaxRows(0);
  170           } catch(SQLException sqle) {
  171               System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setmaxrows").toString() +
  172                                   sqle.getLocalizedMessage());
  173           }
  174   
  175           try {
  176               setMaxFieldSize(0);
  177           } catch(SQLException sqle) {
  178                System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setmaxfieldsize").toString() +
  179                                   sqle.getLocalizedMessage());
  180           }
  181   
  182           try {
  183               setEscapeProcessing(true);
  184           } catch(SQLException sqle) {
  185                System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setescapeprocessing").toString() +
  186                                   sqle.getLocalizedMessage());
  187           }
  188   
  189           try {
  190               setConcurrency(ResultSet.CONCUR_UPDATABLE);
  191           } catch (SQLException sqle) {
  192               System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setconcurrency").toString() +
  193                                   sqle.getLocalizedMessage());
  194           }
  195   
  196           setTypeMap(null);
  197   
  198           try {
  199               setType(ResultSet.TYPE_SCROLL_INSENSITIVE);
  200           } catch(SQLException sqle){
  201             System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.settype").toString() +
  202                                   sqle.getLocalizedMessage());
  203           }
  204   
  205           setReadOnly(true);
  206   
  207           try {
  208               setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
  209           } catch(SQLException sqle){
  210               System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.settransactionisolation").toString() +
  211                                   sqle.getLocalizedMessage());
  212           }
  213   
  214           //Instantiating the vector for MatchColumns
  215   
  216           iMatchColumns = new Vector<Integer>(10);
  217           for(int i = 0; i < 10 ; i++) {
  218              iMatchColumns.add(i,Integer.valueOf(-1));
  219           }
  220   
  221           strMatchColumns = new Vector<String>(10);
  222           for(int j = 0; j < 10; j++) {
  223              strMatchColumns.add(j,null);
  224           }
  225       }
  226   
  227       /**
  228        * Constructs a default <code>JdbcRowSet</code> object given a
  229        * valid <code>Connection</code> object. The new
  230        * instance of <code>JdbcRowSet</code> will serve as a proxy for
  231        * the <code>ResultSet</code> object it creates, and by so doing,
  232        * it will make it possible to use the result set as a JavaBeans
  233        * component.
  234        * <P>
  235        * The following is true of a default <code>JdbcRowSet</code> instance:
  236        * <UL>
  237        *   <LI>Does not show deleted rows
  238        *   <LI>Has no time limit for how long a driver may take to
  239        *       execute the rowset's command
  240        *   <LI>Has no limit for the number of rows it may contain
  241        *   <LI>Has no limit for the number of bytes a column may contain
  242        *   <LI>Has a scrollable cursor and does not show changes
  243        *       made by others
  244        *   <LI>Will not see uncommitted data (make "dirty" reads)
  245        *   <LI>Has escape processing turned on
  246        *   <LI>Has its connection's type map set to <code>null</code>
  247        *   <LI>Has an empty <code>Hashtable</code> object for storing any
  248        *       parameters that are set
  249        * </UL>
  250        * A newly created <code>JdbcRowSet</code> object must have its
  251        * <code>execute</code> method invoked before other public methods
  252        * are called on it; otherwise, such method calls will cause an
  253        * exception to be thrown.
  254        *
  255        * @throws SQLException [1] if any of its public methods are called prior
  256        * to calling the <code>execute</code> method, [2] if invalid JDBC driver
  257        * properties are set, or [3] if no connection to a data source exists.
  258        */
  259       public JdbcRowSetImpl(Connection con) throws SQLException {
  260   
  261           conn = con;
  262           ps = null;
  263           rs = null;
  264   
  265           try {
  266              resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
  267           } catch(IOException ioe) {
  268               throw new RuntimeException(ioe);
  269           }
  270   
  271           propertyChangeSupport = new PropertyChangeSupport(this);
  272   
  273           initParams();
  274           // set the defaults
  275           setShowDeleted(false);
  276           setQueryTimeout(0);
  277           setMaxRows(0);
  278           setMaxFieldSize(0);
  279   
  280           setParams();
  281   
  282           setReadOnly(true);
  283           setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
  284           setEscapeProcessing(true);
  285           setTypeMap(null);
  286   
  287           //Instantiating the vector for MatchColumns
  288   
  289           iMatchColumns = new Vector<Integer>(10);
  290           for(int i = 0; i < 10 ; i++) {
  291              iMatchColumns.add(i,Integer.valueOf(-1));
  292           }
  293   
  294           strMatchColumns = new Vector<String>(10);
  295           for(int j = 0; j < 10; j++) {
  296              strMatchColumns.add(j,null);
  297           }
  298       }
  299   
  300       /**
  301        * Constructs a default <code>JdbcRowSet</code> object using the
  302        * URL, username, and password arguments supplied. The new
  303        * instance of <code>JdbcRowSet</code> will serve as a proxy for
  304        * the <code>ResultSet</code> object it creates, and by so doing,
  305        * it will make it possible to use the result set as a JavaBeans
  306        * component.
  307        *
  308        * <P>
  309        * The following is true of a default <code>JdbcRowSet</code> instance:
  310        * <UL>
  311        *   <LI>Does not show deleted rows
  312        *   <LI>Has no time limit for how long a driver may take to
  313        *       execute the rowset's command
  314        *   <LI>Has no limit for the number of rows it may contain
  315        *   <LI>Has no limit for the number of bytes a column may contain
  316        *   <LI>Has a scrollable cursor and does not show changes
  317        *       made by others
  318        *   <LI>Will not see uncommitted data (make "dirty" reads)
  319        *   <LI>Has escape processing turned on
  320        *   <LI>Has its connection's type map set to <code>null</code>
  321        *   <LI>Has an empty <code>Hashtable</code> object for storing any
  322        *       parameters that are set
  323        * </UL>
  324        *
  325        * @param url - a JDBC URL for the database to which this <code>JdbcRowSet</code>
  326        *        object will be connected. The form for a JDBC URL is
  327        *        <code>jdbc:subprotocol:subname</code>.
  328        * @param user - the database user on whose behalf the connection
  329        *        is being made
  330        * @param password - the user's password
  331        *
  332        * @throws SQLException if a database access error occurs
  333        *
  334        */
  335       public JdbcRowSetImpl(String url, String user, String password) throws SQLException {
  336           conn = null;
  337           ps = null;
  338           rs = null;
  339   
  340           try {
  341              resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
  342           } catch(IOException ioe) {
  343               throw new RuntimeException(ioe);
  344           }
  345   
  346           propertyChangeSupport = new PropertyChangeSupport(this);
  347   
  348           initParams();
  349   
  350           // Pass the arguments to BaseRowSet
  351           // setter methods now.
  352   
  353           setUsername(user);
  354           setPassword(password);
  355           setUrl(url);
  356   
  357           // set the defaults
  358           setShowDeleted(false);
  359           setQueryTimeout(0);
  360           setMaxRows(0);
  361           setMaxFieldSize(0);
  362   
  363           // to ensure connection to a db call connect now
  364           // and associate a conn with "this" object
  365           // in this case.
  366           conn = connect();
  367           setParams();
  368   
  369           setReadOnly(true);
  370           setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
  371           setEscapeProcessing(true);
  372           setTypeMap(null);
  373   
  374           //Instantiating the vector for MatchColumns
  375   
  376           iMatchColumns = new Vector<Integer>(10);
  377           for(int i = 0; i < 10 ; i++) {
  378              iMatchColumns.add(i,Integer.valueOf(-1));
  379           }
  380   
  381           strMatchColumns = new Vector<String>(10);
  382           for(int j = 0; j < 10; j++) {
  383              strMatchColumns.add(j,null);
  384           }
  385       }
  386   
  387   
  388       /**
  389        * Constructs a <code>JdbcRowSet</code> object using the given valid
  390        * <code>ResultSet</code> object. The new
  391        * instance of <code>JdbcRowSet</code> will serve as a proxy for
  392        * the <code>ResultSet</code> object, and by so doing,
  393        * it will make it possible to use the result set as a JavaBeans
  394        * component.
  395        *
  396        * <P>
  397        * The following is true of a default <code>JdbcRowSet</code> instance:
  398        * <UL>
  399        *   <LI>Does not show deleted rows
  400        *   <LI>Has no time limit for how long a driver may take to
  401        *       execute the rowset's command
  402        *   <LI>Has no limit for the number of rows it may contain
  403        *   <LI>Has no limit for the number of bytes a column may contain
  404        *   <LI>Has a scrollable cursor and does not show changes
  405        *       made by others
  406        *   <LI>Will not see uncommitted data (make "dirty" reads)
  407        *   <LI>Has escape processing turned on
  408        *   <LI>Has its connection's type map set to <code>null</code>
  409        *   <LI>Has an empty <code>Hashtable</code> object for storing any
  410        *       parameters that are set
  411        * </UL>
  412        *
  413        * @param res a valid <code>ResultSet</code> object
  414        *
  415        * @throws SQLException if a database access occurs due to a non
  416        * valid ResultSet handle.
  417        */
  418       public JdbcRowSetImpl(ResultSet res) throws SQLException {
  419   
  420           // A ResultSet handle encapsulates a connection handle.
  421           // But there is no way we can retrieve a Connection handle
  422           // from a ResultSet object.
  423           // So to avoid any anomalies we keep the conn = null
  424           // The passed rs handle will be a wrapper around for
  425           // "this" object's all operations.
  426           conn = null;
  427   
  428           ps = null;
  429   
  430           rs = res;
  431   
  432           try {
  433              resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
  434           } catch(IOException ioe) {
  435               throw new RuntimeException(ioe);
  436           }
  437   
  438           propertyChangeSupport = new PropertyChangeSupport(this);
  439   
  440           initParams();
  441   
  442           // get the values from the resultset handle.
  443           setShowDeleted(false);
  444           setQueryTimeout(0);
  445           setMaxRows(0);
  446           setMaxFieldSize(0);
  447   
  448           setParams();
  449   
  450           setReadOnly(true);
  451           setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
  452           setEscapeProcessing(true);
  453           setTypeMap(null);
  454   
  455           // Get a handle to ResultSetMetaData
  456           // Construct RowSetMetaData out of it.
  457   
  458           resMD = rs.getMetaData();
  459   
  460           rowsMD = new RowSetMetaDataImpl();
  461   
  462           initMetaData(rowsMD, resMD);
  463   
  464           //Instantiating the vector for MatchColumns
  465   
  466           iMatchColumns = new Vector<Integer>(10);
  467           for(int i = 0; i < 10 ; i++) {
  468              iMatchColumns.add(i,Integer.valueOf(-1));
  469           }
  470   
  471           strMatchColumns = new Vector<String>(10);
  472           for(int j = 0; j < 10; j++) {
  473              strMatchColumns.add(j,null);
  474           }
  475       }
  476   
  477       /**
  478        * Initializes the given <code>RowSetMetaData</code> object with the values
  479        * in the given <code>ResultSetMetaData</code> object.
  480        *
  481        * @param md the <code>RowSetMetaData</code> object for this
  482        *           <code>JdbcRowSetImpl</code> object, which will be set with
  483        *           values from rsmd
  484        * @param rsmd the <code>ResultSetMetaData</code> object from which new
  485        *             values for md will be read
  486        * @throws SQLException if an error occurs
  487        */
  488       protected void initMetaData(RowSetMetaData md, ResultSetMetaData rsmd) throws SQLException {
  489           int numCols = rsmd.getColumnCount();
  490   
  491           md.setColumnCount(numCols);
  492           for (int col=1; col <= numCols; col++) {
  493               md.setAutoIncrement(col, rsmd.isAutoIncrement(col));
  494               md.setCaseSensitive(col, rsmd.isCaseSensitive(col));
  495               md.setCurrency(col, rsmd.isCurrency(col));
  496               md.setNullable(col, rsmd.isNullable(col));
  497               md.setSigned(col, rsmd.isSigned(col));
  498               md.setSearchable(col, rsmd.isSearchable(col));
  499               md.setColumnDisplaySize(col, rsmd.getColumnDisplaySize(col));
  500               md.setColumnLabel(col, rsmd.getColumnLabel(col));
  501               md.setColumnName(col, rsmd.getColumnName(col));
  502               md.setSchemaName(col, rsmd.getSchemaName(col));
  503               md.setPrecision(col, rsmd.getPrecision(col));
  504               md.setScale(col, rsmd.getScale(col));
  505               md.setTableName(col, rsmd.getTableName(col));
  506               md.setCatalogName(col, rsmd.getCatalogName(col));
  507               md.setColumnType(col, rsmd.getColumnType(col));
  508               md.setColumnTypeName(col, rsmd.getColumnTypeName(col));
  509           }
  510       }
  511   
  512   
  513       protected void checkState() throws SQLException {
  514   
  515           // If all the three i.e.  conn, ps & rs are
  516           // simultaneously null implies we are not connected
  517           // to the db, implies undesirable state so throw exception
  518   
  519           if (conn == null && ps == null && rs == null ) {
  520               throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.invalstate").toString());
  521           }
  522       }
  523   
  524       //---------------------------------------------------------------------
  525       // Reading and writing data
  526       //---------------------------------------------------------------------
  527   
  528       /**
  529        * Creates the internal <code>ResultSet</code> object for which this
  530        * <code>JdbcRowSet</code> object is a wrapper, effectively
  531        * making the result set a JavaBeans component.
  532        * <P>
  533        * Certain properties must have been set before this method is called
  534        * so that it can establish a connection to a database and execute the
  535        * query that will create the result set.  If a <code>DataSource</code>
  536        * object will be used to create the connection, properties for the
  537        * data source name, user name, and password must be set.  If the
  538        * <code>DriverManager</code> will be used, the properties for the
  539        * URL, user name, and password must be set.  In either case, the
  540        * property for the command must be set.  If the command has placeholder
  541        * parameters, those must also be set. This method throws
  542        * an exception if the required properties are not set.
  543        * <P>
  544        * Other properties have default values that may optionally be set
  545        * to new values. The <code>execute</code> method will use the value
  546        * for the command property to create a <code>PreparedStatement</code>
  547        * object and set its properties (escape processing, maximum field
  548        * size, maximum number of rows, and query timeout limit) to be those
  549        * of this rowset.
  550        *
  551        * @throws SQLException if (1) a database access error occurs,
  552        * (2) any required JDBC properties are not set, or (3) if an
  553        * invalid connection exists.
  554        */
  555       public void execute() throws SQLException {
  556           /*
  557            * To execute based on the properties:
  558            * i) determine how to get a connection
  559            * ii) prepare the statement
  560            * iii) set the properties of the statement
  561            * iv) parse the params. and set them
  562            * v) execute the statement
  563            *
  564            * During all of this try to tolerate as many errors
  565            * as possible, many drivers will not support all of
  566            * the properties and will/should throw SQLException
  567            * at us...
  568            *
  569            */
  570   
  571           prepare();
  572   
  573           // set the properties of our shiny new statement
  574           setProperties(ps);
  575   
  576   
  577           // set the parameters
  578           decodeParams(getParams(), ps);
  579   
  580   
  581           // execute the statement
  582           rs = ps.executeQuery();
  583   
  584   
  585           // notify listeners
  586           notifyRowSetChanged();
  587   
  588   
  589       }
  590   
  591       protected void setProperties(PreparedStatement ps) throws SQLException {
  592   
  593           try {
  594               ps.setEscapeProcessing(getEscapeProcessing());
  595           } catch (SQLException ex) {
  596               System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setescapeprocessing").toString() +
  597                                   ex.getLocalizedMessage());
  598           }
  599   
  600           try {
  601               ps.setMaxFieldSize(getMaxFieldSize());
  602           } catch (SQLException ex) {
  603               System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setmaxfieldsize").toString() +
  604                                   ex.getLocalizedMessage());
  605           }
  606   
  607           try {
  608               ps.setMaxRows(getMaxRows());
  609           } catch (SQLException ex) {
  610              System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setmaxrows").toString() +
  611                                   ex.getLocalizedMessage());
  612           }
  613   
  614           try {
  615               ps.setQueryTimeout(getQueryTimeout());
  616           } catch (SQLException ex) {
  617              System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.setquerytimeout").toString() +
  618                                   ex.getLocalizedMessage());
  619           }
  620   
  621       }
  622   
  623       // An alternate solution is required instead of having the
  624       // connect method as protected.
  625       // This is a work around to assist Rave Team
  626       // :ah
  627   
  628       protected Connection connect() throws SQLException {
  629   
  630           // Get a JDBC connection.
  631   
  632           // First check for Connection handle object as such if
  633           // "this" initialized  using conn.
  634   
  635           if(conn != null) {
  636               return conn;
  637   
  638           } else if (getDataSourceName() != null) {
  639   
  640               // Connect using JNDI.
  641               try {
  642                   Context ctx = new InitialContext();
  643                   DataSource ds = (DataSource)ctx.lookup
  644                       (getDataSourceName());
  645                   //return ds.getConnection(getUsername(),getPassword());
  646   
  647                   if(getUsername() != null && !getUsername().equals("")) {
  648                        return ds.getConnection(getUsername(),getPassword());
  649                   } else {
  650                        return ds.getConnection();
  651                   }
  652               }
  653               catch (javax.naming.NamingException ex) {
  654                   throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.connect").toString());
  655               }
  656   
  657           } else if (getUrl() != null) {
  658               // Check only for getUrl() != null because
  659               // user, passwd can be null
  660               // Connect using the driver manager.
  661   
  662               return DriverManager.getConnection
  663                       (getUrl(), getUsername(), getPassword());
  664           }
  665           else {
  666               return null;
  667           }
  668   
  669       }
  670   
  671   
  672       protected PreparedStatement prepare() throws SQLException {
  673           // get a connection
  674           conn = connect();
  675   
  676           try {
  677   
  678               Map<String, Class<?>> aMap = getTypeMap();
  679               if( aMap != null) {
  680                   conn.setTypeMap(aMap);
  681               }
  682               ps = conn.prepareStatement(getCommand(),ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
  683           } catch (SQLException ex) {
  684               System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.prepare").toString() +
  685                                   ex.getLocalizedMessage());
  686   
  687               if (ps != null)
  688                   ps.close();
  689               if (conn != null)
  690                   conn.close();
  691   
  692               throw new SQLException(ex.getMessage());
  693           }
  694   
  695           return ps;
  696       }
  697   
  698       private void decodeParams(Object[] params, PreparedStatement ps)
  699       throws SQLException {
  700   
  701       // There is a corresponding decodeParams in JdbcRowSetImpl
  702       // which does the same as this method. This is a design flaw.
  703       // Update the CachedRowsetReader.decodeParams when you update
  704       // this method.
  705   
  706       // Adding the same comments to CachedRowsetReader.decodeParams.
  707   
  708           int arraySize;
  709           Object[] param = null;
  710   
  711           for (int i=0; i < params.length; i++) {
  712               if (params[i] instanceof Object[]) {
  713                   param = (Object[])params[i];
  714   
  715                   if (param.length == 2) {
  716                       if (param[0] == null) {
  717                           ps.setNull(i + 1, ((Integer)param[1]).intValue());
  718                           continue;
  719                       }
  720   
  721                       if (param[0] instanceof java.sql.Date ||
  722                           param[0] instanceof java.sql.Time ||
  723                           param[0] instanceof java.sql.Timestamp) {
  724                           System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.detecteddate"));
  725                           if (param[1] instanceof java.util.Calendar) {
  726                               System.err.println(resBundle.handleGetObject("jdbcrowsetimpl.detectedcalendar"));
  727                               ps.setDate(i + 1, (java.sql.Date)param[0],
  728                                          (java.util.Calendar)param[1]);
  729                               continue;
  730                           }
  731                           else {
  732                               throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.paramtype").toString());
  733                           }
  734                       }
  735   
  736                       if (param[0] instanceof Reader) {
  737                           ps.setCharacterStream(i + 1, (Reader)param[0],
  738                                                 ((Integer)param[1]).intValue());
  739                           continue;
  740                       }
  741   
  742                       /*
  743                        * What's left should be setObject(int, Object, scale)
  744                        */
  745                       if (param[1] instanceof Integer) {
  746                           ps.setObject(i + 1, param[0], ((Integer)param[1]).intValue());
  747                           continue;
  748                       }
  749   
  750                   } else if (param.length == 3) {
  751   
  752                       if (param[0] == null) {
  753                           ps.setNull(i + 1, ((Integer)param[1]).intValue(),
  754                                      (String)param[2]);
  755                           continue;
  756                       }
  757   
  758                       if (param[0] instanceof java.io.InputStream) {
  759                           switch (((Integer)param[2]).intValue()) {
  760                           case JdbcRowSetImpl.UNICODE_STREAM_PARAM:
  761                               ps.setUnicodeStream(i + 1,
  762                                                   (java.io.InputStream)param[0],
  763                                                   ((Integer)param[1]).intValue());
  764                           case JdbcRowSetImpl.BINARY_STREAM_PARAM:
  765                               ps.setBinaryStream(i + 1,
  766                                                  (java.io.InputStream)param[0],
  767                                                  ((Integer)param[1]).intValue());
  768                           case JdbcRowSetImpl.ASCII_STREAM_PARAM:
  769                               ps.setAsciiStream(i + 1,
  770                                                 (java.io.InputStream)param[0],
  771                                                 ((Integer)param[1]).intValue());
  772                           default:
  773                               throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.paramtype").toString());
  774                           }
  775                       }
  776   
  777                       /*
  778                        * no point at looking at the first element now;
  779                        * what's left must be the setObject() cases.
  780                        */
  781                       if (param[1] instanceof Integer && param[2] instanceof Integer) {
  782                           ps.setObject(i + 1, param[0], ((Integer)param[1]).intValue(),
  783                                        ((Integer)param[2]).intValue());
  784                           continue;
  785                       }
  786   
  787                       throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.paramtype").toString());
  788   
  789                   } else {
  790                       // common case - this catches all SQL92 types
  791                       ps.setObject(i + 1, params[i]);
  792                       continue;
  793                   }
  794               }  else {
  795                  // Try to get all the params to be set here
  796                  ps.setObject(i + 1, params[i]);
  797   
  798               }
  799           }
  800       }
  801   
  802       /**
  803        * Moves the cursor for this rowset's <code>ResultSet</code>
  804        * object down one row from its current position.
  805        * A <code>ResultSet</code> cursor is initially positioned
  806        * before the first row; the first call to the method
  807        * <code>next</code> makes the first row the current row; the
  808        * second call makes the second row the current row, and so on.
  809        *
  810        * <P>If an input stream is open for the current row, a call
  811        * to the method <code>next</code> will
  812        * implicitly close it. A <code>ResultSet</code> object's
  813        * warning chain is cleared when a new row is read.
  814        *
  815        * @return <code>true</code> if the new current row is valid;
  816        *         <code>false</code> if there are no more rows
  817        * @throws SQLException if a database access error occurs
  818        *            or this rowset does not currently have a valid connection,
  819        *            prepared statement, and result set
  820        */
  821       public boolean next() throws SQLException {
  822           checkState();
  823   
  824           boolean b = rs.next();
  825           notifyCursorMoved();
  826           return b;
  827       }
  828   
  829       /**
  830        * Releases this rowset's <code>ResultSet</code> object's database and
  831        * JDBC resources immediately instead of waiting for
  832        * this to happen when it is automatically closed.
  833        *
  834        * <P><B>Note:</B> A <code>ResultSet</code> object
  835        * is automatically closed by the
  836        * <code>Statement</code> object that generated it when
  837        * that <code>Statement</code> object is closed,
  838        * re-executed, or is used to retrieve the next result from a
  839        * sequence of multiple results. A <code>ResultSet</code> object
  840        * is also automatically closed when it is garbage collected.
  841        *
  842        * @throws SQLException if a database access error occurs
  843        */
  844       public void close() throws SQLException {
  845           if (rs != null)
  846               rs.close();
  847           if (ps != null)
  848               ps.close();
  849           if (conn != null)
  850               conn.close();
  851       }
  852   
  853       /**
  854        * Reports whether the last column read from this rowset's
  855        * <code>ResultSet</code> object had a value of SQL <code>NULL</code>.
  856        * Note that you must first call one of the <code>getXXX</code> methods
  857        * on a column to try to read its value and then call
  858        * the method <code>wasNull</code> to see if the value read was
  859        * SQL <code>NULL</code>.
  860        *
  861        * @return <code>true</code> if the last column value read was SQL
  862        *         <code>NULL</code> and <code>false</code> otherwise
  863        * @throws SQLException if a database access error occurs
  864        *            or this rowset does not have a currently valid connection,
  865        *            prepared statement, and result set
  866        */
  867       public boolean wasNull() throws SQLException {
  868           checkState();
  869   
  870           return rs.wasNull();
  871       }
  872   
  873       //======================================================================
  874       // Methods for accessing results by column index
  875       //======================================================================
  876   
  877       /**
  878        * Gets the value of the designated column in the current row
  879        * of this rowset's <code>ResultSet</code> object as
  880        * a <code>String</code>.
  881        *
  882        * @param columnIndex the first column is 1, the second is 2, and so on
  883        * @return the column value; if the value is SQL <code>NULL</code>, the
  884        * value returned is <code>null</code>
  885        * @throws SQLException if (1) a database access error occurs
  886        *            or (2) this rowset does not currently have a valid connection,
  887        *            prepared statement, and result set
  888        */
  889       public String getString(int columnIndex) throws SQLException {
  890           checkState();
  891   
  892           return rs.getString(columnIndex);
  893       }
  894   
  895       /**
  896        * Gets the value of the designated column in the current row
  897        * of this rowset's <code>ResultSet</code> object as
  898        * a <code>boolean</code>.
  899        *
  900        * @param columnIndex the first column is 1, the second is 2, and so on
  901        * @return the column value; if the value is SQL <code>NULL</code>, the
  902        * value returned is <code>false</code>
  903        * @throws SQLException if (1) a database access error occurs
  904        *            or (2) this rowset does not have a currently valid connection,
  905        *            prepared statement, and result set
  906        */
  907       public boolean getBoolean(int columnIndex) throws SQLException {
  908           checkState();
  909   
  910           return rs.getBoolean(columnIndex);
  911       }
  912   
  913       /**
  914        * Gets the value of the designated column in the current row
  915        * of this rowset's <code>ResultSet</code> object as
  916        * a <code>byte</code>.
  917        *
  918        * @param columnIndex the first column is 1, the second is 2, and so on
  919        * @return the column value; if the value is SQL <code>NULL</code>, the
  920        * value returned is <code>0</code>
  921        * @throws SQLException if (1) a database access error occurs
  922        *            or (2) this rowset does not have a currently valid connection,
  923        *            prepared statement, and result set
  924        */
  925       public byte getByte(int columnIndex) throws SQLException {
  926           checkState();
  927   
  928           return rs.getByte(columnIndex);
  929       }
  930   
  931       /**
  932        * Gets the value of the designated column in the current row
  933        * of this rowset's <code>ResultSet</code> object as
  934        * a <code>short</code>.
  935        *
  936        * @param columnIndex the first column is 1, the second is 2, and so on
  937        * @return the column value; if the value is SQL <code>NULL</code>, the
  938        * value returned is <code>0</code>
  939        * @throws SQLException if (1) a database access error occurs
  940        *            or (2) this rowset does not have a currently valid connection,
  941        *            prepared statement, and result set
  942        */
  943       public short getShort(int columnIndex) throws SQLException {
  944           checkState();
  945   
  946           return rs.getShort(columnIndex);
  947       }
  948   
  949       /**
  950        * Gets the value of the designated column in the current row
  951        * of this rowset's <code>ResultSet</code> object as
  952        * an <code>int</code>.
  953        *
  954        * @param columnIndex the first column is 1, the second is 2, and so on
  955        * @return the column value; if the value is SQL <code>NULL</code>, the
  956        * value returned is <code>0</code>
  957        * @throws SQLException if (1) a database access error occurs
  958        *            or (2) this rowset does not have a currently valid connection,
  959        *            prepared statement, and result set
  960        */
  961       public int getInt(int columnIndex) throws SQLException {
  962           checkState();
  963   
  964           return rs.getInt(columnIndex);
  965       }
  966   
  967       /**
  968        * Gets the value of the designated column in the current row
  969        * of this rowset's <code>ResultSet</code> object as
  970        * a <code>long</code>.
  971        *
  972        * @param columnIndex the first column is 1, the second is 2, and so on
  973        * @return the column value; if the value is SQL <code>NULL</code>, the
  974        * value returned is <code>0</code>
  975        * @throws SQLException if (1) a database access error occurs
  976        *            or (2) this rowset does not have a currently valid connection,
  977        *            prepared statement, and result set
  978        */
  979       public long getLong(int columnIndex) throws SQLException {
  980           checkState();
  981   
  982           return rs.getLong(columnIndex);
  983       }
  984   
  985       /**
  986        * Gets the value of the designated column in the current row
  987        * of this rowset's <code>ResultSet</code> object as
  988        * a <code>float</code>.
  989        *
  990        * @param columnIndex the first column is 1, the second is 2, and so on
  991        * @return the column value; if the value is SQL <code>NULL</code>, the
  992        * value returned is <code>0</code>
  993        * @throws SQLException if (1) a database access error occurs
  994        *            or (2) this rowset does not have a currently valid connection,
  995        *            prepared statement, and result set
  996        */
  997       public float getFloat(int columnIndex) throws SQLException {
  998           checkState();
  999   
 1000           return rs.getFloat(columnIndex);
 1001       }
 1002   
 1003       /**
 1004        * Gets the value of the designated column in the current row
 1005        * of this rowset's <code>ResultSet</code> object as
 1006        * a <code>double</code>.
 1007        *
 1008        * @param columnIndex the first column is 1, the second is 2, and so on
 1009        * @return the column value; if the value is SQL <code>NULL</code>, the
 1010        * value returned is <code>0</code>
 1011        * @throws SQLException if (1) a database access error occurs
 1012        *            or (2) this rowset does not have a currently valid connection,
 1013        *            prepared statement, and result set
 1014        */
 1015       public double getDouble(int columnIndex) throws SQLException {
 1016           checkState();
 1017   
 1018           return rs.getDouble(columnIndex);
 1019       }
 1020   
 1021       /**
 1022        * Gets the value of the designated column in the current row
 1023        * of this rowset's <code>ResultSet</code> object as
 1024        * a <code>java.sql.BigDecimal</code>.
 1025        *
 1026        * @param columnIndex the first column is 1, the second is 2, and so on
 1027        * @param scale the number of digits to the right of the decimal point
 1028        * @return the column value; if the value is SQL <code>NULL</code>, the
 1029        * value returned is <code>null</code>
 1030        * @throws SQLException if (1) database access error occurs
 1031        *            or (2) this rowset does not have a currently valid connection,
 1032        *            prepared statement, and result set
 1033        * @deprecated
 1034        */
 1035       public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
 1036           checkState();
 1037   
 1038           return rs.getBigDecimal(columnIndex, scale);
 1039       }
 1040   
 1041       /**
 1042        * Gets the value of the designated column in the current row
 1043        * of this rowset's <code>ResultSet</code> object as
 1044        * a <code>byte</code> array in the Java programming language.
 1045        * The bytes represent the raw values returned by the driver.
 1046        *
 1047        * @param columnIndex the first column is 1, the second is 2, and so on
 1048        * @return the column value; if the value is SQL <code>NULL</code>, the
 1049        * value returned is <code>null</code>
 1050        * @throws SQLException if (1) a database access error occurs
 1051        *            or (2) this rowset does not have a currently valid connection,
 1052        *            prepared statement, and result set
 1053        */
 1054       public byte[] getBytes(int columnIndex) throws SQLException {
 1055           checkState();
 1056   
 1057           return rs.getBytes(columnIndex);
 1058       }
 1059   
 1060       /**
 1061        * Gets the value of the designated column in the current row
 1062        * of this rowset's <code>ResultSet</code> object as
 1063        * a <code>java.sql.Date</code> object in the Java programming language.
 1064        *
 1065        * @param columnIndex the first column is 1, the second is 2, and so on
 1066        * @return the column value; if the value is SQL <code>NULL</code>, the
 1067        * value returned is <code>null</code>
 1068        * @throws SQLException if (1) a database access error occurs
 1069        *            or (2) this rowset does not have a currently valid connection,
 1070        *            prepared statement, and result set
 1071        */
 1072       public java.sql.Date getDate(int columnIndex) throws SQLException {
 1073           checkState();
 1074   
 1075           return rs.getDate(columnIndex);
 1076       }
 1077   
 1078       /**
 1079        * Gets the value of the designated column in the current row
 1080        * of this rowset's <code>ResultSet</code> object as
 1081        * a <code>java.sql.Time</code> object in the Java programming language.
 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 java.sql.Time getTime(int columnIndex) throws SQLException {
 1091           checkState();
 1092   
 1093           return rs.getTime(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.Timestamp</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.Timestamp getTimestamp(int columnIndex) throws SQLException {
 1109           checkState();
 1110   
 1111           return rs.getTimestamp(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 stream of ASCII characters. The value can then be read in chunks from the
 1118        * stream. This method is particularly
 1119        * suitable for retrieving large <code>LONGVARCHAR</code> values.
 1120        * The JDBC driver will
 1121        * do any necessary conversion from the database format into ASCII.
 1122        *
 1123        * <P><B>Note:</B> All the data in the returned stream must be
 1124        * read prior to getting the value of any other column. The next
 1125        * call to a <code>getXXX</code> method implicitly closes the stream.  Also, a
 1126        * stream may return <code>0</code> when the method
 1127        * <code>InputStream.available</code>
 1128        * is called whether there is data available or not.
 1129        *
 1130        * @param columnIndex the first column is 1, the second is 2, and so on
 1131        * @return a Java input stream that delivers the database column value
 1132        * as a stream of one-byte ASCII characters;
 1133        * if the value is SQL <code>NULL</code>, the
 1134        * value returned is <code>null</code>
 1135        * @throws SQLException if (1) database access error occurs
 1136        *            (2) this rowset does not have a currently valid connection,
 1137        *            prepared statement, and result set
 1138        */
 1139       public java.io.InputStream getAsciiStream(int columnIndex) throws SQLException {
 1140           checkState();
 1141   
 1142           return rs.getAsciiStream(columnIndex);
 1143       }
 1144   
 1145       /**
 1146        * Gets the value of the designated column in the current row
 1147        * of this rowset's <code>ResultSet</code> object as
 1148        * as a stream of Unicode characters.
 1149        * The value can then be read in chunks from the
 1150        * stream. This method is particularly
 1151        * suitable for retrieving large<code>LONGVARCHAR</code>values.  The JDBC driver will
 1152        * do any necessary conversion from the database format into Unicode.
 1153        * The byte format of the Unicode stream must be Java UTF-8,
 1154        * as specified in the Java virtual machine specification.
 1155        *
 1156        * <P><B>Note:</B> All the data in the returned stream must be
 1157        * read prior to getting the value of any other column. The next
 1158        * call to a <code>getXXX</code> method implicitly closes the stream.  Also, a
 1159        * stream may return <code>0</code> when the method
 1160        * <code>InputStream.available</code>
 1161        * is called whether there is data available or not.
 1162        *
 1163        * @param columnIndex the first column is 1, the second is 2, and so on
 1164        * @return a Java input stream that delivers the database column value
 1165        * as a stream in Java UTF-8 byte format;
 1166        * if the value is SQL <code>NULL</code>, the value returned is <code>null</code>
 1167        * @throws SQLException if (1) a database access error occurs
 1168        *            or (2) this rowset does not have a currently valid connection,
 1169        *            prepared statement, and result set
 1170        * @deprecated use <code>getCharacterStream</code> in place of
 1171        *              <code>getUnicodeStream</code>
 1172        */
 1173       public java.io.InputStream getUnicodeStream(int columnIndex) throws SQLException {
 1174           checkState();
 1175   
 1176           return rs.getUnicodeStream(columnIndex);
 1177       }
 1178   
 1179       /**
 1180        * Gets the value of a column in the current row as a stream of
 1181        * the value of the designated column in the current row
 1182        * of this rowset's <code>ResultSet</code> object as a binary stream of
 1183        * uninterpreted bytes. The value can then be read in chunks from the
 1184        * stream. This method is particularly
 1185        * suitable for retrieving large <code>LONGVARBINARY</code> values.
 1186        *
 1187        * <P><B>Note:</B> All the data in the returned stream must be
 1188        * read prior to getting the value of any other column. The next
 1189        * call to a <code>getXXX</code> method implicitly closes the stream.  Also, a
 1190        * stream may return <code>0</code> when the method
 1191        * <code>InputStream.available</code>
 1192        * is called whether there is data available or not.
 1193        *
 1194        * @param columnIndex the first column is 1, the second is 2, and so on
 1195        * @return a Java input stream that delivers the database column value
 1196        * as a stream of uninterpreted bytes;
 1197        * if the value is SQL <code>NULL</code>, the value returned is <code>null</code>
 1198        * @throws SQLException if (1) a database access error occurs
 1199        *            or (2) this rowset does not have a currently valid connection,
 1200        *            prepared statement, and result set
 1201        */
 1202       public java.io.InputStream getBinaryStream(int columnIndex) throws SQLException {
 1203           checkState();
 1204   
 1205           return rs.getBinaryStream(columnIndex);
 1206       }
 1207   
 1208   
 1209       //======================================================================
 1210       // Methods for accessing results by column name
 1211       //======================================================================
 1212   
 1213       /**
 1214        * Gets the value of the designated column in the current row
 1215        * of this rowset's <code>ResultSet</code> object as
 1216        * a <code>String</code>.
 1217        *
 1218        * @param columnName the SQL name of the column
 1219        * @return the column value; if the value is SQL <code>NULL</code>, the
 1220        * value returned is <code>null</code>
 1221        * @throws SQLException if (1) a database access error occurs
 1222        *            or (2) this rowset does not have a currently valid connection,
 1223        *            prepared statement, and result set
 1224        */
 1225       public String getString(String columnName) throws SQLException {
 1226           return getString(findColumn(columnName));
 1227       }
 1228   
 1229       /**
 1230        * Gets the value of the designated column in the current row
 1231        * of this rowset's <code>ResultSet</code> object as
 1232        * a <code>boolean</code>.
 1233        *
 1234        * @param columnName the SQL name of the column
 1235        * @return the column value; if the value is SQL <code>NULL</code>, the
 1236        * value returned is <code>false</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 boolean getBoolean(String columnName) throws SQLException {
 1242           return getBoolean(findColumn(columnName));
 1243       }
 1244   
 1245       /**
 1246        * Gets the value of the designated column in the current row
 1247        * of this rowset's <code>ResultSet</code> object as
 1248        * a <code>byte</code>.
 1249        *
 1250        * @param columnName the SQL name of the column
 1251        * @return the column value; if the value is SQL <code>NULL</code>, the
 1252        * value returned is <code>0</code>
 1253        * @throws SQLException if (1) a database access error occurs
 1254        *            or (2) this rowset does not have a currently valid connection,
 1255        *            prepared statement, and result set
 1256        */
 1257       public byte getByte(String columnName) throws SQLException {
 1258           return getByte(findColumn(columnName));
 1259       }
 1260   
 1261       /**
 1262        * Gets the value of the designated column in the current row
 1263        * of this rowset's <code>ResultSet</code> object as
 1264        * a <code>short</code>.
 1265        *
 1266        * @param columnName the SQL name of the column
 1267        * @return the column value; if the value is SQL <code>NULL</code>, the
 1268        * value returned is <code>0</code>
 1269        * @throws SQLException if (1) a database access error occurs
 1270        *            or (2) this rowset does not have a currently valid connection,
 1271        *            prepared statement, and result set
 1272        */
 1273       public short getShort(String columnName) throws SQLException {
 1274           return getShort(findColumn(columnName));
 1275       }
 1276   
 1277       /**
 1278        * Gets the value of the designated column in the current row
 1279        * of this rowset's <code>ResultSet</code> object as
 1280        * an <code>int</code>.
 1281        *
 1282        * @param columnName the SQL name of the column
 1283        * @return the column value; if the value is SQL <code>NULL</code>, the
 1284        * value returned is <code>0</code>
 1285        * @throws SQLException if (1) a database access error occurs
 1286        *            or (2) this rowset does not have a currently valid connection,
 1287        *            prepared statement, and result set
 1288        */
 1289       public int getInt(String columnName) throws SQLException {
 1290           return getInt(findColumn(columnName));
 1291       }
 1292   
 1293       /**
 1294        * Gets the value of the designated column in the current row
 1295        * of this rowset's <code>ResultSet</code> object as
 1296        * a <code>long</code>.
 1297        *
 1298        * @param columnName the SQL name of the column
 1299        * @return the column value; if the value is SQL <code>NULL</code>, the
 1300        * value returned is <code>0</code>
 1301        * @throws SQLException if a database access error occurs
 1302        *            or this rowset does not have a currently valid connection,
 1303        *            prepared statement, and result set
 1304        */
 1305       public long getLong(String columnName) throws SQLException {
 1306           return getLong(findColumn(columnName));
 1307       }
 1308   
 1309       /**
 1310        * Gets the value of the designated column in the current row
 1311        * of this rowset's <code>ResultSet</code> object as
 1312        * a <code>float</code>.
 1313        *
 1314        * @param columnName the SQL name of the column
 1315        * @return the column value; if the value is SQL <code>NULL</code>, the
 1316        * value returned is <code>0</code>
 1317        * @throws SQLException if (1) a database access error occurs
 1318        *            or (2) this rowset does not have a currently valid connection,
 1319        *            prepared statement, and result set
 1320        */
 1321       public float getFloat(String columnName) throws SQLException {
 1322           return getFloat(findColumn(columnName));
 1323       }
 1324   
 1325       /**
 1326        * Gets the value of the designated column in the current row
 1327        * of this rowset's <code>ResultSet</code> object as
 1328        * a <code>double</code>.
 1329        *
 1330        * @param columnName the SQL name of the column
 1331        * @return the column value; if the value is SQL <code>NULL</code>, the
 1332        * value returned is <code>0</code>
 1333        * @throws SQLException if (1) a database access error occurs
 1334        *            or (2) this rowset does not have a currently valid connection,
 1335        *            prepared statement, and result set
 1336        */
 1337       public double getDouble(String columnName) throws SQLException {
 1338           return getDouble(findColumn(columnName));
 1339       }
 1340   
 1341       /**
 1342        * Gets the value of the designated column in the current row
 1343        * of this rowset's <code>ResultSet</code> object as
 1344        * a <code>java.math.BigDecimal</code>.
 1345        *
 1346        * @param columnName the SQL name of the column
 1347        * @param scale the number of digits to the right of the decimal point
 1348        * @return the column value; if the value is SQL <code>NULL</code>, the
 1349        * value returned is <code>null</code>
 1350        * @throws SQLException if (1) adatabase access error occurs
 1351        *            or (2) this rowset does not have a currently valid connection,
 1352        *            prepared statement, and result set
 1353        * @deprecated
 1354        */
 1355       public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
 1356           return getBigDecimal(findColumn(columnName), scale);
 1357       }
 1358   
 1359       /**
 1360        * Gets the value of the designated column in the current row
 1361        * of this rowset's <code>ResultSet</code> object as
 1362        * a <code>byte</code> array in the Java programming language.
 1363        * The bytes represent the raw values returned by the driver.
 1364        *
 1365        * @param columnName the SQL name of the column
 1366        * @return the column value; if the value is SQL <code>NULL</code>, the
 1367        * value returned is <code>null</code>
 1368        * @throws SQLException if (1) a database access error occurs
 1369        *            or (2) this rowset does not have a currently valid connection,
 1370        *            prepared statement, and result set
 1371        */
 1372       public byte[] getBytes(String columnName) throws SQLException {
 1373           return getBytes(findColumn(columnName));
 1374       }
 1375   
 1376       /**
 1377        * Gets the value of the designated column in the current row
 1378        * of this rowset's <code>ResultSet</code> object as
 1379        * a <code>java.sql.Date</code> object in the Java programming language.
 1380        *
 1381        * @param columnName the SQL name of the column
 1382        * @return the column value; if the value is SQL <code>NULL</code>, the
 1383        * value returned is <code>null</code>
 1384        * @throws SQLException if (1) a database access error occurs
 1385        *            or (2) this rowset does not have a currently valid connection,
 1386        *            prepared statement, and result set
 1387        */
 1388       public java.sql.Date getDate(String columnName) throws SQLException {
 1389           return getDate(findColumn(columnName));
 1390       }
 1391   
 1392       /**
 1393        * Gets the value of the designated column in the current row
 1394        * of this rowset's <code>ResultSet</code> object as
 1395        * a <code>java.sql.Time</code> object in the Java programming language.
 1396        *
 1397        * @param columnName the SQL name of the column
 1398        * @return the column value;
 1399        * if the value is SQL <code>NULL</code>,
 1400        * the value returned is <code>null</code>
 1401        * @throws SQLException if (1) a database access error occurs
 1402        *            or (2) this rowset does not have a currently valid connection,
 1403        *            prepared statement, and result set
 1404        */
 1405       public java.sql.Time getTime(String columnName) throws SQLException {
 1406           return getTime(findColumn(columnName));
 1407       }
 1408   
 1409       /**
 1410        * Gets the value of the designated column in the current row
 1411        * of this rowset's <code>ResultSet</code> object as
 1412        * a <code>java.sql.Timestamp</code> object.
 1413        *
 1414        * @param columnName the SQL name of the column
 1415        * @return the column value; if the value is SQL <code>NULL</code>, the
 1416        * value returned is <code>null</code>
 1417        * @throws SQLException if (1) a database access error occurs
 1418        *            or (2) this rowset does not have a currently valid connection,
 1419        *            prepared statement, and result set
 1420        */
 1421       public java.sql.Timestamp getTimestamp(String columnName) throws SQLException {
 1422           return getTimestamp(findColumn(columnName));
 1423       }
 1424   
 1425       /**
 1426        * Gets the value of the designated column in the current row
 1427        * of this rowset's <code>ResultSet</code> object as a stream of
 1428        * ASCII characters. The value can then be read in chunks from the
 1429        * stream. This method is particularly
 1430        * suitable for retrieving large <code>LONGVARCHAR</code> values.
 1431        * The JDBC driver will
 1432        * do any necessary conversion from the database format into ASCII.
 1433        *
 1434        * <P><B>Note:</B> All the data in the returned stream must be
 1435        * read prior to getting the value of any other column. The next
 1436        * call to a <code>getXXX</code> method implicitly closes the stream. Also, a
 1437        * stream may return <code>0</code> when the method <code>available</code>
 1438        * is called whether there is data available or not.
 1439        *
 1440        * @param columnName the SQL name of the column
 1441        * @return a Java input stream that delivers the database column value
 1442        * as a stream of one-byte ASCII characters.
 1443        * If the value is SQL <code>NULL</code>,
 1444        * the value returned is <code>null</code>.
 1445        * @throws SQLException if (1) a database access error occurs
 1446        *            or (2) this rowset does not have a currently valid connection,
 1447        *            prepared statement, and result set
 1448        */
 1449       public java.io.InputStream getAsciiStream(String columnName) throws SQLException {
 1450           return getAsciiStream(findColumn(columnName));
 1451       }
 1452   
 1453       /**
 1454        * Gets the value of the designated column in the current row
 1455        * of this rowset's <code>ResultSet</code> object as a stream of
 1456        * Unicode characters. The value can then be read in chunks from the
 1457        * stream. This method is particularly
 1458        * suitable for retrieving large <code>LONGVARCHAR</code> values.
 1459        * The JDBC driver will
 1460        * do any necessary conversion from the database format into Unicode.
 1461        * The byte format of the Unicode stream must be Java UTF-8,
 1462        * as defined in the Java virtual machine specification.
 1463        *
 1464        * <P><B>Note:</B> All the data in the returned stream must be
 1465        * read prior to getting the value of any other column. The next
 1466        * call to a <code>getXXX</code> method implicitly closes the stream. Also, a
 1467        * stream may return <code>0</code> when the method <code>available</code>
 1468        * is called whether there is data available or not.
 1469        *
 1470        * @param columnName the SQL name of the column
 1471        * @return a Java input stream that delivers the database column value
 1472        * as a stream of two-byte Unicode characters.
 1473        * If the value is SQL <code>NULL</code>,
 1474        * the value returned is <code>null</code>.
 1475        * @throws SQLException if (1) a database access error occurs
 1476        *            or (2) this rowset does not have a currently valid connection,
 1477        *            prepared statement, and result set
 1478        * @deprecated
 1479        */
 1480       public java.io.InputStream getUnicodeStream(String columnName) throws SQLException {
 1481           return getUnicodeStream(findColumn(columnName));
 1482       }
 1483   
 1484       /**
 1485        * Gets the value of the designated column in the current row
 1486        * of this rowset's <code>ResultSet</code> object as a stream of uninterpreted
 1487        * <code>byte</code>s.
 1488        * The value can then be read in chunks from the
 1489        * stream. This method is particularly
 1490        * suitable for retrieving large <code>LONGVARBINARY</code>
 1491        * values.
 1492        *
 1493        * <P><B>Note:</B> All the data in the returned stream must be
 1494        * read prior to getting the value of any other column. The next
 1495        * call to a <code>getXXX</code> method implicitly closes the stream. Also, a
 1496        * stream may return <code>0</code> when the method <code>available</code>
 1497        * is called whether there is data available or not.
 1498        *
 1499        * @param columnName the SQL name of the column
 1500        * @return a Java input stream that delivers the database column value
 1501        * as a stream of uninterpreted bytes;
 1502        * if the value is SQL <code>NULL</code>, the result is <code>null</code>
 1503        * @throws SQLException if (1) a database access error occurs
 1504        *            or (2) this rowset does not have a currently valid connection,
 1505        *            prepared statement, and result set
 1506        */
 1507       public java.io.InputStream getBinaryStream(String columnName) throws SQLException {
 1508           return getBinaryStream(findColumn(columnName));
 1509       }
 1510   
 1511   
 1512       //=====================================================================
 1513       // Advanced features:
 1514       //=====================================================================
 1515   
 1516       /**
 1517        * Returns the first warning reported by calls on this rowset's
 1518        * <code>ResultSet</code> object.
 1519        * Subsequent warnings on this rowset's <code>ResultSet</code> object
 1520        * will be chained to the <code>SQLWarning</code> object that
 1521        * this method returns.
 1522        *
 1523        * <P>The warning chain is automatically cleared each time a new
 1524        * row is read.
 1525        *
 1526        * <P><B>Note:</B> This warning chain only covers warnings caused
 1527        * by <code>ResultSet</code> methods.  Any warning caused by
 1528        * <code>Statement</code> methods
 1529        * (such as reading OUT parameters) will be chained on the
 1530        * <code>Statement</code> object.
 1531        *
 1532        * @return the first <code>SQLWarning</code> object reported or <code>null</code>
 1533        * @throws SQLException if (1) a database access error occurs
 1534        *            or (2) this rowset does not have a currently valid connection,
 1535        *            prepared statement, and result set
 1536        */
 1537       public SQLWarning getWarnings() throws SQLException {
 1538           checkState();
 1539   
 1540           return rs.getWarnings();
 1541       }
 1542   
 1543       /**
 1544        * Clears all warnings reported on this rowset's <code>ResultSet</code> object.
 1545        * After this method is called, the method <code>getWarnings</code>
 1546        * returns <code>null</code> until a new warning is
 1547        * reported for this rowset's <code>ResultSet</code> object.
 1548        *
 1549        * @throws SQLException if (1) a database access error occurs
 1550        *            or (2) this rowset does not have a currently valid connection,
 1551        *            prepared statement, and result set
 1552        */
 1553       public void clearWarnings() throws SQLException {
 1554           checkState();
 1555   
 1556           rs.clearWarnings();
 1557       }
 1558   
 1559       /**
 1560        * Gets the name of the SQL cursor used by this rowset's <code>ResultSet</code>
 1561        * object.
 1562        *
 1563        * <P>In SQL, a result table is retrieved through a cursor that is
 1564        * named. The current row of a result set can be updated or deleted
 1565        * using a positioned update/delete statement that references the
 1566        * cursor name. To insure that the cursor has the proper isolation
 1567        * level to support update, the cursor's <code>select</code> statement should be
 1568        * of the form 'select for update'. If the 'for update' clause is
 1569        * omitted, the positioned updates may fail.
 1570        *
 1571        * <P>The JDBC API supports this SQL feature by providing the name of the
 1572        * SQL cursor used by a <code>ResultSet</code> object.
 1573        * The current row of a <code>ResultSet</code> object
 1574        * is also the current row of this SQL cursor.
 1575        *
 1576        * <P><B>Note:</B> If positioned update is not supported, a
 1577        * <code>SQLException</code> is thrown.
 1578        *
 1579        * @return the SQL name for this rowset's <code>ResultSet</code> object's cursor
 1580        * @throws SQLException if (1) a database access error occurs
 1581        *            or (2) xthis rowset does not have a currently valid connection,
 1582        *            prepared statement, and result set
 1583        */
 1584       public String getCursorName() throws SQLException {
 1585           checkState();
 1586   
 1587           return rs.getCursorName();
 1588       }
 1589   
 1590       /**
 1591        * Retrieves the  number, types and properties of
 1592        * this rowset's <code>ResultSet</code> object's columns.
 1593        *
 1594        * @return the description of this rowset's <code>ResultSet</code>
 1595        *     object's columns
 1596        * @throws SQLException if (1) a database access error occurs
 1597        *     or (2) this rowset does not have a currently valid connection,
 1598        *     prepared statement, and result set
 1599        */
 1600       public ResultSetMetaData getMetaData() throws SQLException {
 1601   
 1602           checkState();
 1603   
 1604           // It may be the case that JdbcRowSet might not have been
 1605           // initialized with ResultSet handle and may be by PreparedStatement
 1606           // internally when we set JdbcRowSet.setCommand().
 1607           // We may require all the basic properties of setEscapeProcessing
 1608           // setMaxFieldSize etc. which an application can use before we call
 1609           // execute.
 1610           try {
 1611                checkState();
 1612           } catch(SQLException sqle) {
 1613                prepare();
 1614                // will return ResultSetMetaData
 1615                return ps.getMetaData();
 1616           }
 1617           return rs.getMetaData();
 1618       }
 1619   
 1620       /**
 1621        * <p>Gets the value of the designated column in the current row
 1622        * of this rowset's <code>ResultSet</code> object as
 1623        * an <code>Object</code>.
 1624        *
 1625        * <p>This method will return the value of the given column as a
 1626        * Java object.  The type of the Java object will be the default
 1627        * Java object type corresponding to the column's SQL type,
 1628        * following the mapping for built-in types specified in the JDBC
 1629        * specification.
 1630        *
 1631        * <p>This method may also be used to read datatabase-specific
 1632        * abstract data types.
 1633        *
 1634        * In the JDBC 3.0 API, the behavior of method
 1635        * <code>getObject</code> is extended to materialize
 1636        * data of SQL user-defined types.  When a column contains
 1637        * a structured or distinct value, the behavior of this method is as
 1638        * if it were a call to: <code>getObject(columnIndex,
 1639        * this.getStatement().getConnection().getTypeMap())</code>.
 1640        *
 1641        * @param columnIndex the first column is 1, the second is 2, and so on
 1642        * @return a <code>java.lang.Object</code> holding the column value
 1643        * @throws SQLException if (1) a database access error occurs
 1644        *            or (2) this rowset does not currently have a valid connection,
 1645        *            prepared statement, and result set
 1646        */
 1647       public Object getObject(int columnIndex) throws SQLException {
 1648           checkState();
 1649   
 1650           return rs.getObject(columnIndex);
 1651       }
 1652   
 1653       /**
 1654        * <p>Gets the value of the designated column in the current row
 1655        * of this rowset's <code>ResultSet</code> object as
 1656        * an <code>Object</code>.
 1657        *
 1658        * <p>This method will return the value of the given column as a
 1659        * Java object.  The type of the Java object will be the default
 1660        * Java object type corresponding to the column's SQL type,
 1661        * following the mapping for built-in types specified in the JDBC
 1662        * specification.
 1663        *
 1664        * <p>This method may also be used to read datatabase-specific
 1665        * abstract data types.
 1666        *
 1667        * In the JDBC 3.0 API, the behavior of the method
 1668        * <code>getObject</code> is extended to materialize
 1669        * data of SQL user-defined types.  When a column contains
 1670        * a structured or distinct value, the behavior of this method is as
 1671        * if it were a call to: <code>getObject(columnIndex,
 1672        * this.getStatement().getConnection().getTypeMap())</code>.
 1673        *
 1674        * @param columnName the SQL name of the column
 1675        * @return a <code>java.lang.Object</code> holding the column value
 1676        * @throws SQLException if (1) a database access error occurs
 1677        *            or (2) this rowset does not currently have a valid connection,
 1678        *            prepared statement, and result set
 1679        */
 1680       public Object getObject(String columnName) throws SQLException {
 1681           return getObject(findColumn(columnName));
 1682       }
 1683   
 1684       //----------------------------------------------------------------
 1685   
 1686       /**
 1687        * Maps the given <code>JdbcRowSetImpl</code> column name to its
 1688        * <code>JdbcRowSetImpl</code> column index and reflects this on
 1689        * the internal <code>ResultSet</code> object.
 1690        *
 1691        * @param columnName the name of the column
 1692        * @return the column index of the given column name
 1693        * @throws SQLException if (1) a database access error occurs
 1694        * (2) this rowset does not have a currently valid connection,
 1695        * prepared statement, and result set
 1696        */
 1697       public int findColumn(String columnName) throws SQLException {
 1698           checkState();
 1699   
 1700           return rs.findColumn(columnName);
 1701       }
 1702   
 1703   
 1704       //--------------------------JDBC 2.0-----------------------------------
 1705   
 1706       //---------------------------------------------------------------------
 1707       // Getters and Setters
 1708       //---------------------------------------------------------------------
 1709   
 1710       /**
 1711        * Gets the value of the designated column in the current row
 1712        * of this rowset's <code>ResultSet</code> object as a
 1713        * <code>java.io.Reader</code> object.
 1714        * @return a <code>java.io.Reader</code> object that contains the column
 1715        * value; if the value is SQL <code>NULL</code>, the value returned is
 1716        * <code>null</code>.
 1717        * @param columnIndex the first column is 1, the second is 2, and so on
 1718        *
 1719        */
 1720       public java.io.Reader getCharacterStream(int columnIndex) throws SQLException {
 1721           checkState();
 1722   
 1723           return rs.getCharacterStream(columnIndex);
 1724       }
 1725   
 1726       /**
 1727        * Gets the value of the designated column in the current row
 1728        * of this rowset's <code>ResultSet</code> object as a
 1729        * <code>java.io.Reader</code> object.
 1730        *
 1731        * @return a <code>java.io.Reader</code> object that contains the column
 1732        * value; if the value is SQL <code>NULL</code>, the value returned is
 1733        * <code>null</code>.
 1734        * @param columnName the name of the column
 1735        * @return the value in the specified column as a <code>java.io.Reader</code>
 1736        *
 1737        */
 1738       public java.io.Reader getCharacterStream(String columnName) throws SQLException {
 1739           return getCharacterStream(findColumn(columnName));
 1740       }
 1741   
 1742       /**
 1743        * Gets the value of the designated column in the current row
 1744        * of this rowset's <code>ResultSet</code> object as a
 1745        * <code>java.math.BigDecimal</code> with full precision.
 1746        *
 1747        * @param columnIndex the first column is 1, the second is 2, and so on
 1748        * @return the column value (full precision);
 1749        * if the value is SQL <code>NULL</code>, the value returned is
 1750        * <code>null</code>.
 1751        * @throws SQLException if a database access error occurs
 1752        *            or this rowset does not currently have a valid
 1753        *            connection, prepared statement, and result set
 1754        */
 1755       public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
 1756           checkState();
 1757   
 1758           return rs.getBigDecimal(columnIndex);
 1759       }
 1760   
 1761       /**
 1762        * Gets the value of the designated column in the current row
 1763        * of this rowset's <code>ResultSet</code> object as a
 1764        * <code>java.math.BigDecimal</code> with full precision.
 1765        *
 1766        * @param columnName the column name
 1767        * @return the column value (full precision);
 1768        * if the value is SQL <code>NULL</code>, the value returned is
 1769        * <code>null</code>.
 1770        * @throws SQLException if a database access error occurs
 1771        *            or this rowset does not currently have a valid
 1772        *            connection, prepared statement, and result set
 1773        */
 1774       public BigDecimal getBigDecimal(String columnName) throws SQLException {
 1775           return getBigDecimal(findColumn(columnName));
 1776       }
 1777   
 1778       //---------------------------------------------------------------------
 1779       // Traversal/Positioning
 1780       //---------------------------------------------------------------------
 1781   
 1782       /**
 1783        * Indicates whether the cursor is before the first row in
 1784        * this rowset's <code>ResultSet</code> object.
 1785        *
 1786        * @return <code>true</code> if the cursor is before the first row;
 1787        * <code>false</code> if the cursor is at any other position or the
 1788        * result set contains no rows
 1789        * @throws SQLException if a database access error occurs
 1790        *            or this rowset does not currently have a valid
 1791        *            connection, prepared statement, and result set
 1792        */
 1793       public boolean isBeforeFirst() throws SQLException {
 1794           checkState();
 1795   
 1796           return rs.isBeforeFirst();
 1797       }
 1798   
 1799       /**
 1800        * Indicates whether the cursor is after the last row in
 1801        * this rowset's <code>ResultSet</code> object.
 1802        *
 1803        * @return <code>true</code> if the cursor is after the last row;
 1804        * <code>false</code> if the cursor is at any other position or the
 1805        * result set contains no rows
 1806        * @throws SQLException if a database access error occurs
 1807        *            or this rowset does not currently have a valid
 1808        *            connection, prepared statement, and result set
 1809        */
 1810       public boolean isAfterLast() throws SQLException {
 1811           checkState();
 1812   
 1813           return rs.isAfterLast();
 1814       }
 1815   
 1816       /**
 1817        * Indicates whether the cursor is on the first row of
 1818        * this rowset's <code>ResultSet</code> object.
 1819        *
 1820        * @return <code>true</code> if the cursor is on the first row;
 1821        * <code>false</code> otherwise
 1822        * @throws SQLException if a database access error occurs
 1823        *            or this rowset does not currently have a valid
 1824        *            connection, prepared statement, and result set
 1825        */
 1826       public boolean isFirst() throws SQLException {
 1827           checkState();
 1828   
 1829           return rs.isFirst();
 1830       }
 1831   
 1832       /**
 1833        * Indicates whether the cursor is on the last row of
 1834        * this rowset's <code>ResultSet</code> object.
 1835        * Note: Calling the method <code>isLast</code> may be expensive
 1836        * because the JDBC driver
 1837        * might need to fetch ahead one row in order to determine
 1838        * whether the current row is the last row in the result set.
 1839        *
 1840        * @return <code>true</code> if the cursor is on the last row;
 1841        * <code>false</code> otherwise
 1842        * @throws SQLException if a database access error occurs
 1843        *            or this rowset does not currently have a valid
 1844        *            connection, prepared statement, and result set
 1845        *
 1846        */
 1847       public boolean isLast() throws SQLException {
 1848           checkState();
 1849   
 1850           return rs.isLast();
 1851       }
 1852   
 1853       /**
 1854        * Moves the cursor to the front of
 1855        * this rowset's <code>ResultSet</code> object, just before the
 1856        * first row. This method has no effect if the result set contains no rows.
 1857        *
 1858        * @throws SQLException if (1) a database access error occurs,
 1859        *            (2) the result set type is <code>TYPE_FORWARD_ONLY</code>,
 1860        *            or (3) this rowset does not currently have a valid
 1861        *            connection, prepared statement, and result set
 1862        */
 1863       public void beforeFirst() throws SQLException {
 1864           checkState();
 1865   
 1866           rs.beforeFirst();
 1867           notifyCursorMoved();
 1868       }
 1869   
 1870       /**
 1871        * Moves the cursor to the end of
 1872        * this rowset's <code>ResultSet</code> object, just after the
 1873        * last row. This method has no effect if the result set contains no rows.
 1874        * @throws SQLException if (1) a database access error occurs,
 1875        *            (2) the result set type is <code>TYPE_FORWARD_ONLY</code>,
 1876        *            or (3) this rowset does not currently have a valid
 1877        *            connection, prepared statement, and result set
 1878        */
 1879       public void afterLast() throws SQLException {
 1880           checkState();
 1881   
 1882           rs.afterLast();
 1883           notifyCursorMoved();
 1884       }
 1885   
 1886       /**
 1887        * Moves the cursor to the first row in
 1888        * this rowset's <code>ResultSet</code> object.
 1889        *
 1890        * @return <code>true</code> if the cursor is on a valid row;
 1891        * <code>false</code> if there are no rows in the result set
 1892        * @throws SQLException if (1) a database access error occurs,
 1893        *            (2) the result set type is <code>TYPE_FORWARD_ONLY</code>,
 1894        *            or (3) this rowset does not currently have a valid
 1895        *            connection, prepared statement, and result set
 1896        */
 1897       public boolean first() throws SQLException {
 1898           checkState();
 1899   
 1900           boolean b = rs.first();
 1901           notifyCursorMoved();
 1902           return b;
 1903   
 1904       }
 1905   
 1906       /**
 1907        * Moves the cursor to the last row in
 1908        * this rowset's <code>ResultSet</code> object.
 1909        *
 1910        * @return <code>true</code> if the cursor is on a valid row;
 1911        * <code>false</code> if there are no rows in the result set
 1912        * @throws SQLException if (1) a database access error occurs,
 1913        *            (2) the result set type is <code>TYPE_FORWARD_ONLY</code>,
 1914        *            or (3) this rowset does not currently have a valid
 1915        *            connection, prepared statement, and result set
 1916        */
 1917       public boolean last() throws SQLException {
 1918           checkState();
 1919   
 1920           boolean b = rs.last();
 1921           notifyCursorMoved();
 1922           return b;
 1923       }
 1924   
 1925       /**
 1926        * Retrieves the current row number.  The first row is number 1, the
 1927        * second is number 2, and so on.
 1928        *
 1929        * @return the current row number; <code>0</code> if there is no current row
 1930        * @throws SQLException if a database access error occurs
 1931        *            or this rowset does not currently have a valid connection,
 1932        *            prepared statement, and result set
 1933        */
 1934       public int getRow() throws SQLException {
 1935           checkState();
 1936   
 1937           return rs.getRow();
 1938       }
 1939   
 1940       /**
 1941        * Moves the cursor to the given row number in
 1942        * this rowset's internal <code>ResultSet</code> object.
 1943        *
 1944        * <p>If the row number is positive, the cursor moves to
 1945        * the given row number with respect to the
 1946        * beginning of the result set.  The first row is row 1, the second
 1947        * is row 2, and so on.
 1948        *
 1949        * <p>If the given row number is negative, the cursor moves to
 1950        * an absolute row position with respect to
 1951        * the end of the result set.  For example, calling the method
 1952        * <code>absolute(-1)</code> positions the
 1953        * cursor on the last row, calling the method <code>absolute(-2)</code>
 1954        * moves the cursor to the next-to-last row, and so on.
 1955        *
 1956        * <p>An attempt to position the cursor beyond the first/last row in
 1957        * the result set leaves the cursor before the first row or after
 1958        * the last row.
 1959        *
 1960        * <p><B>Note:</B> Calling <code>absolute(1)</code> is the same
 1961        * as calling <code>first()</code>. Calling <code>absolute(-1)</code>
 1962        * is the same as calling <code>last()</code>.
 1963        *
 1964        * @return <code>true</code> if the cursor is on the result set;
 1965        * <code>false</code> otherwise
 1966        * @throws SQLException if (1) a database access error occurs,
 1967        *            (2) the row is <code>0</code>, (3) the result set
 1968        *            type is <code>TYPE_FORWARD_ONLY</code>, or (4) this
 1969        *            rowset does not currently have a valid connection,
 1970        *            prepared statement, and result set
 1971        */
 1972       public boolean absolute(int row) throws SQLException {
 1973           checkState();
 1974   
 1975           boolean b = rs.absolute(row);
 1976           notifyCursorMoved();
 1977           return b;
 1978       }
 1979   
 1980       /**
 1981        * Moves the cursor a relative number of rows, either positive or negative.
 1982        * Attempting to move beyond the first/last row in the
 1983        * result set positions the cursor before/after the
 1984        * the first/last row. Calling <code>relative(0)</code> is valid, but does
 1985        * not change the cursor position.
 1986        *
 1987        * <p>Note: Calling the method <code>relative(1)</code>
 1988        * is different from calling the method <code>next()</code>
 1989        * because is makes sense to call <code>next()</code> when there
 1990        * is no current row,
 1991        * for example, when the cursor is positioned before the first row
 1992        * or after the last row of the result set.
 1993        *
 1994        * @return <code>true</code> if the cursor is on a row;
 1995        * <code>false</code> otherwise
 1996        * @throws SQLException if (1) a database access error occurs,
 1997        *            (2) there is no current row, (3) the result set
 1998        *            type is <code>TYPE_FORWARD_ONLY</code>, or (4) this
 1999        *            rowset does not currently have a valid connection,
 2000        *            prepared statement, and result set
 2001        */
 2002       public boolean relative(int rows) throws SQLException {
 2003           checkState();
 2004   
 2005           boolean b = rs.relative(rows);
 2006           notifyCursorMoved();
 2007           return b;
 2008       }
 2009   
 2010       /**
 2011        * Moves the cursor to the previous row in this
 2012        * <code>ResultSet</code> object.
 2013        *
 2014        * <p><B>Note:</B> Calling the method <code>previous()</code> is not the same as
 2015        * calling the method <code>relative(-1)</code> because it
 2016        * makes sense to call <code>previous()</code> when there is no current row.
 2017        *
 2018        * @return <code>true</code> if the cursor is on a valid row;
 2019        * <code>false</code> if it is off the result set
 2020        * @throws SQLException if (1) a database access error occurs,
 2021        *            (2) the result set type is <code>TYPE_FORWARD_ONLY</code>,
 2022        *            or (3) this rowset does not currently have a valid
 2023        *            connection, prepared statement, and result set
 2024        */
 2025       public boolean previous() throws SQLException {
 2026           checkState();
 2027   
 2028           boolean b = rs.previous();
 2029           notifyCursorMoved();
 2030           return b;
 2031       }
 2032   
 2033       /**
 2034        * Gives a hint as to the direction in which the rows in this
 2035        * <code>ResultSet</code> object will be processed.
 2036        * The initial value is determined by the
 2037        * <code>Statement</code> object
 2038        * that produced this rowset's <code>ResultSet</code> object.
 2039        * The fetch direction may be changed at any time.
 2040        *
 2041        * @throws SQLException if (1) a database access error occurs,
 2042        *            (2) the result set type is <code>TYPE_FORWARD_ONLY</code>
 2043        *            and the fetch direction is not <code>FETCH_FORWARD</code>,
 2044        *            or (3) this rowset does not currently have a valid
 2045        *            connection, prepared statement, and result set
 2046        * @see java.sql.Statement#setFetchDirection
 2047        */
 2048       public void setFetchDirection(int direction) throws SQLException {
 2049           checkState();
 2050   
 2051           rs.setFetchDirection(direction);
 2052       }
 2053   
 2054       /**
 2055        * Returns the fetch direction for this
 2056        * <code>ResultSet</code> object.
 2057        *
 2058        * @return the current fetch direction for this rowset's
 2059        *         <code>ResultSet</code> object
 2060        * @throws SQLException if a database access error occurs
 2061        *            or this rowset does not currently have a valid connection,
 2062        *            prepared statement, and result set
 2063        */
 2064       public int getFetchDirection() throws SQLException {
 2065           try {
 2066                checkState();
 2067           } catch(SQLException sqle) {
 2068                super.getFetchDirection();
 2069           }
 2070           return rs.getFetchDirection();
 2071       }
 2072   
 2073       /**
 2074        * Gives the JDBC driver a hint as to the number of rows that should
 2075        * be fetched from the database when more rows are needed for this
 2076        * <code>ResultSet</code> object.
 2077        * If the fetch size specified is zero, the JDBC driver
 2078        * ignores the value and is free to make its own best guess as to what
 2079        * the fetch size should be.  The default value is set by the
 2080        * <code>Statement</code> object
 2081        * that created the result set.  The fetch size may be changed at any time.
 2082        *
 2083        * @param rows the number of rows to fetch
 2084        * @throws SQLException if (1) a database access error occurs, (2) the
 2085        *            condition <code>0 <= rows <= this.getMaxRows()</code> is not
 2086        *            satisfied, or (3) this rowset does not currently have a valid
 2087        *            connection, prepared statement, and result set
 2088        *
 2089        */
 2090       public void setFetchSize(int rows) throws SQLException {
 2091           checkState();
 2092   
 2093           rs.setFetchSize(rows);
 2094       }
 2095   
 2096       /**
 2097        *
 2098        * Returns the fetch size for this
 2099        * <code>ResultSet</code> object.
 2100        *
 2101        * @return the current fetch size for this rowset's <code>ResultSet</code> object
 2102        * @throws SQLException if a database access error occurs
 2103        *            or this rowset does not currently have a valid connection,
 2104        *            prepared statement, and result set
 2105        */
 2106       public int getType() throws SQLException {
 2107           try {
 2108                checkState();
 2109           } catch(SQLException sqle) {
 2110               return super.getType();
 2111           }
 2112   
 2113           // If the ResultSet has not been created, then return the default type
 2114           // otherwise return the type from the ResultSet.
 2115           if(rs == null) {
 2116               return super.getType();
 2117           } else {
 2118              int rstype = rs.getType();
 2119               return rstype;
 2120           }
 2121   
 2122   
 2123       }
 2124   
 2125       /**
 2126        * Returns the concurrency mode of this rowset's <code>ResultSet</code> object.
 2127        * The concurrency used is determined by the
 2128        * <code>Statement</code> object that created the result set.
 2129        *
 2130        * @return the concurrency type, either <code>CONCUR_READ_ONLY</code>
 2131        * or <code>CONCUR_UPDATABLE</code>
 2132        * @throws SQLException if (1) a database access error occurs
 2133        *            or (2) this rowset does not currently have a valid connection,
 2134        *            prepared statement, and result set
 2135        */
 2136       public int getConcurrency() throws SQLException {
 2137           try {
 2138                checkState();
 2139           } catch(SQLException sqle) {
 2140                super.getConcurrency();
 2141           }
 2142           return rs.getConcurrency();
 2143       }
 2144   
 2145       //---------------------------------------------------------------------
 2146       // Updates
 2147       //---------------------------------------------------------------------
 2148   
 2149       /**
 2150        * Indicates whether the current row has been updated.  The value returned
 2151        * depends on whether or not the result set can detect updates.
 2152        *
 2153        * @return <code>true</code> if the row has been visibly updated
 2154        * by the owner or another, and updates are detected
 2155        * @throws SQLException if a database access error occurs
 2156        *            or this rowset does not currently have a valid connection,
 2157        *            prepared statement, and result set
 2158        * @see java.sql.DatabaseMetaData#updatesAreDetected
 2159        */
 2160       public boolean rowUpdated() throws SQLException {
 2161           checkState();
 2162   
 2163           return rs.rowUpdated();
 2164       }
 2165   
 2166       /**
 2167        * Indicates whether the current row has had an insertion.
 2168        * The value returned depends on whether or not this
 2169        * <code>ResultSet</code> object can detect visible inserts.
 2170        *
 2171        * @return <code>true</code> if a row has had an insertion
 2172        * and insertions are detected; <code>false</code> otherwise
 2173        * @throws SQLException if a database access error occurs
 2174        *            or this rowset does not currently have a valid connection,
 2175        *            prepared statement, and result set
 2176        * @see java.sql.DatabaseMetaData#insertsAreDetected
 2177        *
 2178        */
 2179       public boolean rowInserted() throws SQLException {
 2180           checkState();
 2181   
 2182           return rs.rowInserted();
 2183       }
 2184   
 2185       /**
 2186        * Indicates whether a row has been deleted.  A deleted row may leave
 2187        * a visible "hole" in a result set.  This method can be used to
 2188        * detect holes in a result set.  The value returned depends on whether
 2189        * or not this rowset's <code>ResultSet</code> object can detect deletions.
 2190        *
 2191        * @return <code>true</code> if a row was deleted and deletions are detected;
 2192        * <code>false</code> otherwise
 2193        * @throws SQLException if a database access error occurs
 2194        *            or this rowset does not currently have a valid connection,
 2195        *            prepared statement, and result set
 2196        * @see java.sql.DatabaseMetaData#deletesAreDetected
 2197        */
 2198       public boolean rowDeleted() throws SQLException {
 2199           checkState();
 2200   
 2201           return rs.rowDeleted();
 2202       }
 2203   
 2204       /**
 2205        * Gives a nullable column a null value.
 2206        *
 2207        * The <code>updateXXX</code> methods are used to update column values in the
 2208        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2209        * update the underlying database; instead the <code>updateRow</code>
 2210        * or <code>insertRow</code> methods are called to update the database.
 2211        *
 2212        * @param columnIndex the first column is 1, the second is 2, and so on
 2213        * @throws SQLException if a database access error occurs
 2214        *            or this rowset does not currently have a valid connection,
 2215        *            prepared statement, and result set
 2216        */
 2217       public void updateNull(int columnIndex) throws SQLException {
 2218           checkState();
 2219   
 2220           // To check the type and concurrency of the ResultSet
 2221           // to verify whether updates are possible or not
 2222           checkTypeConcurrency();
 2223   
 2224           rs.updateNull(columnIndex);
 2225       }
 2226   
 2227       /**
 2228        * Updates the designated column with a <code>boolean</code> value.
 2229        * The <code>updateXXX</code> methods are used to update column values in the
 2230        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2231        * update the underlying database; instead the <code>updateRow</code> or
 2232        * <code>insertRow</code> methods are called to update the database.
 2233        *
 2234        * @param columnIndex the first column is 1, the second is 2, and so on
 2235        * @param x the new column value
 2236        * @throws SQLException if a database access error occurs
 2237        *            or this rowset does not currently have a valid connection,
 2238        *            prepared statement, and result set
 2239        *
 2240        */
 2241       public void updateBoolean(int columnIndex, boolean x) throws SQLException {
 2242           checkState();
 2243   
 2244           // To check the type and concurrency of the ResultSet
 2245           // to verify whether updates are possible or not
 2246           checkTypeConcurrency();
 2247   
 2248           rs.updateBoolean(columnIndex, x);
 2249       }
 2250   
 2251       /**
 2252        * Updates the designated column with a <code>byte</code> value.
 2253        * The <code>updateXXX</code> methods are used to update column values in the
 2254        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2255        * update the underlying database; instead the <code>updateRow</code> or
 2256        * <code>insertRow</code> methods are called to update the database.
 2257        *
 2258        *
 2259        * @param columnIndex the first column is 1, the second is 2, and so on
 2260        * @param x the new column value
 2261        * @throws SQLException if a database access error occurs
 2262        *            or this rowset does not currently have a valid connection,
 2263        *            prepared statement, and result set
 2264        *
 2265        */
 2266       public void updateByte(int columnIndex, byte x) throws SQLException {
 2267           checkState();
 2268   
 2269           // To check the type and concurrency of the ResultSet
 2270           // to verify whether updates are possible or not
 2271           checkTypeConcurrency();
 2272   
 2273           rs.updateByte(columnIndex, x);
 2274       }
 2275   
 2276       /**
 2277        * Updates the designated column with a <code>short</code> value.
 2278        * The <code>updateXXX</code> methods are used to update column values in the
 2279        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2280        * update the underlying database; instead the <code>updateRow</code> or
 2281        * <code>insertRow</code> methods are called to update the database.
 2282        *
 2283        * @param columnIndex the first column is 1, the second is 2, and so on
 2284        * @param x the new column value
 2285        * @throws SQLException if a database access error occurs
 2286        *            or this rowset does not currently have a valid connection,
 2287        *            prepared statement, and result set
 2288        *
 2289        */
 2290       public void updateShort(int columnIndex, short x) throws SQLException {
 2291           checkState();
 2292   
 2293           // To check the type and concurrency of the ResultSet
 2294           // to verify whether updates are possible or not
 2295           checkTypeConcurrency();
 2296   
 2297           rs.updateShort(columnIndex, x);
 2298       }
 2299   
 2300       /**
 2301        * Updates the designated column with an <code>int</code> value.
 2302        * The <code>updateXXX</code> methods are used to update column values in the
 2303        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2304        * update the underlying database; instead the <code>updateRow</code> or
 2305        * <code>insertRow</code> methods are called to update the database.
 2306        *
 2307        * @param columnIndex the first column is 1, the second is 2, and so on
 2308        * @param x the new column value
 2309        * @throws SQLException if a database access error occurs
 2310        *            or this rowset does not currently have a valid connection,
 2311        *            prepared statement, and result set
 2312        */
 2313       public void updateInt(int columnIndex, int x) throws SQLException {
 2314           checkState();
 2315   
 2316           // To check the type and concurrency of the ResultSet
 2317           // to verify whether updates are possible or not
 2318           checkTypeConcurrency();
 2319   
 2320           rs.updateInt(columnIndex, x);
 2321       }
 2322   
 2323       /**
 2324        * Updates the designated column with a <code>long</code> value.
 2325        * The <code>updateXXX</code> methods are used to update column values in the
 2326        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2327        * update the underlying database; instead the <code>updateRow</code> or
 2328        * <code>insertRow</code> methods are called to update the database.
 2329        *
 2330        * @param columnIndex the first column is 1, the second is 2, and so on
 2331        * @param x the new column value
 2332        * @throws SQLException if a database access error occurs
 2333        *            or this rowset does not currently have a valid connection,
 2334        *            prepared statement, and result set
 2335        *
 2336        */
 2337       public void updateLong(int columnIndex, long x) 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.updateLong(columnIndex, x);
 2345       }
 2346   
 2347       /**
 2348        * Updates the designated column with a <code>float</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        */
 2361       public void updateFloat(int columnIndex, float x) throws SQLException {
 2362           checkState();
 2363   
 2364           // To check the type and concurrency of the ResultSet
 2365           // to verify whether updates are possible or not
 2366           checkTypeConcurrency();
 2367   
 2368           rs.updateFloat(columnIndex, x);
 2369       }
 2370   
 2371       /**
 2372        * Updates the designated column with a <code>double</code> value.
 2373        * The <code>updateXXX</code> methods are used to update column values in the
 2374        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2375        * update the underlying database; instead the <code>updateRow</code> or
 2376        * <code>insertRow</code> methods are called to update the database.
 2377        *
 2378        * @param columnIndex the first column is 1, the second is 2, and so on
 2379        * @param x the new column value
 2380        * @throws SQLException if a database access error occurs
 2381        *            or this rowset does not currently have a valid connection,
 2382        *            prepared statement, and result set
 2383        *
 2384        */
 2385       public void updateDouble(int columnIndex, double x) throws SQLException {
 2386           checkState();
 2387   
 2388           // To check the type and concurrency of the ResultSet
 2389           // to verify whether updates are possible or not
 2390           checkTypeConcurrency();
 2391   
 2392           rs.updateDouble(columnIndex, x);
 2393       }
 2394   
 2395       /**
 2396        * Updates the designated column with a <code>java.math.BigDecimal</code>
 2397        * value.
 2398        * The <code>updateXXX</code> methods are used to update column values in the
 2399        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2400        * update the underlying database; instead the <code>updateRow</code> or
 2401        * <code>insertRow</code> methods are called to update the database.
 2402        *
 2403        * @param columnIndex the first column is 1, the second is 2, and so on
 2404        * @param x the new column value
 2405        * @throws SQLException if a database access error occurs
 2406        *            or this rowset does not currently have a valid connection,
 2407        *            prepared statement, and result set
 2408        *
 2409        */
 2410       public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
 2411           checkState();
 2412   
 2413           // To check the type and concurrency of the ResultSet
 2414           // to verify whether updates are possible or not
 2415           checkTypeConcurrency();
 2416   
 2417           rs.updateBigDecimal(columnIndex, x);
 2418       }
 2419   
 2420       /**
 2421        * Updates the designated column with a <code>String</code> value.
 2422        * The <code>updateXXX</code> methods are used to update column values in the
 2423        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2424        * update the underlying database; instead the <code>updateRow</code> or
 2425        * <code>insertRow</code> methods are called to update the database.
 2426        *
 2427        * @param columnIndex the first column is 1, the second is 2, and so on
 2428        * @param x the new column value
 2429        * @throws SQLException if a database access error occurs
 2430        *            or this rowset does not currently have a valid connection,
 2431        *            prepared statement, and result set
 2432        *
 2433        */
 2434       public void updateString(int columnIndex, String x) 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.updateString(columnIndex, x);
 2442       }
 2443   
 2444       /**
 2445        * Updates the designated column with a <code>byte</code> array value.
 2446        * The <code>updateXXX</code> methods are used to update column values in the
 2447        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2448        * update the underlying database; instead the <code>updateRow</code> or
 2449        * <code>insertRow</code> methods are called to update the database.
 2450        *
 2451        * @param columnIndex the first column is 1, the second is 2, and so on
 2452        * @param x the new column value
 2453        * @throws SQLException if a database access error occurs
 2454        *            or this rowset does not currently have a valid connection,
 2455        *            prepared statement, and result set
 2456        *
 2457        */
 2458       public void updateBytes(int columnIndex, byte x[]) throws SQLException {
 2459           checkState();
 2460   
 2461           // To check the type and concurrency of the ResultSet
 2462           // to verify whether updates are possible or not
 2463           checkTypeConcurrency();
 2464   
 2465           rs.updateBytes(columnIndex, x);
 2466       }
 2467   
 2468       /**
 2469        * Updates the designated column with a <code>java.sql.Date</code> value.
 2470        * The <code>updateXXX</code> methods are used to update column values in the
 2471        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2472        * update the underlying database; instead the <code>updateRow</code> or
 2473        * <code>insertRow</code> methods are called to update the database.
 2474        *
 2475        * @param columnIndex the first column is 1, the second is 2, and so on
 2476        * @param x the new column value
 2477        * @throws SQLException if a database access error occurs
 2478        *            or this rowset does not currently have a valid connection,
 2479        *            prepared statement, and result set
 2480        *
 2481        */
 2482       public void updateDate(int columnIndex, java.sql.Date x) throws SQLException {
 2483           checkState();
 2484   
 2485           // To check the type and concurrency of the ResultSet
 2486           // to verify whether updates are possible or not
 2487           checkTypeConcurrency();
 2488   
 2489           rs.updateDate(columnIndex, x);
 2490       }
 2491   
 2492   
 2493       /**
 2494        * Updates the designated column with a <code>java.sql.Time</code> value.
 2495        * The <code>updateXXX</code> methods are used to update column values in the
 2496        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2497        * update the underlying database; instead the <code>updateRow</code> or
 2498        * <code>insertRow</code> methods are called to update the database.
 2499        *
 2500        * @param columnIndex the first column is 1, the second is 2, and so on
 2501        * @param x the new column value
 2502        * @throws SQLException if a database access error occurs
 2503        *            or this rowset does not currently have a valid connection,
 2504        *            prepared statement, and result set
 2505        *
 2506        */
 2507       public void updateTime(int columnIndex, java.sql.Time x) throws SQLException {
 2508           checkState();
 2509   
 2510           // To check the type and concurrency of the ResultSet
 2511           // to verify whether updates are possible or not
 2512           checkTypeConcurrency();
 2513   
 2514           rs.updateTime(columnIndex, x);
 2515       }
 2516   
 2517       /**
 2518        * Updates the designated column with a <code>java.sql.Timestamp</code>
 2519        * value.
 2520        * The <code>updateXXX</code> methods are used to update column values in the
 2521        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2522        * update the underlying database; instead the <code>updateRow</code> or
 2523        * <code>insertRow</code> methods are called to update the database.
 2524        *
 2525        * @param columnIndex the first column is 1, the second is 2, and so on
 2526        * @param x the new column value
 2527        * @throws SQLException if a database access error occurs
 2528        *            or this rowset does not currently have a valid connection,
 2529        *            prepared statement, and result set
 2530        *
 2531        */
 2532       public void updateTimestamp(int columnIndex, java.sql.Timestamp x) throws SQLException {
 2533           checkState();
 2534   
 2535           // To check the type and concurrency of the ResultSet
 2536           // to verify whether updates are possible or not
 2537           checkTypeConcurrency();
 2538   
 2539           rs.updateTimestamp(columnIndex, x);
 2540       }
 2541   
 2542       /**
 2543        * Updates the designated column with an ascii stream value.
 2544        * The <code>updateXXX</code> methods are used to update column values in the
 2545        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2546        * update the underlying database; instead the <code>updateRow</code> or
 2547        * <code>insertRow</code> methods are called to update the database.
 2548        *
 2549        * @param columnIndex the first column is 1, the second is 2, and so on
 2550        * @param x the new column value
 2551        * @param length the length of the stream
 2552        * @throws SQLException if (1) a database access error occurs
 2553        *            (2) or this rowset does not currently have a valid connection,
 2554        *            prepared statement, and result set
 2555        *
 2556        */
 2557       public void updateAsciiStream(int columnIndex, java.io.InputStream x, int length) throws SQLException {
 2558           checkState();
 2559   
 2560           // To check the type and concurrency of the ResultSet
 2561           // to verify whether updates are possible or not
 2562           checkTypeConcurrency();
 2563   
 2564           rs.updateAsciiStream(columnIndex, x, length);
 2565       }
 2566   
 2567       /**
 2568        * Updates the designated column with a binary stream value.
 2569        * The <code>updateXXX</code> methods are used to update column values in the
 2570        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2571        * update the underlying database; instead the <code>updateRow</code> or
 2572        * <code>insertRow</code> methods are called to update the database.
 2573        *
 2574        * @param columnIndex the first column is 1, the second is 2, and so on
 2575        * @param x the new column value
 2576        * @param length the length of the stream
 2577        * @throws SQLException if a database access error occurs
 2578        *            or this rowset does not currently have a valid connection,
 2579        *            prepared statement, and result set
 2580        *
 2581        */
 2582       public void updateBinaryStream(int columnIndex, java.io.InputStream x, int length) throws SQLException {
 2583           checkState();
 2584   
 2585           // To check the type and concurrency of the ResultSet
 2586           // to verify whether updates are possible or not
 2587           checkTypeConcurrency();
 2588   
 2589           rs.updateBinaryStream(columnIndex, x, length);
 2590       }
 2591   
 2592       /**
 2593        * Updates the designated column with a character stream value.
 2594        * The <code>updateXXX</code> methods are used to update column values in the
 2595        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2596        * update the underlying database; instead the <code>updateRow</code> or
 2597        * <code>insertRow</code> methods are called to update the database.
 2598        *
 2599        * @param columnIndex the first column is 1, the second is 2, and so on
 2600        * @param x the new column value
 2601        * @param length the length of the stream
 2602        * @throws SQLException if a database access error occurs
 2603        *            or this rowset does not currently have a valid connection,
 2604        *            prepared statement, and result set
 2605        *
 2606        */
 2607       public void updateCharacterStream(int columnIndex, java.io.Reader x, int length) throws SQLException {
 2608           checkState();
 2609   
 2610           // To check the type and concurrency of the ResultSet
 2611           // to verify whether updates are possible or not
 2612           checkTypeConcurrency();
 2613   
 2614           rs.updateCharacterStream(columnIndex, x, length);
 2615       }
 2616   
 2617       /**
 2618        * Updates the designated column with an <code>Object</code> value.
 2619        * The <code>updateXXX</code> methods are used to update column values in the
 2620        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2621        * update the underlying database; instead the <code>updateRow</code> or
 2622        * <code>insertRow</code> methods are called to update the database.
 2623        *
 2624        * @param columnIndex the first column is 1, the second is 2, and so on
 2625        * @param x the new column value
 2626        * @param scale for <code>java.sql.Types.DECIMAl</code>
 2627        *  or <code>java.sql.Types.NUMERIC</code> types,
 2628        *  this is the number of digits after the decimal point.  For all other
 2629        *  types this value will be ignored.
 2630        * @throws SQLException if a database access error occurs
 2631        *            or this rowset does not currently have a valid connection,
 2632        *            prepared statement, and result set
 2633        *
 2634        */
 2635       public void updateObject(int columnIndex, Object x, int scale) throws SQLException {
 2636           checkState();
 2637   
 2638           // To check the type and concurrency of the ResultSet
 2639           // to verify whether updates are possible or not
 2640           checkTypeConcurrency();
 2641   
 2642           rs.updateObject(columnIndex, x, scale);
 2643       }
 2644   
 2645       /**
 2646        * Updates the designated column with an <code>Object</code> value.
 2647        * The <code>updateXXX</code> methods are used to update column values in the
 2648        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2649        * update the underlying database; instead the <code>updateRow</code> or
 2650        * <code>insertRow</code> methods are called to update the database.
 2651        *
 2652        * @param columnIndex the first column is 1, the second is 2, and so on
 2653        * @param x the new column value
 2654        * @throws SQLException if a database access error occurs
 2655        *            or this rowset does not currently have a valid connection,
 2656        *            prepared statement, and result set
 2657        *
 2658        */
 2659       public void updateObject(int columnIndex, Object x) throws SQLException {
 2660           checkState();
 2661   
 2662           // To check the type and concurrency of the ResultSet
 2663           // to verify whether updates are possible or not
 2664           checkTypeConcurrency();
 2665   
 2666           rs.updateObject(columnIndex, x);
 2667       }
 2668   
 2669       /**
 2670        * Updates the designated column with a <code>null</code> value.
 2671        * The <code>updateXXX</code> methods are used to update column values in the
 2672        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2673        * update the underlying database; instead the <code>updateRow</code> or
 2674        * <code>insertRow</code> methods are called to update the database.
 2675        *
 2676        * @param columnName the name of the column
 2677        * @throws SQLException if a database access error occurs
 2678        *            or this rowset does not currently have a valid connection,
 2679        *            prepared statement, and result set
 2680        *
 2681        */
 2682       public void updateNull(String columnName) throws SQLException {
 2683           updateNull(findColumn(columnName));
 2684       }
 2685   
 2686       /**
 2687        * Updates the designated column with a <code>boolean</code> value.
 2688        * The <code>updateXXX</code> methods are used to update column values in the
 2689        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2690        * update the underlying database; instead the <code>updateRow</code> or
 2691        * <code>insertRow</code> methods are called to update the database.
 2692        *
 2693        * @param columnName the name of the column
 2694        * @param x the new column value
 2695        * @throws SQLException if a database access error occurs
 2696        *
 2697        */
 2698       public void updateBoolean(String columnName, boolean x) throws SQLException {
 2699           updateBoolean(findColumn(columnName), x);
 2700       }
 2701   
 2702       /**
 2703        * Updates the designated column with a <code>byte</code> value.
 2704        * The <code>updateXXX</code> methods are used to update column values in the
 2705        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2706        * update the underlying database; instead the <code>updateRow</code> or
 2707        * <code>insertRow</code> methods are called to update the database.
 2708        *
 2709        * @param columnName the name of the column
 2710        * @param x the new column value
 2711        * @throws SQLException if a database access error occurs
 2712        *
 2713        */
 2714       public void updateByte(String columnName, byte x) throws SQLException {
 2715           updateByte(findColumn(columnName), x);
 2716       }
 2717   
 2718       /**
 2719        * Updates the designated column with a <code>short</code> value.
 2720        * The <code>updateXXX</code> methods are used to update column values in the
 2721        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2722        * update the underlying database; instead the <code>updateRow</code> or
 2723        * <code>insertRow</code> methods are called to update the database.
 2724        *
 2725        * @param columnName the name of the column
 2726        * @param x the new column value
 2727        * @throws SQLException if a database access error occurs
 2728        *
 2729        */
 2730       public void updateShort(String columnName, short x) throws SQLException {
 2731           updateShort(findColumn(columnName), x);
 2732       }
 2733   
 2734       /**
 2735        * Updates the designated column with an <code>int</code> value.
 2736        * The <code>updateXXX</code> methods are used to update column values in the
 2737        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2738        * update the underlying database; instead the <code>updateRow</code> or
 2739        * <code>insertRow</code> methods are called to update the database.
 2740        *
 2741        * @param columnName the name of the column
 2742        * @param x the new column value
 2743        * @throws SQLException if a database access error occurs
 2744        *
 2745        */
 2746       public void updateInt(String columnName, int x) throws SQLException {
 2747           updateInt(findColumn(columnName), x);
 2748       }
 2749   
 2750       /**
 2751        * Updates the designated column with a <code>long</code> value.
 2752        * The <code>updateXXX</code> methods are used to update column values in the
 2753        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2754        * update the underlying database; instead the <code>updateRow</code> or
 2755        * <code>insertRow</code> methods are called to update the database.
 2756        *
 2757        * @param columnName the name of the column
 2758        * @param x the new column value
 2759        * @throws SQLException if a database access error occurs
 2760        *
 2761        */
 2762       public void updateLong(String columnName, long x) throws SQLException {
 2763           updateLong(findColumn(columnName), x);
 2764       }
 2765   
 2766       /**
 2767        * Updates the designated column with a <code>float </code> value.
 2768        * The <code>updateXXX</code> methods are used to update column values in the
 2769        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2770        * update the underlying database; instead the <code>updateRow</code> or
 2771        * <code>insertRow</code> methods are called to update the database.
 2772        *
 2773        * @param columnName the name of the column
 2774        * @param x the new column value
 2775        * @throws SQLException if a database access error occurs
 2776        *
 2777        */
 2778       public void updateFloat(String columnName, float x) throws SQLException {
 2779           updateFloat(findColumn(columnName), x);
 2780       }
 2781   
 2782       /**
 2783        * Updates the designated column with a <code>double</code> value.
 2784        * The <code>updateXXX</code> methods are used to update column values in the
 2785        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2786        * update the underlying database; instead the <code>updateRow</code> or
 2787        * <code>insertRow</code> methods are called to update the database.
 2788        *
 2789        * @param columnName the name of the column
 2790        * @param x the new column value
 2791        * @throws SQLException if a database access error occurs
 2792        *
 2793        */
 2794       public void updateDouble(String columnName, double x) throws SQLException {
 2795           updateDouble(findColumn(columnName), x);
 2796       }
 2797   
 2798       /**
 2799        * Updates the designated column with a <code>java.sql.BigDecimal</code>
 2800        * value.
 2801        * The <code>updateXXX</code> methods are used to update column values in the
 2802        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2803        * update the underlying database; instead the <code>updateRow</code> or
 2804        * <code>insertRow</code> methods are called to update the database.
 2805        *
 2806        * @param columnName the name of the column
 2807        * @param x the new column value
 2808        * @throws SQLException if a database access error occurs
 2809        *
 2810        */
 2811       public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException {
 2812           updateBigDecimal(findColumn(columnName), x);
 2813       }
 2814   
 2815       /**
 2816        * Updates the designated column with a <code>String</code> value.
 2817        * The <code>updateXXX</code> methods are used to update column values in the
 2818        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2819        * update the underlying database; instead the <code>updateRow</code> or
 2820        * <code>insertRow</code> methods are called to update the database.
 2821        *
 2822        * @param columnName the name of the column
 2823        * @param x the new column value
 2824        * @throws SQLException if a database access error occurs
 2825        *
 2826        */
 2827       public void updateString(String columnName, String x) throws SQLException {
 2828           updateString(findColumn(columnName), x);
 2829       }
 2830   
 2831       /**
 2832        * Updates the designated column with a <code>boolean</code> value.
 2833        * The <code>updateXXX</code> methods are used to update column values in the
 2834        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2835        * update the underlying database; instead the <code>updateRow</code> or
 2836        * <code>insertRow</code> methods are called to update the database.
 2837        *
 2838        * JDBC 2.0
 2839        *
 2840        * Updates a column with a byte array value.
 2841        *
 2842        * The <code>updateXXX</code> methods are used to update column values in the
 2843        * current row, or the insert row.  The <code>updateXXX</code> methods do not
 2844        * update the underlying database; instead the <code>updateRow</code> or <code>insertRow</code>
 2845        * methods are called to update the database.
 2846        *
 2847        * @param columnName the name of the column
 2848        * @param x the new column value
 2849        * @throws SQLException if a database access error occurs
 2850        *
 2851        */
 2852       public void updateBytes(String columnName, byte x[]) throws SQLException {
 2853           updateBytes(findColumn(columnName), x);
 2854       }
 2855   
 2856       /**
 2857        * Updates the designated column with a <code>java.sql.Date</code> value.
 2858        * The <code>updateXXX</code> methods are used to update column values in the
 2859        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2860        * update the underlying database; instead the <code>updateRow</code> or
 2861        * <code>insertRow</code> methods are called to update the database.
 2862        *
 2863        * @param columnName the name of the column
 2864        * @param x the new column value
 2865        * @throws SQLException if a database access error occurs
 2866        *
 2867        */
 2868       public void updateDate(String columnName, java.sql.Date x) throws SQLException {
 2869           updateDate(findColumn(columnName), x);
 2870       }
 2871   
 2872       /**
 2873        * Updates the designated column with a <code>java.sql.Time</code> value.
 2874        * The <code>updateXXX</code> methods are used to update column values in the
 2875        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2876        * update the underlying database; instead the <code>updateRow</code> or
 2877        * <code>insertRow</code> methods are called to update the database.
 2878        *
 2879        * @param columnName the name of the column
 2880        * @param x the new column value
 2881        * @throws SQLException if a database access error occurs
 2882        *
 2883        */
 2884       public void updateTime(String columnName, java.sql.Time x) throws SQLException {
 2885           updateTime(findColumn(columnName), x);
 2886       }
 2887   
 2888       /**
 2889        * Updates the designated column with a <code>java.sql.Timestamp</code>
 2890        * value.
 2891        * The <code>updateXXX</code> methods are used to update column values in the
 2892        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2893        * update the underlying database; instead the <code>updateRow</code> or
 2894        * <code>insertRow</code> methods are called to update the database.
 2895        *
 2896        * @param columnName the name of the column
 2897        * @param x the new column value
 2898        * @throws SQLException if a database access error occurs
 2899        *
 2900        */
 2901       public void updateTimestamp(String columnName, java.sql.Timestamp x) throws SQLException {
 2902           updateTimestamp(findColumn(columnName), x);
 2903       }
 2904   
 2905       /**
 2906        * Updates the designated column with an ascii stream value.
 2907        * The <code>updateXXX</code> methods are used to update column values in the
 2908        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2909        * update the underlying database; instead the <code>updateRow</code> or
 2910        * <code>insertRow</code> methods are called to update the database.
 2911        *
 2912        * @param columnName the name of the column
 2913        * @param x the new column value
 2914        * @param length the length of the stream
 2915        * @throws SQLException if a database access error occurs
 2916        *
 2917        */
 2918       public void updateAsciiStream(String columnName, java.io.InputStream x, int length) throws SQLException {
 2919           updateAsciiStream(findColumn(columnName), x, length);
 2920       }
 2921   
 2922       /**
 2923        * Updates the designated column with a binary stream value.
 2924        * The <code>updateXXX</code> methods are used to update column values in the
 2925        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2926        * update the underlying database; instead the <code>updateRow</code> or
 2927        * <code>insertRow</code> methods are called to update the database.
 2928        *
 2929        * @param columnName the name of the column
 2930        * @param x the new column value
 2931        * @param length the length of the stream
 2932        * @throws SQLException if a database access error occurs
 2933        *
 2934        */
 2935       public void updateBinaryStream(String columnName, java.io.InputStream x, int length) throws SQLException {
 2936           updateBinaryStream(findColumn(columnName), x, length);
 2937       }
 2938   
 2939       /**
 2940        * Updates the designated column with a character stream value.
 2941        * The <code>updateXXX</code> methods are used to update column values
 2942        * in the current row or the insert row.  The <code>updateXXX</code>
 2943        * methods do not update the underlying database; instead the
 2944        * <code>updateRow</code> or <code>insertRow</code> methods are called
 2945        * to update the database.
 2946        *
 2947        * @param columnName the name of the column
 2948        * @param reader the new column <code>Reader</code> stream value
 2949        * @param length the length of the stream
 2950        * @throws SQLException if a database access error occurs
 2951        *
 2952        */
 2953       public void updateCharacterStream(String columnName, java.io.Reader reader, int length) throws SQLException {
 2954           updateCharacterStream(findColumn(columnName), reader, length);
 2955       }
 2956   
 2957       /**
 2958        * Updates the designated column with an <code>Object</code> value.
 2959        * The <code>updateXXX</code> methods are used to update column values in the
 2960        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2961        * update the underlying database; instead the <code>updateRow</code> or
 2962        * <code>insertRow</code> methods are called to update the database.
 2963        *
 2964        * @param columnName the name of the column
 2965        * @param x the new column value
 2966        * @param scale for <code>java.sql.Types.DECIMAL</code>
 2967        *  or <code>java.sql.Types.NUMERIC</code> types,
 2968        *  this is the number of digits after the decimal point.  For all other
 2969        *  types this value will be ignored.
 2970        * @throws SQLException if a database access error occurs
 2971        *
 2972        */
 2973       public void updateObject(String columnName, Object x, int scale) throws SQLException {
 2974           updateObject(findColumn(columnName), x, scale);
 2975       }
 2976   
 2977       /**
 2978        * Updates the designated column with an <code>Object</code> value.
 2979        * The <code>updateXXX</code> methods are used to update column values in the
 2980        * current row or the insert row.  The <code>updateXXX</code> methods do not
 2981        * update the underlying database; instead the <code>updateRow</code> or
 2982        * <code>insertRow</code> methods are called to update the database.
 2983        *
 2984        * @param columnName the name of the column
 2985        * @param x the new column value
 2986        * @throws SQLException if a database access error occurs
 2987        *
 2988        */
 2989       public void updateObject(String columnName, Object x) throws SQLException {
 2990           updateObject(findColumn(columnName), x);
 2991       }
 2992   
 2993       /**
 2994        * Inserts the contents of the insert row into this
 2995        * <code>ResultSet</code> object and into the database
 2996        * and also notifies listeners that a row has changed.
 2997        * The cursor must be on the insert row when this method is called.
 2998        *
 2999        * @throws SQLException if (1) a database access error occurs,
 3000        *            (2) this method is called when the cursor is not
 3001        *             on the insert row, (3) not all non-nullable columns in
 3002        *             the insert row have been given a value, or (4) this
 3003        *             rowset does not currently have a valid connection,
 3004        *             prepared statement, and result set
 3005        */
 3006       public void insertRow() throws SQLException {
 3007           checkState();
 3008   
 3009           rs.insertRow();
 3010           notifyRowChanged();
 3011       }
 3012   
 3013       /**
 3014        * Updates the underlying database with the new contents of the
 3015        * current row of this rowset's <code>ResultSet</code> object
 3016        * and notifies listeners that a row has changed.
 3017        * This method cannot be called when the cursor is on the insert row.
 3018        *
 3019        * @throws SQLException if (1) a database access error occurs,
 3020        *            (2) this method is called when the cursor is
 3021        *             on the insert row, (3) the concurrency of the result
 3022        *             set is <code>ResultSet.CONCUR_READ_ONLY</code>, or
 3023        *             (4) this rowset does not currently have a valid connection,
 3024        *             prepared statement, and result set
 3025        */
 3026       public void updateRow() throws SQLException {
 3027           checkState();
 3028   
 3029           rs.updateRow();
 3030           notifyRowChanged();
 3031       }
 3032   
 3033       /**
 3034        * Deletes the current row from this rowset's <code>ResultSet</code> object
 3035        * and from the underlying database and also notifies listeners that a row
 3036        * has changed.  This method cannot be called when the cursor is on the insert
 3037        * row.
 3038        *
 3039        * @throws SQLException if a database access error occurs
 3040        * or if this method is called when the cursor is on the insert row
 3041        * @throws SQLException if (1) a database access error occurs,
 3042        *            (2) this method is called when the cursor is before the
 3043        *            first row, after the last row, or on the insert row,
 3044        *            (3) the concurrency of this rowset's result
 3045        *            set is <code>ResultSet.CONCUR_READ_ONLY</code>, or
 3046        *            (4) this rowset does not currently have a valid connection,
 3047        *            prepared statement, and result set
 3048        */
 3049       public void deleteRow() throws SQLException {
 3050           checkState();
 3051   
 3052           rs.deleteRow();
 3053           notifyRowChanged();
 3054       }
 3055   
 3056       /**
 3057        * Refreshes the current row of this rowset's <code>ResultSet</code>
 3058        * object with its most recent value in the database.  This method
 3059        * cannot be called when the cursor is on the insert row.
 3060        *
 3061        * <P>The <code>refreshRow</code> method provides a way for an
 3062        * application to explicitly tell the JDBC driver to refetch
 3063        * a row(s) from the database.  An application may want to call
 3064        * <code>refreshRow</code> when caching or prefetching is being
 3065        * done by the JDBC driver to fetch the latest value of a row
 3066        * from the database.  The JDBC driver may actually refresh multiple
 3067        * rows at once if the fetch size is greater than one.
 3068        *
 3069        * <P> All values are refetched subject to the transaction isolation
 3070        * level and cursor sensitivity.  If <code>refreshRow</code> is called after
 3071        * calling an <code>updateXXX</code> method, but before calling
 3072        * the method <code>updateRow</code>, then the
 3073        * updates made to the row are lost.  Calling the method
 3074        * <code>refreshRow</code> frequently will likely slow performance.
 3075        *
 3076        * @throws SQLException if (1) a database access error occurs,
 3077        *            (2) this method is called when the cursor is
 3078        *             on the insert row, or (3) this rowset does not
 3079        *             currently have a valid connection, prepared statement,
 3080        *             and result set
 3081        *
 3082        */
 3083       public void refreshRow() throws SQLException {
 3084           checkState();
 3085   
 3086           rs.refreshRow();
 3087       }
 3088   
 3089       /**
 3090        * Cancels the updates made to the current row in this
 3091        * <code>ResultSet</code> object and notifies listeners that a row
 3092        * has changed. This method may be called after calling an
 3093        * <code>updateXXX</code> method(s) and before calling
 3094        * the method <code>updateRow</code> to roll back
 3095        * the updates made to a row.  If no updates have been made or
 3096        * <code>updateRow</code> has already been called, this method has no
 3097        * effect.
 3098        *
 3099        * @throws SQLException if (1) a database access error occurs,
 3100        *            (2) this method is called when the cursor is
 3101        *             on the insert row, or (3) this rowset does not
 3102        *             currently have a valid connection, prepared statement,
 3103        *             and result set
 3104        */
 3105       public void cancelRowUpdates() throws SQLException {
 3106           checkState();
 3107   
 3108           rs.cancelRowUpdates();
 3109   
 3110           notifyRowChanged();
 3111       }
 3112   
 3113       /**
 3114        * Moves the cursor to the insert row.  The current cursor position is
 3115        * remembered while the cursor is positioned on the insert row.
 3116        *
 3117        * The insert row is a special row associated with an updatable
 3118        * result set.  It is essentially a buffer where a new row may
 3119        * be constructed by calling the <code>updateXXX</code> methods prior to
 3120        * inserting the row into the result set.
 3121        *
 3122        * Only the <code>updateXXX</code>, <code>getXXX</code>,
 3123        * and <code>insertRow</code> methods may be
 3124        * called when the cursor is on the insert row.  All of the columns in
 3125        * a result set must be given a value each time this method is
 3126        * called before calling <code>insertRow</code>.
 3127        * An <code>updateXXX</code> method must be called before a
 3128        * <code>getXXX</code> method can be called on a column value.
 3129        *
 3130        * @throws SQLException if (1) a database access error occurs,
 3131        *            (2) this rowset's <code>ResultSet</code> object is
 3132        *             not updatable, or (3) this rowset does not
 3133        *             currently have a valid connection, prepared statement,
 3134        *             and result set
 3135        *
 3136        */
 3137       public void moveToInsertRow() throws SQLException {
 3138           checkState();
 3139   
 3140           rs.moveToInsertRow();
 3141       }
 3142   
 3143       /**
 3144        * Moves the cursor to the remembered cursor position, usually the
 3145        * current row.  This method has no effect if the cursor is not on
 3146        * the insert row.
 3147        *
 3148        * @throws SQLException if (1) a database access error occurs,
 3149        *            (2) this rowset's <code>ResultSet</code> object is
 3150        *             not updatable, or (3) this rowset does not
 3151        *             currently have a valid connection, prepared statement,
 3152        *             and result set
 3153        */
 3154       public void moveToCurrentRow() throws SQLException {
 3155           checkState();
 3156   
 3157           rs.moveToCurrentRow();
 3158       }
 3159   
 3160       /**
 3161        * Returns the <code>Statement</code> object that produced this
 3162        * <code>ResultSet</code> object.
 3163        * If the result set was generated some other way, such as by a
 3164        * <code>DatabaseMetaData</code> method, this method returns
 3165        * <code>null</code>.
 3166        *
 3167        * @return the <code>Statment</code> object that produced
 3168        * this rowset's <code>ResultSet</code> object or <code>null</code>
 3169        * if the result set was produced some other way
 3170        * @throws SQLException if a database access error occurs
 3171        */
 3172       public java.sql.Statement getStatement() throws SQLException {
 3173   
 3174           if(rs != null)
 3175           {
 3176              return rs.getStatement();
 3177           } else {
 3178              return null;
 3179           }
 3180       }
 3181   
 3182       /**
 3183        * Returns the value of the designated column in the current row
 3184        * of this rowset's <code>ResultSet</code> object as an <code>Object</code>.
 3185        * This method uses the given <code>Map</code> object
 3186        * for the custom mapping of the
 3187        * SQL structured or distinct type that is being retrieved.
 3188        *
 3189        * @param i the first column is 1, the second is 2, and so on
 3190        * @param map a <code>java.util.Map</code> object that contains the mapping
 3191        * from SQL type names to classes in the Java programming language
 3192        * @return an <code>Object</code> in the Java programming language
 3193        * representing the SQL value
 3194        * @throws SQLException if (1) a database access error occurs
 3195        *            or (2) this rowset does not currently have a valid connection,
 3196        *            prepared statement, and result set
 3197        */
 3198       public Object getObject(int i, java.util.Map<String,Class<?>> map)
 3199           throws SQLException
 3200       {
 3201           checkState();
 3202   
 3203           return rs.getObject(i, map);
 3204       }
 3205   
 3206       /**
 3207        * Returns the value of the designated column in the current row
 3208        * of this rowset's <code>ResultSet</code> object as a <code>Ref</code> object.
 3209        *
 3210        * @param i the first column is 1, the second is 2, and so on
 3211        * @return a <code>Ref</code> object representing an SQL <code>REF</code> value
 3212        * @throws SQLException if (1) a database access error occurs
 3213        *            or (2) this rowset does not currently have a valid connection,
 3214        *            prepared statement, and result set
 3215        */
 3216       public Ref getRef(int i) throws SQLException {
 3217           checkState();
 3218   
 3219           return rs.getRef(i);
 3220       }
 3221   
 3222   
 3223       /**
 3224        * Returns the value of the designated column in the current row
 3225        * of this rowset's <code>ResultSet</code> object as a <code>Blob</code> object.
 3226        *
 3227        * @param i the first column is 1, the second is 2, and so on
 3228        * @return a <code>Blob</code> object representing the SQL <code>BLOB</code>
 3229        *         value in the specified column
 3230        * @throws SQLException if (1) a database access error occurs
 3231        *            or (2) this rowset does not currently have a valid connection,
 3232        *            prepared statement, and result set
 3233        */
 3234       public Blob getBlob(int i) throws SQLException {
 3235           checkState();
 3236   
 3237           return rs.getBlob(i);
 3238       }
 3239   
 3240       /**
 3241        * Returns the value of the designated column in the current row
 3242        * of this rowset's <code>ResultSet</code> object as a <code>Clob</code> object.
 3243        *
 3244        * @param i the first column is 1, the second is 2, and so on
 3245        * @return a <code>Clob</code> object representing the SQL <code>CLOB</code>
 3246        *         value in the specified column
 3247        * @throws SQLException if (1) a database access error occurs
 3248        *            or (2) this rowset does not currently have a valid connection,
 3249        *            prepared statement, and result set
 3250        */
 3251       public Clob getClob(int i) throws SQLException {
 3252           checkState();
 3253   
 3254           return rs.getClob(i);
 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>Array</code> object.
 3260        *
 3261        * @param i the first column is 1, the second is 2, and so on.
 3262        * @return an <code>Array</code> object representing the SQL <code>ARRAY</code>
 3263        *         value in the specified column
 3264        * @throws SQLException if (1) a database access error occurs
 3265        *            or (2) this rowset does not currently have a valid connection,
 3266        *            prepared statement, and result set
 3267        */
 3268       public Array getArray(int i) throws SQLException {
 3269           checkState();
 3270   
 3271           return rs.getArray(i);
 3272       }
 3273   
 3274       /**
 3275        * Returns the value of the designated column in the current row
 3276        * of this rowset's <code>ResultSet</code> object as an <code>Object</code>.
 3277        * This method uses the specified <code>Map</code> object for
 3278        * custom mapping if appropriate.
 3279        *
 3280        * @param colName the name of the column from which to retrieve the value
 3281        * @param map a <code>java.util.Map</code> object that contains the mapping
 3282        * from SQL type names to classes in the Java programming language
 3283        * @return an <code>Object</code> representing the SQL
 3284        *         value in the specified column
 3285        * @throws SQLException if (1) a database access error occurs
 3286        *            or (2) this rowset does not currently have a valid connection,
 3287        *            prepared statement, and result set
 3288        */
 3289       public Object getObject(String colName, java.util.Map<String,Class<?>> map)
 3290           throws SQLException
 3291       {
 3292           return getObject(findColumn(colName), map);
 3293       }
 3294   
 3295       /**
 3296        * Returns the value of the designated column in the current row
 3297        * of this rowset's <code>ResultSet</code> object as a <code>Ref</code> object.
 3298        *
 3299        * @param colName the column name
 3300        * @return a <code>Ref</code> object representing the SQL <code>REF</code> value in
 3301        *         the specified column
 3302        * @throws SQLException if (1) a database access error occurs
 3303        *            or (2) this rowset does not currently have a valid connection,
 3304        *            prepared statement, and result set
 3305        */
 3306       public Ref getRef(String colName) throws SQLException {
 3307           return getRef(findColumn(colName));
 3308       }
 3309   
 3310       /**
 3311        * Returns the value of the designated column in the current row
 3312        * of this rowset's <code>ResultSet</code> object as a <code>Blob</code> object.
 3313        *
 3314        * @param colName the name of the column from which to retrieve the value
 3315        * @return a <code>Blob</code> object representing the SQL <code>BLOB</code>
 3316        *         value in the specified column
 3317        * @throws SQLException if (1) a database access error occurs
 3318        *            or (2) this rowset does not currently have a valid connection,
 3319        *            prepared statement, and result set
 3320        */
 3321       public Blob getBlob(String colName) throws SQLException {
 3322           return getBlob(findColumn(colName));
 3323       }
 3324   
 3325       /**
 3326        * Returns the value of the designated column in the current row
 3327        * of this rowset's <code>ResultSet</code> object as a <code>Clob</code> object.
 3328        *
 3329        * @param colName the name of the column from which to retrieve the value
 3330        * @return a <code>Clob</code> object representing the SQL <code>CLOB</code>
 3331        *         value in the specified column
 3332        * @throws SQLException if (1) a database access error occurs
 3333        *            or (2) this rowset does not currently have a valid connection,
 3334        *            prepared statement, and result set
 3335        */
 3336       public Clob getClob(String colName) throws SQLException {
 3337           return getClob(findColumn(colName));
 3338       }
 3339   
 3340       /**
 3341        * Returns the value of the designated column in the current row
 3342        * of this rowset's <code>ResultSet</code> object as an <code>Array</code> object.
 3343        *
 3344        * @param colName the name of the column from which to retrieve the value
 3345        * @return an <code>Array</code> object representing the SQL <code>ARRAY</code>
 3346        *         value in the specified column
 3347        * @throws SQLException if (1) a database access error occurs
 3348        *            or (2) this rowset does not currently have a valid connection,
 3349        *            prepared statement, and result set
 3350        */
 3351       public Array getArray(String colName) throws SQLException {
 3352           return getArray(findColumn(colName));
 3353       }
 3354   
 3355       /**
 3356        * Returns the value of the designated column in the current row
 3357        * of this rowset's <code>ResultSet</code> object as a <code>java.sql.Date</code>
 3358        * object. This method uses the given calendar to construct an appropriate
 3359        * millisecond value for the date if the underlying database does not store
 3360        * timezone information.
 3361        *
 3362        * @param columnIndex the first column is 1, the second is 2, and so on
 3363        * @param cal the <code>java.util.Calendar</code> object
 3364        *        to use in constructing the date
 3365        * @return the column value as a <code>java.sql.Date</code> object;
 3366        *         if the value is SQL <code>NULL</code>,
 3367        *         the value returned is <code>null</code>
 3368        * @throws SQLException if (1) a database access error occurs
 3369        *            or (2) this rowset does not currently have a valid connection,
 3370        *            prepared statement, and result set
 3371        */
 3372       public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLException {
 3373           checkState();
 3374   
 3375           return rs.getDate(columnIndex, cal);
 3376       }
 3377   
 3378       /**
 3379        * Returns the value of the designated column in the current row
 3380        * of this rowset's <code>ResultSet</code> object as a <code>java.sql.Date</code>
 3381        * object. This method uses the given calendar to construct an appropriate
 3382        * millisecond value for the date if the underlying database does not store
 3383        * timezone information.
 3384        *
 3385        * @param columnName the SQL name of the column from which to retrieve the value
 3386        * @param cal the <code>java.util.Calendar</code> object
 3387        *        to use in constructing the date
 3388        * @return the column value as a <code>java.sql.Date</code> object;
 3389        *         if the value is SQL <code>NULL</code>,
 3390        *         the value returned is <code>null</code>
 3391        * @throws SQLException if a database access error occurs
 3392        *            or this rowset does not currently have a valid connection,
 3393        *            prepared statement, and result set
 3394        *
 3395        */
 3396       public java.sql.Date getDate(String columnName, Calendar cal) throws SQLException {
 3397           return getDate(findColumn(columnName), cal);
 3398       }
 3399   
 3400       /**
 3401        * Returns the value of the designated column in the current row
 3402        * of this rowset's <code>ResultSet</code> object as a <code>java.sql.Time</code>
 3403        * object. This method uses the given calendar to construct an appropriate
 3404        * millisecond value for the date if the underlying database does not store
 3405        * timezone information.
 3406        *
 3407        * @param columnIndex the first column is 1, the second is 2, and so on
 3408        * @param cal the <code>java.util.Calendar</code> object
 3409        *        to use in constructing the time
 3410        * @return the column value as a <code>java.sql.Time</code> object;
 3411        *         if the value is SQL <code>NULL</code>,
 3412        *         the value returned is <code>null</code> in the Java programming language
 3413        * @throws SQLException if a database access error occurs
 3414        *            or this rowset does not currently have a valid connection,
 3415        *            prepared statement, and result set
 3416        */
 3417       public java.sql.Time getTime(int columnIndex, Calendar cal) throws SQLException {
 3418           checkState();
 3419   
 3420           return rs.getTime(columnIndex, cal);
 3421       }
 3422   
 3423       /**
 3424        * Returns the value of the designated column in the current row
 3425        * of this rowset's <code>ResultSet</code> object as a <code>java.sql.Time</code>
 3426        * object. This method uses the given calendar to construct an appropriate
 3427        * millisecond value for the date if the underlying database does not store
 3428        * timezone information.
 3429        *
 3430        * @param columnName the SQL name of the column
 3431        * @param cal the <code>java.util.Calendar</code> object
 3432        *        to use in constructing the time
 3433        * @return the column value as a <code>java.sql.Time</code> object;
 3434        *         if the value is SQL <code>NULL</code>,
 3435        *         the value returned is <code>null</code> in the Java programming language
 3436        * @throws SQLException if a database access error occurs
 3437        *            or this rowset does not currently have a valid connection,
 3438        *            prepared statement, and result set
 3439        */
 3440       public java.sql.Time getTime(String columnName, Calendar cal) throws SQLException {
 3441           return getTime(findColumn(columnName), cal);
 3442       }
 3443   
 3444       /**
 3445        * Returns the value of the designated column in the current row
 3446        * of this rowset's <code>ResultSet</code> object as a
 3447        * <code>java.sql.Timestamp</code> object.
 3448        * This method uses the given calendar to construct an appropriate millisecond
 3449        * value for the timestamp if the underlying database does not store
 3450        * timezone information.
 3451        *
 3452        * @param columnIndex the first column is 1, the second is 2, and so on
 3453        * @param cal the <code>java.util.Calendar</code> object
 3454        *        to use in constructing the timestamp
 3455        * @return the column value as a <code>java.sql.Timestamp</code> object;
 3456        *         if the value is SQL <code>NULL</code>,
 3457        *         the value returned is <code>null</code>
 3458        * @throws SQLException if a database access error occurs
 3459        *            or this rowset does not currently have a valid connection,
 3460        *            prepared statement, and result set
 3461        */
 3462       public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
 3463           checkState();
 3464   
 3465           return rs.getTimestamp(columnIndex, cal);
 3466       }
 3467   
 3468       /**
 3469        * Returns the value of the designated column in the current row
 3470        * of this rowset's <code>ResultSet</code> object as a
 3471        * <code>java.sql.Timestamp</code> object.
 3472        * This method uses the given calendar to construct an appropriate millisecond
 3473        * value for the timestamp if the underlying database does not store
 3474        * timezone information.
 3475        *
 3476        * @param columnName the SQL name of the column
 3477        * @param cal the <code>java.util.Calendar</code> object
 3478        *        to use in constructing the timestamp
 3479        * @return the column value as a <code>java.sql.Timestamp</code> object;
 3480        *         if the value is SQL <code>NULL</code>,
 3481        *         the value returned is <code>null</code>
 3482        * @throws SQLException if a database access error occurs
 3483        *            or this rowset does not currently have a valid connection,
 3484        *            prepared statement, and result set
 3485        */
 3486       public java.sql.Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException {
 3487           return getTimestamp(findColumn(columnName), cal);
 3488       }
 3489   
 3490   
 3491       /**
 3492        * Sets the designated column in either the current row or the insert
 3493        * row of this <code>JdbcRowSetImpl</code> object with the given
 3494        * <code>double</code> value.
 3495        *
 3496        * This method updates a column value in either the current row or
 3497        * the insert row of this rowset, but it does not update the
 3498        * database.  If the cursor is on a row in the rowset, the
 3499        * method {@link #updateRow} must be called to update the database.
 3500        * If the cursor is on the insert row, the method {@link #insertRow}
 3501        * must be called, which will insert the new row into both this rowset
 3502        * and the database. Both of these methods must be called before the
 3503        * cursor moves to another row.
 3504        *
 3505        * @param columnIndex the first column is <code>1</code>, the second
 3506        *        is <code>2</code>, and so on; must be <code>1</code> or larger
 3507        *        and equal to or less than the number of columns in this rowset
 3508        * @param ref the new <code>Ref</code> column value
 3509        * @throws SQLException if (1) the given column index is out of bounds,
 3510        *            (2) the cursor is not on one of this rowset's rows or its
 3511        *            insert row, or (3) this rowset is
 3512        *            <code>ResultSet.CONCUR_READ_ONLY</code>
 3513        */
 3514       public void updateRef(int columnIndex, java.sql.Ref ref)
 3515           throws SQLException {
 3516           checkState();
 3517           rs.updateRef(columnIndex, ref);
 3518       }
 3519   
 3520       /**
 3521        * Sets the designated column in either the current row or the insert
 3522        * row of this <code>JdbcRowSetImpl</code> object with the given
 3523        * <code>double</code> value.
 3524        *
 3525        * This method updates a column value in either the current row or
 3526        * the insert row of this rowset, but it does not update the
 3527        * database.  If the cursor is on a row in the rowset, the
 3528        * method {@link #updateRow} must be called to update the database.
 3529        * If the cursor is on the insert row, the method {@link #insertRow}
 3530        * must be called, which will insert the new row into both this rowset
 3531        * and the database. Both of these methods must be called before the
 3532        * cursor moves to another row.
 3533        *
 3534        * @param columnName a <code>String</code> object that must match the
 3535        *        SQL name of a column in this rowset, ignoring case
 3536        * @param ref the new column value
 3537        * @throws SQLException if (1) the given column name does not match the
 3538        *            name of a column in this rowset, (2) the cursor is not on
 3539        *            one of this rowset's rows or its insert row, or (3) this
 3540        *            rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
 3541        */
 3542       public void updateRef(String columnName, java.sql.Ref ref)
 3543           throws SQLException {
 3544           updateRef(findColumn(columnName), ref);
 3545       }
 3546   
 3547       /**
 3548        * Sets the designated column in either the current row or the insert
 3549        * row of this <code>JdbcRowSetImpl</code> object with the given
 3550        * <code>double</code> value.
 3551        *
 3552        * This method updates a column value in either the current row or
 3553        * the insert row of this rowset, but it does not update the
 3554        * database.  If the cursor is on a row in the rowset, the
 3555        * method {@link #updateRow} must be called to update the database.
 3556        * If the cursor is on the insert row, the method {@link #insertRow}
 3557        * must be called, which will insert the new row into both this rowset
 3558        * and the database. Both of these methods must be called before the
 3559        * cursor moves to another row.
 3560        *
 3561        * @param columnIndex the first column is <code>1</code>, the second
 3562        *        is <code>2</code>, and so on; must be <code>1</code> or larger
 3563        *        and equal to or less than the number of columns in this rowset
 3564        * @param c the new column <code>Clob</code> value
 3565        * @throws SQLException if (1) the given column index is out of bounds,
 3566        *            (2) the cursor is not on one of this rowset's rows or its
 3567        *            insert row, or (3) this rowset is
 3568        *            <code>ResultSet.CONCUR_READ_ONLY</code>
 3569        */
 3570       public void updateClob(int columnIndex, Clob c) throws SQLException {
 3571           checkState();
 3572           rs.updateClob(columnIndex, c);
 3573       }
 3574   
 3575   
 3576       /**
 3577        * Sets the designated column in either the current row or the insert
 3578        * row of this <code>JdbcRowSetImpl</code> object with the given
 3579        * <code>double</code> value.
 3580        *
 3581        * This method updates a column value in either the current row or
 3582        * the insert row of this rowset, but it does not update the
 3583        * database.  If the cursor is on a row in the rowset, the
 3584        * method {@link #updateRow} must be called to update the database.
 3585        * If the cursor is on the insert row, the method {@link #insertRow}
 3586        * must be called, which will insert the new row into both this rowset
 3587        * and the database. Both of these methods must be called before the
 3588        * cursor moves to another row.
 3589        *
 3590        * @param columnName a <code>String</code> object that must match the
 3591        *        SQL name of a column in this rowset, ignoring case
 3592        * @param c the new column <code>Clob</code> value
 3593        * @throws SQLException if (1) the given column name does not match the
 3594        *            name of a column in this rowset, (2) the cursor is not on
 3595        *            one of this rowset's rows or its insert row, or (3) this
 3596        *            rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
 3597        */
 3598       public void updateClob(String columnName, Clob c) throws SQLException {
 3599           updateClob(findColumn(columnName), c);
 3600       }
 3601   
 3602       /**
 3603        * Sets the designated column in either the current row or the insert
 3604        * row of this <code>JdbcRowSetImpl</code> object with the given
 3605        * <code>java.sql.Blob</code> value.
 3606        *
 3607        * This method updates a column value in either the current row or
 3608        * the insert row of this rowset, but it does not update the
 3609        * database.  If the cursor is on a row in the rowset, the
 3610        * method {@link #updateRow} must be called to update the database.
 3611        * If the cursor is on the insert row, the method {@link #insertRow}
 3612        * must be called, which will insert the new row into both this rowset
 3613        * and the database. Both of these methods must be called before the
 3614        * cursor moves to another row.
 3615        *
 3616        * @param columnIndex the first column is <code>1</code>, the second
 3617        *        is <code>2</code>, and so on; must be <code>1</code> or larger
 3618        *        and equal to or less than the number of columns in this rowset
 3619        * @param b the new column <code>Blob</code> value
 3620        * @throws SQLException if (1) the given column index is out of bounds,
 3621        *            (2) the cursor is not on one of this rowset's rows or its
 3622        *            insert row, or (3) this rowset is
 3623        *            <code>ResultSet.CONCUR_READ_ONLY</code>
 3624        */
 3625       public void updateBlob(int columnIndex, Blob b) throws SQLException {
 3626           checkState();
 3627           rs.updateBlob(columnIndex, b);
 3628       }
 3629   
 3630       /**
 3631        * Sets the designated column in either the current row or the insert
 3632        * row of this <code>JdbcRowSetImpl</code> object with the given
 3633        * <code>java.sql.Blob </code> value.
 3634        *
 3635        * This method updates a column value in either the current row or
 3636        * the insert row of this rowset, but it does not update the
 3637        * database.  If the cursor is on a row in the rowset, the
 3638        * method {@link #updateRow} must be called to update the database.
 3639        * If the cursor is on the insert row, the method {@link #insertRow}
 3640        * must be called, which will insert the new row into both this rowset
 3641        * and the database. Both of these methods must be called before the
 3642        * cursor moves to another row.
 3643        *
 3644        * @param columnName a <code>String</code> object that must match the
 3645        *        SQL name of a column in this rowset, ignoring case
 3646        * @param b the new column <code>Blob</code> value
 3647        * @throws SQLException if (1) the given column name does not match the
 3648        *            name of a column in this rowset, (2) the cursor is not on
 3649        *            one of this rowset's rows or its insert row, or (3) this
 3650        *            rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
 3651        */
 3652       public void updateBlob(String columnName, Blob b) throws SQLException {
 3653           updateBlob(findColumn(columnName), b);
 3654       }
 3655   
 3656       /**
 3657        * Sets the designated column in either the current row or the insert
 3658        * row of this <code>JdbcRowSetImpl</code> object with the given
 3659        * <code>java.sql.Array</code> values.
 3660        *
 3661        * This method updates a column value in either the current row or
 3662        * the insert row of this rowset, but it does not update the
 3663        * database.  If the cursor is on a row in the rowset, the
 3664        * method {@link #updateRow} must be called to update the database.
 3665        * If the cursor is on the insert row, the method {@link #insertRow}
 3666        * must be called, which will insert the new row into both this rowset
 3667        * and the database. Both of these methods must be called before the
 3668        * cursor moves to another row.
 3669        *
 3670        * @param columnIndex the first column is <code>1</code>, the second
 3671        *        is <code>2</code>, and so on; must be <code>1</code> or larger
 3672        *        and equal to or less than the number of columns in this rowset
 3673        * @param a the new column <code>Array</code> value
 3674        * @throws SQLException if (1) the given column index is out of bounds,
 3675        *            (2) the cursor is not on one of this rowset's rows or its
 3676        *            insert row, or (3) this rowset is
 3677        *            <code>ResultSet.CONCUR_READ_ONLY</code>
 3678        */
 3679       public void updateArray(int columnIndex, Array a) throws SQLException {
 3680           checkState();
 3681           rs.updateArray(columnIndex, a);
 3682       }
 3683   
 3684       /**
 3685        * Sets the designated column in either the current row or the insert
 3686        * row of this <code>JdbcRowSetImpl</code> object with the given
 3687        * <code>java.sql.Array</code> value.
 3688        *
 3689        * This method updates a column value in either the current row or
 3690        * the insert row of this rowset, but it does not update the
 3691        * database.  If the cursor is on a row in the rowset, the
 3692        * method {@link #updateRow} must be called to update the database.
 3693        * If the cursor is on the insert row, the method {@link #insertRow}
 3694        * must be called, which will insert the new row into both this rowset
 3695        * and the database. Both of these methods must be called before the
 3696        * cursor moves to another row.
 3697        *
 3698        * @param columnName a <code>String</code> object that must match the
 3699        *        SQL name of a column in this rowset, ignoring case
 3700        * @param a the new column <code>Array</code> value
 3701        * @throws SQLException if (1) the given column name does not match the
 3702        *            name of a column in this rowset, (2) the cursor is not on
 3703        *            one of this rowset's rows or its insert row, or (3) this
 3704        *            rowset is <code>ResultSet.CONCUR_READ_ONLY</code>
 3705        */
 3706       public void updateArray(String columnName, Array a) throws SQLException {
 3707           updateArray(findColumn(columnName), a);
 3708       }
 3709   
 3710       /**
 3711        * Provide interface coverage for getURL(int) in ResultSet->RowSet
 3712        */
 3713       public java.net.URL getURL(int columnIndex) throws SQLException {
 3714           checkState();
 3715           return rs.getURL(columnIndex);
 3716       }
 3717   
 3718       /**
 3719        * Provide interface coverage for getURL(String) in ResultSet->RowSet
 3720        */
 3721       public java.net.URL getURL(String columnName) throws SQLException {
 3722           return getURL(findColumn(columnName));
 3723       }
 3724   
 3725       /**
 3726        * Return the RowSetWarning object for the current row of a
 3727        * <code>JdbcRowSetImpl</code>
 3728        */
 3729       public RowSetWarning getRowSetWarnings() throws SQLException {
 3730          return null;
 3731       }
 3732       /**
 3733        * Unsets the designated parameter to the given int array.
 3734        * This was set using <code>setMatchColumn</code>
 3735        * as the column which will form the basis of the join.
 3736        * <P>
 3737        * The parameter value unset by this method should be same
 3738        * as was set.
 3739        *
 3740        * @param columnIdxes the index into this rowset
 3741        *        object's internal representation of parameter values
 3742        * @throws SQLException if an error occurs or the
 3743        *  parameter index is out of bounds or if the columnIdx is
 3744        *  not the same as set using <code>setMatchColumn(int [])</code>
 3745        */
 3746       public void unsetMatchColumn(int[] columnIdxes) throws SQLException {
 3747   
 3748            int i_val;
 3749            for( int j= 0 ;j < columnIdxes.length; j++) {
 3750               i_val = (Integer.parseInt(iMatchColumns.get(j).toString()));
 3751               if(columnIdxes[j] != i_val) {
 3752                  throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols").toString());
 3753               }
 3754            }
 3755   
 3756            for( int i = 0;i < columnIdxes.length ;i++) {
 3757               iMatchColumns.set(i,Integer.valueOf(-1));
 3758            }
 3759       }
 3760   
 3761      /**
 3762        * Unsets the designated parameter to the given String array.
 3763        * This was set using <code>setMatchColumn</code>
 3764        * as the column which will form the basis of the join.
 3765        * <P>
 3766        * The parameter value unset by this method should be same
 3767        * as was set.
 3768        *
 3769        * @param columnIdxes the index into this rowset
 3770        *        object's internal representation of parameter values
 3771        * @throws SQLException if an error occurs or the
 3772        *  parameter index is out of bounds or if the columnName is
 3773        *  not the same as set using <code>setMatchColumn(String [])</code>
 3774        */
 3775       public void unsetMatchColumn(String[] columnIdxes) throws SQLException {
 3776   
 3777           for(int j = 0 ;j < columnIdxes.length; j++) {
 3778              if( !columnIdxes[j].equals(strMatchColumns.get(j)) ){
 3779                 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols").toString());
 3780              }
 3781           }
 3782   
 3783           for(int i = 0 ; i < columnIdxes.length; i++) {
 3784              strMatchColumns.set(i,null);
 3785           }
 3786       }
 3787   
 3788       /**
 3789        * Retrieves the column name as <code>String</code> array
 3790        * that was set using <code>setMatchColumn(String [])</code>
 3791        * for this rowset.
 3792        *
 3793        * @return a <code>String</code> array object that contains the column names
 3794        *         for the rowset which has this the match columns
 3795        *
 3796        * @throws SQLException if an error occurs or column name is not set
 3797        */
 3798       public String[] getMatchColumnNames() throws SQLException {
 3799   
 3800           String []str_temp = new String[strMatchColumns.size()];
 3801   
 3802           if( strMatchColumns.get(0) == null) {
 3803              throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.setmatchcols").toString());
 3804           }
 3805   
 3806           strMatchColumns.copyInto(str_temp);
 3807           return str_temp;
 3808       }
 3809   
 3810       /**
 3811        * Retrieves the column id as <code>int</code> array that was set using
 3812        * <code>setMatchColumn(int [])</code> for this rowset.
 3813        *
 3814        * @return a <code>int</code> array object that contains the column ids
 3815        *         for the rowset which has this as the match columns.
 3816        *
 3817        * @throws SQLException if an error occurs or column index is not set
 3818        */
 3819       public int[] getMatchColumnIndexes() throws SQLException {
 3820   
 3821           Integer []int_temp = new Integer[iMatchColumns.size()];
 3822           int [] i_temp = new int[iMatchColumns.size()];
 3823           int i_val;
 3824   
 3825           i_val = ((Integer)iMatchColumns.get(0)).intValue();
 3826   
 3827           if( i_val == -1 ) {
 3828              throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.setmatchcols").toString());
 3829           }
 3830   
 3831   
 3832           iMatchColumns.copyInto(int_temp);
 3833   
 3834           for(int i = 0; i < int_temp.length; i++) {
 3835              i_temp[i] = (int_temp[i]).intValue();
 3836           }
 3837   
 3838           return i_temp;
 3839       }
 3840   
 3841       /**
 3842        * Sets the designated parameter to the given int array.
 3843        * This forms the basis of the join for the
 3844        * <code>JoinRowSet</code> as the column which will form the basis of the
 3845        * join.
 3846        * <P>
 3847        * The parameter value set by this method is stored internally and
 3848        * will be supplied as the appropriate parameter in this rowset's
 3849        * command when the method <code>getMatchColumnIndexes</code> is called.
 3850        *
 3851        * @param columnIdxes the indexes into this rowset
 3852        *        object's internal representation of parameter values; the
 3853        *        first parameter is 0, the second is 1, and so on; must be
 3854        *        <code>0</code> or greater
 3855        * @throws SQLException if an error occurs or the
 3856        *                         parameter index is out of bounds
 3857        */
 3858       public void setMatchColumn(int[] columnIdxes) throws SQLException {
 3859   
 3860           for(int j = 0 ; j < columnIdxes.length; j++) {
 3861              if( columnIdxes[j] < 0 ) {
 3862                 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols1").toString());
 3863              }
 3864           }
 3865           for(int i = 0 ;i < columnIdxes.length; i++) {
 3866              iMatchColumns.add(i,Integer.valueOf(columnIdxes[i]));
 3867           }
 3868       }
 3869   
 3870       /**
 3871        * Sets the designated parameter to the given String array.
 3872        *  This forms the basis of the join for the
 3873        * <code>JoinRowSet</code> as the column which will form the basis of the
 3874        * join.
 3875        * <P>
 3876        * The parameter value set by this method is stored internally and
 3877        * will be supplied as the appropriate parameter in this rowset's
 3878        * command when the method <code>getMatchColumn</code> is called.
 3879        *
 3880        * @param columnNames the name of the column into this rowset
 3881        *        object's internal representation of parameter values
 3882        * @throws SQLException if an error occurs or the
 3883        *  parameter index is out of bounds
 3884        */
 3885       public void setMatchColumn(String[] columnNames) throws SQLException {
 3886   
 3887           for(int j = 0; j < columnNames.length; j++) {
 3888              if( columnNames[j] == null || columnNames[j].equals("")) {
 3889                 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols2").toString());
 3890              }
 3891           }
 3892           for( int i = 0; i < columnNames.length; i++) {
 3893              strMatchColumns.add(i,columnNames[i]);
 3894           }
 3895       }
 3896   
 3897   
 3898           /**
 3899        * Sets the designated parameter to the given <code>int</code>
 3900        * object.  This forms the basis of the join for the
 3901        * <code>JoinRowSet</code> as the column which will form the basis of the
 3902        * join.
 3903        * <P>
 3904        * The parameter value set by this method is stored internally and
 3905        * will be supplied as the appropriate parameter in this rowset's
 3906        * command when the method <code>getMatchColumn</code> is called.
 3907        *
 3908        * @param columnIdx the index into this rowset
 3909        *        object's internal representation of parameter values; the
 3910        *        first parameter is 0, the second is 1, and so on; must be
 3911        *        <code>0</code> or greater
 3912        * @throws SQLException if an error occurs or the
 3913        *                         parameter index is out of bounds
 3914        */
 3915       public void setMatchColumn(int columnIdx) throws SQLException {
 3916           // validate, if col is ok to be set
 3917           if(columnIdx < 0) {
 3918               throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols1").toString());
 3919           } else {
 3920               // set iMatchColumn
 3921               iMatchColumns.set(0, Integer.valueOf(columnIdx));
 3922               //strMatchColumn = null;
 3923           }
 3924       }
 3925   
 3926       /**
 3927        * Sets the designated parameter to the given <code>String</code>
 3928        * object.  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>getMatchColumn</code> is called.
 3935        *
 3936        * @param columnName the name of the column into this rowset
 3937        *        object's internal representation of parameter values
 3938        * @throws SQLException if an error occurs or the
 3939        *  parameter index is out of bounds
 3940        */
 3941       public void setMatchColumn(String columnName) throws SQLException {
 3942           // validate, if col is ok to be set
 3943           if(columnName == null || (columnName= columnName.trim()).equals("")) {
 3944               throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.matchcols2").toString());
 3945           } else {
 3946               // set strMatchColumn
 3947               strMatchColumns.set(0, columnName);
 3948               //iMatchColumn = -1;
 3949           }
 3950       }
 3951   
 3952       /**
 3953        * Unsets the designated parameter to the given <code>int</code>
 3954        * object.  This was set using <code>setMatchColumn</code>
 3955        * as the column which will form the basis of the join.
 3956        * <P>
 3957        * The parameter value unset by this method should be same
 3958        * as was set.
 3959        *
 3960        * @param columnIdx the index into this rowset
 3961        *        object's internal representation of parameter values
 3962        * @throws SQLException if an error occurs or the
 3963        *  parameter index is out of bounds or if the columnIdx is
 3964        *  not the same as set using <code>setMatchColumn(int)</code>
 3965        */
 3966       public void unsetMatchColumn(int columnIdx) throws SQLException {
 3967           // check if we are unsetting the SAME column
 3968           if(! iMatchColumns.get(0).equals(Integer.valueOf(columnIdx) )  ) {
 3969               throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.unsetmatch").toString());
 3970           } else if(strMatchColumns.get(0) != null) {
 3971               throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.usecolname").toString());
 3972           } else {
 3973                   // that is, we are unsetting it.
 3974                  iMatchColumns.set(0, Integer.valueOf(-1));
 3975           }
 3976       }
 3977   
 3978       /**
 3979        * Unsets the designated parameter to the given <code>String</code>
 3980        * object.  This was set using <code>setMatchColumn</code>
 3981        * as the column which will form the basis of the join.
 3982        * <P>
 3983        * The parameter value unset by this method should be same
 3984        * as was set.
 3985        *
 3986        * @param columnName the index into this rowset
 3987        *        object's internal representation of parameter values
 3988        * @throws SQLException if an error occurs or the
 3989        *  parameter index is out of bounds or if the columnName is
 3990        *  not the same as set using <code>setMatchColumn(String)</code>
 3991        *
 3992        */
 3993       public void unsetMatchColumn(String columnName) throws SQLException {
 3994           // check if we are unsetting the same column
 3995           columnName = columnName.trim();
 3996   
 3997           if(!((strMatchColumns.get(0)).equals(columnName))) {
 3998               throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.unsetmatch").toString());
 3999           } else if( ((Integer)(iMatchColumns.get(0))).intValue() > 0) {
 4000               throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.usecolid").toString());
 4001           } else {
 4002               strMatchColumns.set(0, null);   // that is, we are unsetting it.
 4003           }
 4004       }
 4005   
 4006       /**
 4007        * Retrieves the <code>DatabaseMetaData</code> associated with
 4008        * the connection handle associated this this
 4009        * <code>JdbcRowSet</code> object.
 4010        *
 4011        * @return the <code>DatabaseMetadata</code> associated
 4012        *  with the rowset's connection.
 4013        * @throws SQLException if a database access error occurs
 4014        */
 4015       public DatabaseMetaData getDatabaseMetaData() throws SQLException {
 4016           Connection con = connect();
 4017           return con.getMetaData();
 4018       }
 4019   
 4020       /**
 4021        * Retrieves the <code>ParameterMetaData</code> associated with
 4022        * the connection handle associated this this
 4023        * <code>JdbcRowSet</code> object.
 4024        *
 4025        * @return the <code>ParameterMetadata</code> associated
 4026        *  with the rowset's connection.
 4027        * @throws SQLException if a database access error occurs
 4028        */
 4029       public ParameterMetaData getParameterMetaData() throws SQLException {
 4030           prepare();
 4031           return (ps.getParameterMetaData());
 4032       }
 4033   
 4034       /**
 4035        * Commits all updates in this <code>JdbcRowSet</code> object by
 4036        * wrapping the internal <code>Connection</code> object and calling
 4037        * its <code>commit</code> method.
 4038        * This method sets this <code>JdbcRowSet</code> object's private field
 4039        * <code>rs</code> to <code>null</code> after saving its value to another
 4040        * object, but only if the <code>ResultSet</code>
 4041        * constant <code>HOLD_CURSORS_OVER_COMMIT</code> has not been set.
 4042        * (The field <code>rs</code> is this <code>JdbcRowSet</code> object's
 4043        * <code>ResultSet</code> object.)
 4044        *
 4045        * @throws SQLException if autoCommit is set to true or if a database
 4046        * access error occurs
 4047        */
 4048       public void commit() throws SQLException {
 4049         conn.commit();
 4050   
 4051         // Checking the holadbility value and making the result set handle null
 4052         // Added as per Rave requirements
 4053   
 4054         if( conn.getHoldability() != HOLD_CURSORS_OVER_COMMIT) {
 4055            ResultSet oldVal = rs;
 4056            rs = null;
 4057            // propertyChangeSupport.firePropertyChange("ResultSet",oldVal,rs);
 4058         }
 4059       }
 4060   
 4061       /**
 4062        * Sets auto-commit on the internal <code>Connection</code> object with this
 4063        * <code>JdbcRowSet</code>
 4064        *
 4065        * @throws SQLException if a database access error occurs
 4066        */
 4067       public void setAutoCommit(boolean autoCommit) throws SQLException {
 4068           // The connection object should be there
 4069           // in order to commit the connection handle on or off.
 4070   
 4071           if(conn != null) {
 4072              conn.setAutoCommit(autoCommit);
 4073           } else {
 4074              // Coming here means the connection object is null.
 4075              // So generate a connection handle internally, since
 4076              // a JdbcRowSet is always connected to a db, it is fine
 4077              // to get a handle to the connection.
 4078   
 4079              // Get hold of a connection handle
 4080              // and change the autcommit as passesd.
 4081              conn = connect();
 4082   
 4083              // After setting the below the conn.getAutoCommit()
 4084              // should return the same value.
 4085              conn.setAutoCommit(autoCommit);
 4086   
 4087           }
 4088       }
 4089   
 4090       /**
 4091        * Returns the auto-commit status with this <code>JdbcRowSet</code>.
 4092        *
 4093        * @return true if auto commit is true; false otherwise
 4094        * @throws SQLException if a database access error occurs
 4095        */
 4096       public boolean getAutoCommit() throws SQLException {
 4097           return conn.getAutoCommit();
 4098       }
 4099   
 4100       /**
 4101        * Rolls back all the updates in this <code>JdbcRowSet</code> object by
 4102        * wrapping the internal <code>Connection</code> object and calling its
 4103        * <code>rollback</code> method.
 4104        * This method sets this <code>JdbcRowSet</code> object's private field
 4105        * <code>rs</code> to <code>null</code> after saving its value to another object.
 4106        * (The field <code>rs</code> is this <code>JdbcRowSet</code> object's
 4107        * internal <code>ResultSet</code> object.)
 4108        *
 4109        * @throws SQLException if autoCommit is set to true or a database
 4110        * access error occurs
 4111        */
 4112       public void rollback() throws SQLException {
 4113           conn.rollback();
 4114   
 4115           // Makes the result ste handle null after rollback
 4116           // Added as per Rave requirements
 4117   
 4118           ResultSet oldVal = rs;
 4119           rs = null;
 4120           // propertyChangeSupport.firePropertyChange("ResultSet", oldVal,rs);
 4121       }
 4122   
 4123   
 4124       /**
 4125        * Rollbacks all the updates in the <code>JdbcRowSet</code> back to the
 4126        * last <code>Savepoint</code> transaction marker. Wraps the internal
 4127        * <code>Connection</code> object and call it's rollback method
 4128        *
 4129        * @param s the <code>Savepoint</code> transaction marker to roll the
 4130        * transaction to.
 4131        * @throws SQLException if autoCommit is set to true; or ia a database
 4132        * access error occurs
 4133        */
 4134       public void rollback(Savepoint s) throws SQLException {
 4135           conn.rollback(s);
 4136       }
 4137   
 4138       // Setting the ResultSet Type and Concurrency
 4139       protected void setParams() throws SQLException {
 4140           if(rs == null) {
 4141              setType(ResultSet.TYPE_SCROLL_INSENSITIVE);
 4142              setConcurrency(ResultSet.CONCUR_UPDATABLE);
 4143           }
 4144           else {
 4145               setType(rs.getType());
 4146               setConcurrency(rs.getConcurrency());
 4147           }
 4148       }
 4149   
 4150   
 4151       // Checking ResultSet Type and Concurrency
 4152       private void checkTypeConcurrency() throws SQLException {
 4153           if(rs.getType() == TYPE_FORWARD_ONLY ||
 4154              rs.getConcurrency() == CONCUR_READ_ONLY) {
 4155                 throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.resnotupd").toString());
 4156            }
 4157       }
 4158   
 4159        // Returns a Connection Handle
 4160       //  Added as per Rave requirements
 4161   
 4162       /**
 4163        * Gets this <code>JdbcRowSet</code> object's Connection property
 4164        *
 4165        *
 4166        * @return the <code>Connection</code> object associated with this rowset;
 4167        */
 4168   
 4169       protected Connection getConnection() {
 4170          return conn;
 4171       }
 4172   
 4173       // Sets the connection handle with the parameter
 4174       // Added as per rave requirements
 4175   
 4176       /**
 4177        * Sets this <code>JdbcRowSet</code> object's connection property
 4178        * to the given <code>Connection</code> object.
 4179        *
 4180        * @param connection the <code>Connection</code> object.
 4181        */
 4182   
 4183       protected void setConnection(Connection connection) {
 4184          conn = connection;
 4185       }
 4186   
 4187       // Returns a PreparedStatement Handle
 4188       // Added as per Rave requirements
 4189   
 4190       /**
 4191        * Gets this <code>JdbcRowSet</code> object's PreparedStatement property
 4192        *
 4193        *
 4194        * @return the <code>PreparedStatement</code> object associated with this rowset;
 4195        */
 4196   
 4197       protected PreparedStatement getPreparedStatement() {
 4198          return ps;
 4199       }
 4200   
 4201       //Sets the prepared statement handle to the parameter
 4202       // Added as per Rave requirements
 4203   
 4204       /**
 4205        * Sets this <code>JdbcRowSet</code> object's preparedtsatement property
 4206        * to the given <code>PreparedStatemennt</code> object.
 4207        *
 4208        * @param preparedStatement the <code>PreparedStatement</code> object
 4209        *
 4210        */
 4211       protected void setPreparedStatement(PreparedStatement preparedStatement) {
 4212          ps = preparedStatement;
 4213       }
 4214   
 4215       // Returns a ResultSet handle
 4216       // Added as per Rave requirements
 4217   
 4218       /**
 4219        * Gets this <code>JdbcRowSet</code> object's ResultSet property
 4220        *
 4221        *
 4222        * @return the <code>ResultSet</code> object associated with this rowset;
 4223        */
 4224   
 4225       protected ResultSet getResultSet() throws SQLException {
 4226   
 4227          checkState();
 4228   
 4229          return rs;
 4230       }
 4231   
 4232       // Sets the result set handle to the parameter
 4233       // Added as per Rave requirements
 4234   
 4235       /**
 4236        * Sets this <code>JdbcRowSet</code> object's resultset property
 4237        * to the given <code>ResultSet</code> object.
 4238        *
 4239        * @param resultSet the <code>ResultSet</code> object
 4240        *
 4241        */
 4242       protected void setResultSet(ResultSet resultSet) {
 4243          rs = resultSet;
 4244       }
 4245   
 4246   
 4247       // Over riding the setCommand from BaseRowSet for
 4248       // firing the propertyChangeSupport Event for
 4249       // Rave requirements when this property's value
 4250       // changes.
 4251   
 4252       /**
 4253        * Sets this <code>JdbcRowSet</code> object's <code>command</code> property to
 4254        * the given <code>String</code> object and clears the parameters, if any,
 4255        * that were set for the previous command. In addition,
 4256        * if the <code>command</code> property has previously been set to a
 4257        * non-null value and it is
 4258        * different from the <code>String</code> object supplied,
 4259        * this method sets this <code>JdbcRowSet</code> object's private fields
 4260        * <code>ps</code> and <code>rs</code> to <code>null</code>.
 4261        * (The field <code>ps</code> is its <code>PreparedStatement</code> object, and
 4262        * the field <code>rs</code> is its <code>ResultSet</code> object.)
 4263        * <P>
 4264        * The <code>command</code> property may not be needed if the <code>RowSet</code>
 4265        * object gets its data from a source that does not support commands,
 4266        * such as a spreadsheet or other tabular file.
 4267        * Thus, this property is optional and may be <code>null</code>.
 4268        *
 4269        * @param command a <code>String</code> object containing an SQL query
 4270        *            that will be set as this <code>RowSet</code> object's command
 4271        *            property; may be <code>null</code> but may not be an empty string
 4272        * @throws SQLException if an empty string is provided as the command value
 4273        * @see #getCommand
 4274        */
 4275       public void setCommand(String command) throws SQLException {
 4276          String oldVal;
 4277   
 4278          if (getCommand() != null) {
 4279             if(!getCommand().equals(command)) {
 4280                oldVal = getCommand();
 4281                super.setCommand(command);
 4282                ps = null;
 4283                rs = null;
 4284                propertyChangeSupport.firePropertyChange("command", oldVal,command);
 4285             }
 4286          }
 4287          else {
 4288             super.setCommand(command);
 4289             propertyChangeSupport.firePropertyChange("command", null,command);
 4290          }
 4291       }
 4292   
 4293       // Over riding the setDataSourceName from BaseRowSet for
 4294       // firing the propertyChangeSupport Event for
 4295       // Rave requirements when this property's values
 4296       // changes.
 4297   
 4298       /**
 4299        * Sets the <code>dataSourceName</code> property for this <code>JdbcRowSet</code>
 4300        * object to the given logical name and sets this <code>JdbcRowSet</code> object's
 4301        * Url property to <code>null</code>. In addition, if the <code>dataSourceName</code>
 4302        * property has previously been set and is different from the one supplied,
 4303        * this method sets this <code>JdbcRowSet</code> object's private fields
 4304        * <code>ps</code>, <code>rs</code>, and <code>conn</code> to <code>null</code>.
 4305        * (The field <code>ps</code> is its <code>PreparedStatement</code> object,
 4306        * the field <code>rs</code> is its <code>ResultSet</code> object, and
 4307        * the field <code>conn</code> is its <code>Connection</code> object.)
 4308        * <P>
 4309        * The name supplied to this method must have been bound to a
 4310        * <code>DataSource</code> object in a JNDI naming service so that an
 4311        * application can do a lookup using that name to retrieve the
 4312        * <code>DataSource</code> object bound to it. The <code>DataSource</code>
 4313        * object can then be used to establish a connection to the data source it
 4314        * represents.
 4315        * <P>
 4316        * Users should set either the Url property or the dataSourceName property.
 4317        * If both properties are set, the driver will use the property set most recently.
 4318        *
 4319        * @param dsName a <code>String</code> object with the name that can be supplied
 4320        *        to a naming service based on JNDI technology to retrieve the
 4321        *        <code>DataSource</code> object that can be used to get a connection;
 4322        *        may be <code>null</code>
 4323        * @throws SQLException if there is a problem setting the
 4324        *          <code>dataSourceName</code> property
 4325        * @see #getDataSourceName
 4326        */
 4327       public void setDataSourceName(String dsName) throws SQLException{
 4328          String oldVal;
 4329   
 4330          if(getDataSourceName() != null) {
 4331             if(!getDataSourceName().equals(dsName)) {
 4332                oldVal = getDataSourceName();
 4333                super.setDataSourceName(dsName);
 4334                conn = null;
 4335                ps = null;
 4336                rs = null;
 4337                propertyChangeSupport.firePropertyChange("dataSourceName",oldVal,dsName);
 4338             }
 4339          }
 4340          else {
 4341             super.setDataSourceName(dsName);
 4342             propertyChangeSupport.firePropertyChange("dataSourceName",null,dsName);
 4343          }
 4344       }
 4345   
 4346       // Over riding the setUrl from BaseRowSet for
 4347       // firing the propertyChangeSupport Event for
 4348       // Rave requirements when this property's values
 4349       // changes.
 4350   
 4351       /**
 4352        * Sets the Url property for this <code>JdbcRowSet</code> object
 4353        * to the given <code>String</code> object and sets the dataSource name
 4354        * property to <code>null</code>. In addition, if the Url property has
 4355        * previously been set to a non <code>null</code> value and its value
 4356        * is different from the value to be set,
 4357        * this method sets this <code>JdbcRowSet</code> object's private fields
 4358        * <code>ps</code>, <code>rs</code>, and <code>conn</code> to <code>null</code>.
 4359        * (The field <code>ps</code> is its <code>PreparedStatement</code> object,
 4360        * the field <code>rs</code> is its <code>ResultSet</code> object, and
 4361        * the field <code>conn</code> is its <code>Connection</code> object.)
 4362        * <P>
 4363        * The Url property is a JDBC URL that is used when
 4364        * the connection is created using a JDBC technology-enabled driver
 4365        * ("JDBC driver") and the <code>DriverManager</code>.
 4366        * The correct JDBC URL for the specific driver to be used can be found
 4367        * in the driver documentation.  Although there are guidelines for for how
 4368        * a JDBC URL is formed,
 4369        * a driver vendor can specify any <code>String</code> object except
 4370        * one with a length of <code>0</code> (an empty string).
 4371        * <P>
 4372        * Setting the Url property is optional if connections are established using
 4373        * a <code>DataSource</code> object instead of the <code>DriverManager</code>.
 4374        * The driver will use either the URL property or the
 4375        * dataSourceName property to create a connection, whichever was
 4376        * specified most recently. If an application uses a JDBC URL, it
 4377        * must load a JDBC driver that accepts the JDBC URL before it uses the
 4378        * <code>RowSet</code> object to connect to a database.  The <code>RowSet</code>
 4379        * object will use the URL internally to create a database connection in order
 4380        * to read or write data.
 4381        *
 4382        * @param url a <code>String</code> object that contains the JDBC URL
 4383        *            that will be used to establish the connection to a database for this
 4384        *            <code>RowSet</code> object; may be <code>null</code> but must not
 4385        *            be an empty string
 4386        * @throws SQLException if an error occurs setting the Url property or the
 4387        *         parameter supplied is a string with a length of <code>0</code> (an
 4388        *         empty string)
 4389        * @see #getUrl
 4390        */
 4391   
 4392       public void setUrl(String url) throws SQLException {
 4393          String oldVal;
 4394   
 4395          if(getUrl() != null) {
 4396             if(!getUrl().equals(url)) {
 4397                oldVal = getUrl();
 4398                super.setUrl(url);
 4399                conn = null;
 4400                ps = null;
 4401                rs = null;
 4402                propertyChangeSupport.firePropertyChange("url", oldVal, url);
 4403             }
 4404          }
 4405          else {
 4406             super.setUrl(url);
 4407             propertyChangeSupport.firePropertyChange("url", null, url);
 4408          }
 4409       }
 4410   
 4411       // Over riding the setUsername from BaseRowSet for
 4412       // firing the propertyChangeSupport Event for
 4413       // Rave requirements when this property's values
 4414       // changes.
 4415   
 4416        /**
 4417        * Sets the username property for this <code>JdbcRowSet</code> object
 4418        * to the given user name. Because it
 4419        * is not serialized, the username property is set at run time before
 4420        * calling the method <code>execute</code>. In addition,
 4421        * if the <code>username</code> property is already set with a
 4422        * non-null value and that value is different from the <code>String</code>
 4423        * object to be set,
 4424        * this method sets this <code>JdbcRowSet</code> object's private fields
 4425        * <code>ps</code>, <code>rs</code>, and <code>conn</code> to <code>null</code>.
 4426        * (The field <code>ps</code> is its <code>PreparedStatement</code> object,
 4427        * <code>rs</code> is its <code>ResultSet</code> object, and
 4428        * <code>conn</code> is its <code>Connection</code> object.)
 4429        * Setting these fields to <code>null</code> ensures that only current
 4430        * values will be used.
 4431        *
 4432        * @param uname the <code>String</code> object containing the user name that
 4433        *     is supplied to the data source to create a connection. It may be null.
 4434        * @see #getUsername
 4435        */
 4436       public void setUsername(String uname) {
 4437          String oldVal;
 4438   
 4439          if( getUsername() != null) {
 4440             if(!getUsername().equals(uname)) {
 4441                oldVal = getUsername();
 4442                super.setUsername(uname);
 4443                conn = null;
 4444                ps = null;
 4445                rs = null;
 4446                propertyChangeSupport.firePropertyChange("username",oldVal,uname);
 4447             }
 4448          }
 4449          else{
 4450             super.setUsername(uname);
 4451             propertyChangeSupport.firePropertyChange("username",null,uname);
 4452          }
 4453       }
 4454   
 4455       // Over riding the setPassword from BaseRowSet for
 4456       // firing the propertyChangeSupport Event for
 4457       // Rave requirements when this property's values
 4458       // changes.
 4459   
 4460        /**
 4461        * Sets the password property for this <code>JdbcRowSet</code> object
 4462        * to the given <code>String</code> object. Because it
 4463        * is not serialized, the password property is set at run time before
 4464        * calling the method <code>execute</code>. Its default valus is
 4465        * <code>null</code>. In addition,
 4466        * if the <code>password</code> property is already set with a
 4467        * non-null value and that value is different from the one being set,
 4468        * this method sets this <code>JdbcRowSet</code> object's private fields
 4469        * <code>ps</code>, <code>rs</code>, and <code>conn</code> to <code>null</code>.
 4470        * (The field <code>ps</code> is its <code>PreparedStatement</code> object,
 4471        * <code>rs</code> is its <code>ResultSet</code> object, and
 4472        * <code>conn</code> is its <code>Connection</code> object.)
 4473        * Setting these fields to <code>null</code> ensures that only current
 4474        * values will be used.
 4475        *
 4476        * @param password the <code>String</code> object that represents the password
 4477        *     that must be supplied to the database to create a connection
 4478        */
 4479       public void setPassword(String password) {
 4480          String oldVal;
 4481   
 4482          if ( getPassword() != null) {
 4483             if(!getPassword().equals(password)) {
 4484                oldVal = getPassword();
 4485                super.setPassword(password);
 4486                conn = null;
 4487                ps = null;
 4488                rs = null;
 4489                propertyChangeSupport.firePropertyChange("password",oldVal,password);
 4490             }
 4491          }
 4492          else{
 4493             super.setPassword(password);
 4494             propertyChangeSupport.firePropertyChange("password",null,password);
 4495          }
 4496       }
 4497   
 4498       /**
 4499        * Sets the type for this <code>RowSet</code> object to the specified type.
 4500        * The default type is <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>.
 4501        *
 4502        * @param type one of the following constants:
 4503        *             <code>ResultSet.TYPE_FORWARD_ONLY</code>,
 4504        *             <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
 4505        *             <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
 4506        * @throws SQLException if the parameter supplied is not one of the
 4507        *         following constants:
 4508        *          <code>ResultSet.TYPE_FORWARD_ONLY</code> or
 4509        *          <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>
 4510        *          <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
 4511        * @see #getConcurrency
 4512        * @see #getType
 4513        */
 4514   
 4515       public void setType(int type) throws SQLException {
 4516   
 4517          int oldVal;
 4518   
 4519          try {
 4520             oldVal = getType();
 4521           }catch(SQLException ex) {
 4522              oldVal = 0;
 4523           }
 4524   
 4525          if(oldVal != type) {
 4526              super.setType(type);
 4527              propertyChangeSupport.firePropertyChange("type",oldVal,type);
 4528          }
 4529   
 4530       }
 4531   
 4532       /**
 4533        * Sets the concurrency for this <code>RowSet</code> object to
 4534        * the specified concurrency. The default concurrency for any <code>RowSet</code>
 4535        * object (connected or disconnected) is <code>ResultSet.CONCUR_UPDATABLE</code>,
 4536        * but this method may be called at any time to change the concurrency.
 4537        *
 4538        * @param concur one of the following constants:
 4539        *                    <code>ResultSet.CONCUR_READ_ONLY</code> or
 4540        *                    <code>ResultSet.CONCUR_UPDATABLE</code>
 4541        * @throws SQLException if the parameter supplied is not one of the
 4542        *         following constants:
 4543        *          <code>ResultSet.CONCUR_UPDATABLE</code> or
 4544        *          <code>ResultSet.CONCUR_READ_ONLY</code>
 4545        * @see #getConcurrency
 4546        * @see #isReadOnly
 4547        */
 4548       public void setConcurrency(int concur) throws SQLException {
 4549   
 4550          int oldVal;
 4551   
 4552          try {
 4553             oldVal = getConcurrency();
 4554           }catch(NullPointerException ex) {
 4555              oldVal = 0;
 4556           }
 4557   
 4558          if(oldVal != concur) {
 4559              super.setConcurrency(concur);
 4560              propertyChangeSupport.firePropertyChange("concurrency",oldVal,concur);
 4561          }
 4562   
 4563       }
 4564   
 4565       /**
 4566        * Sets the transaction isolation property for this JDBC <code>RowSet</code> object to the given
 4567        * constant. The DBMS will use this transaction isolation level for
 4568        * transactions if it can.
 4569        * <p>
 4570        * For <code>RowSet</code> implementations such as
 4571        * the <code>CachedRowSet</code> that operate in a disconnected environment,
 4572        * the <code>SyncProvider</code> object being used
 4573        * offers complementary locking and data integrity options. The
 4574        * options described below are pertinent only to connected <code>RowSet</code>
 4575        * objects (<code>JdbcRowSet</code> objects).
 4576        *
 4577        * @param transIso one of the following constants, listed in ascending order:
 4578        *              <code>Connection.TRANSACTION_NONE</code>,
 4579        *              <code>Connection.TRANSACTION_READ_UNCOMMITTED</code>,
 4580        *              <code>Connection.TRANSACTION_READ_COMMITTED</code>,
 4581        *              <code>Connection.TRANSACTION_REPEATABLE_READ</code>, or
 4582        *              <code>Connection.TRANSACTION_SERIALIZABLE</code>
 4583        * @throws SQLException if the given parameter is not one of the Connection
 4584        *          constants
 4585        * @see javax.sql.rowset.spi.SyncFactory
 4586        * @see javax.sql.rowset.spi.SyncProvider
 4587        * @see #getTransactionIsolation
 4588        */
 4589       public void setTransactionIsolation(int transIso) throws SQLException {
 4590   
 4591          int oldVal;
 4592   
 4593          try {
 4594             oldVal = getTransactionIsolation();
 4595           }catch(NullPointerException ex) {
 4596              oldVal = 0;
 4597           }
 4598   
 4599          if(oldVal != transIso) {
 4600              super.setTransactionIsolation(transIso);
 4601              propertyChangeSupport.firePropertyChange("transactionIsolation",oldVal,transIso);
 4602          }
 4603   
 4604       }
 4605   
 4606       /**
 4607        * Sets the maximum number of rows that this <code>RowSet</code> object may contain to
 4608        * the given number. If this limit is exceeded, the excess rows are
 4609        * silently dropped.
 4610        *
 4611        * @param mRows an <code>int</code> indicating the current maximum number
 4612        *     of rows; zero means that there is no limit
 4613        * @throws SQLException if an error occurs internally setting the
 4614        *     maximum limit on the number of rows that a JDBC <code>RowSet</code> object
 4615        *     can contain; or if <i>max</i> is less than <code>0</code>; or
 4616        *     if <i>max</i> is less than the <code>fetchSize</code> of the
 4617        *     <code>RowSet</code>
 4618        */
 4619       public void setMaxRows(int mRows) throws SQLException {
 4620   
 4621          int oldVal;
 4622   
 4623          try {
 4624             oldVal = getMaxRows();
 4625           }catch(NullPointerException ex) {
 4626              oldVal = 0;
 4627           }
 4628   
 4629          if(oldVal != mRows) {
 4630              super.setMaxRows(mRows);
 4631              propertyChangeSupport.firePropertyChange("maxRows",oldVal,mRows);
 4632          }
 4633   
 4634       }
 4635   
 4636       /**
 4637        * Retrieves the value of the designated <code>SQL XML</code> parameter as a
 4638        * <code>SQLXML</code> object in the Java programming language.
 4639        * @param columnIndex the first column is 1, the second is 2, ...
 4640        * @return a SQLXML object that maps an SQL XML value
 4641        * @throws SQLException if a database access error occurs
 4642        * @since 6.0
 4643        */
 4644       public SQLXML getSQLXML(int columnIndex) throws SQLException {
 4645           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4646       }
 4647   
 4648       /**
 4649        * Retrieves the value of the designated <code>SQL XML</code> parameter as a
 4650        * <code>SQLXML</code> object in the Java programming language.
 4651        * @param colName the name of the column from which to retrieve the value
 4652        * @return a SQLXML object that maps an SQL XML value
 4653        * @throws SQLException if a database access error occurs
 4654        */
 4655       public SQLXML getSQLXML(String colName) throws SQLException {
 4656           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4657       }
 4658   
 4659       /**
 4660        * Retrieves the value of the designated column in the current row of this
 4661        * <code>ResultSet</code> object as a java.sql.RowId object in the Java
 4662        * programming language.
 4663        *
 4664        * @param columnIndex the first column is 1, the second 2, ...
 4665        * @return the column value if the value is a SQL <code>NULL</code> the
 4666        *     value returned is <code>null</code>
 4667        * @throws SQLException if a database access error occurs
 4668        * @since 6.0
 4669        */
 4670       public RowId getRowId(int columnIndex) throws SQLException {
 4671           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4672       }
 4673   
 4674       /**
 4675        * Retrieves the value of the designated column in the current row of this
 4676        * <code>ResultSet</code> object as a java.sql.RowId object in the Java
 4677        * programming language.
 4678        *
 4679        * @param columnName the name of the column
 4680        * @return the column value if the value is a SQL <code>NULL</code> the
 4681        *     value returned is <code>null</code>
 4682        * @throws SQLException if a database access error occurs
 4683        * @since 6.0
 4684        */
 4685       public RowId getRowId(String columnName) throws SQLException {
 4686           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4687       }
 4688   
 4689       /**
 4690        * Updates the designated column with a <code>RowId</code> value. The updater
 4691        * methods are used to update column values in the current row or the insert
 4692        * row. The updater methods do not update the underlying database; instead
 4693        * the <code>updateRow<code> or <code>insertRow</code> methods are called
 4694        * to update the database.
 4695        *
 4696        * @param columnIndex the first column is 1, the second 2, ...
 4697        * @param x the column value
 4698        * @throws SQLException if a database access occurs
 4699        * @since 6.0
 4700        */
 4701       public void updateRowId(int columnIndex, RowId x) throws SQLException {
 4702           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4703       }
 4704   
 4705       /**
 4706        * Updates the designated column with a <code>RowId</code> value. The updater
 4707        * methods are used to update column values in the current row or the insert
 4708        * row. The updater methods do not update the underlying database; instead
 4709        * the <code>updateRow<code> or <code>insertRow</code> methods are called
 4710        * to update the database.
 4711        *
 4712        * @param columnName the name of the column
 4713        * @param x the column value
 4714        * @throws SQLException if a database access occurs
 4715        * @since 6.0
 4716        */
 4717       public void updateRowId(String columnName, RowId x) throws SQLException {
 4718           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4719       }
 4720   
 4721       /**
 4722        * Retrieves the holdability of this ResultSet object
 4723        * @return  either ResultSet.HOLD_CURSORS_OVER_COMMIT or ResultSet.CLOSE_CURSORS_AT_COMMIT
 4724        * @throws SQLException if a database error occurs
 4725        * @since 6.0
 4726        */
 4727       public int getHoldability() throws SQLException {
 4728           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4729       }
 4730   
 4731       /**
 4732        * Retrieves whether this ResultSet object has been closed. A ResultSet is closed if the
 4733        * method close has been called on it, or if it is automatically closed.
 4734        * @return true if this ResultSet object is closed; false if it is still open
 4735        * @throws SQLException if a database access error occurs
 4736        * @since 6.0
 4737        */
 4738       public boolean isClosed() throws SQLException {
 4739           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4740       }
 4741   
 4742       /**
 4743        * This method is used for updating columns that support National Character sets.
 4744        * It can be used for updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
 4745        * @param columnIndex the first column is 1, the second 2, ...
 4746        * @param nString the value for the column to be updated
 4747        * @throws SQLException if a database access error occurs
 4748        * @since 6.0
 4749        */
 4750       public void updateNString(int columnIndex, String nString) throws SQLException {
 4751           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4752       }
 4753   
 4754       /**
 4755        * This method is used for updating columns that support National Character sets.
 4756        * It can be used for updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
 4757        * @param columnName name of the Column
 4758        * @param nString the value for the column to be updated
 4759        * @throws SQLException if a database access error occurs
 4760        * @since 6.0
 4761        */
 4762       public void updateNString(String columnName, String nString) throws SQLException {
 4763           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4764       }
 4765   
 4766   
 4767       /*o
 4768        * This method is used for updating SQL <code>NCLOB</code>  type that maps
 4769        * to <code>java.sql.Types.NCLOB</code>
 4770        * @param columnIndex the first column is 1, the second 2, ...
 4771        * @param nClob the value for the column to be updated
 4772        * @throws SQLException if a database access error occurs
 4773        * @since 6.0
 4774        */
 4775       public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
 4776           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4777       }
 4778   
 4779       /**
 4780        * This method is used for updating SQL <code>NCLOB</code>  type that maps
 4781        * to <code>java.sql.Types.NCLOB</code>
 4782        * @param columnName name of the column
 4783        * @param nClob the value for the column to be updated
 4784        * @throws SQLException if a database access error occurs
 4785        * @since 6.0
 4786        */
 4787       public void updateNClob(String columnName, NClob nClob) throws SQLException {
 4788           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4789       }
 4790   
 4791       /**
 4792        * Retrieves the value of the designated column in the current row
 4793        * of this <code>ResultSet</code> object as a <code>NClob</code> object
 4794        * in the Java programming language.
 4795        *
 4796        * @param i the first column is 1, the second is 2, ...
 4797        * @return a <code>NClob</code> object representing the SQL
 4798        *         <code>NCLOB</code> value in the specified column
 4799        * @exception SQLException if a database access error occurs
 4800        * @since 6.0
 4801        */
 4802       public NClob getNClob(int i) throws SQLException {
 4803           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4804       }
 4805   
 4806   
 4807     /**
 4808        * Retrieves the value of the designated column in the current row
 4809        * of this <code>ResultSet</code> object as a <code>NClob</code> object
 4810        * in the Java programming language.
 4811        *
 4812        * @param colName the name of the column from which to retrieve the value
 4813        * @return a <code>NClob</code> object representing the SQL <code>NCLOB</code>
 4814        * value in the specified column
 4815        * @exception SQLException if a database access error occurs
 4816        * @since 6.0
 4817        */
 4818       public NClob getNClob(String colName) throws SQLException {
 4819           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4820       }
 4821   
 4822       public <T> T unwrap(java.lang.Class<T> iface) throws java.sql.SQLException{
 4823           return null;
 4824       }
 4825   
 4826       public boolean isWrapperFor(Class<?> interfaces) throws SQLException {
 4827           return false;
 4828       }
 4829   
 4830       /**
 4831         * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
 4832         * SQL <code>XML</code> value when it sends it to the database.
 4833         * @param parameterIndex index of the first parameter is 1, the second is 2, ...
 4834         * @param xmlObject a <code>SQLXML</code> object that maps an SQL <code>XML</code> value
 4835         * @throws SQLException if a database access error occurs
 4836         * @since 1.6
 4837         */
 4838        public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
 4839            throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4840        }
 4841   
 4842       /**
 4843        * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
 4844        * <code>SQL XML</code> value when it sends it to the database.
 4845        * @param parameterName the name of the parameter
 4846        * @param xmlObject a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
 4847        * @throws SQLException if a database access error occurs
 4848        * @since 1.6
 4849        */
 4850       public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
 4851            throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4852        }
 4853   
 4854       /**
 4855        * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
 4856        * driver converts this to a SQL <code>ROWID</code> value when it sends it
 4857        * to the database
 4858        *
 4859        * @param parameterIndex the first parameter is 1, the second is 2, ...
 4860        * @param x the parameter value
 4861        * @throws SQLException if a database access error occurs
 4862        *
 4863        * @since 1.6
 4864        */
 4865       public void setRowId(int parameterIndex, RowId x) throws SQLException {
 4866            throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4867        }
 4868   
 4869       /**
 4870       * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
 4871       * driver converts this to a SQL <code>ROWID</code> when it sends it to the
 4872       * database.
 4873       *
 4874       * @param parameterName the name of the parameter
 4875       * @param x the parameter value
 4876       * @throws SQLException if a database access error occurs
 4877       * @since 1.6
 4878       */
 4879      public void setRowId(String parameterName, RowId x) throws SQLException {
 4880            throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4881        }
 4882   
 4883   
 4884      /**
 4885        * Sets the designated paramter to the given <code>String</code> object.
 4886        * The driver converts this to a SQL <code>NCHAR</code> or
 4887        * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
 4888        * (depending on the argument's
 4889        * size relative to the driver's limits on <code>NVARCHAR</code> values)
 4890        * when it sends it to the database.
 4891        *
 4892        * @param parameterIndex of the first parameter is 1, the second is 2, ...
 4893        * @param value the parameter value
 4894        * @throws SQLException if the driver does not support national
 4895        *         character sets;  if the driver can detect that a data conversion
 4896        *  error could occur ; or if a database access error occurs
 4897        * @since 1.6
 4898        */
 4899        public void setNString(int parameterIndex, String value) throws SQLException {
 4900           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4901        }
 4902   
 4903   
 4904      /**
 4905       * Sets the designated parameter in this <code>RowSet</code> object's command
 4906       * to a <code>Reader</code> object. The
 4907       * <code>Reader</code> reads the data till end-of-file is reached. The
 4908       * driver does the necessary conversion from Java character format to
 4909       * the national character set in the database.
 4910   
 4911       * <P><B>Note:</B> This stream object can either be a standard
 4912       * Java stream object or your own subclass that implements the
 4913       * standard interface.
 4914       * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 4915       * it might be more efficient to use a version of
 4916       * <code>setNCharacterStream</code> which takes a length parameter.
 4917       *
 4918       * @param parameterIndex of the first parameter is 1, the second is 2, ...
 4919       * @param value the parameter value
 4920       * @throws SQLException if the driver does not support national
 4921       *         character sets;  if the driver can detect that a data conversion
 4922       *  error could occur ; if a database access error occurs; or
 4923       * this method is called on a closed <code>PreparedStatement</code>
 4924       * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
 4925       * @since 1.6
 4926       */
 4927       public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
 4928           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4929       }
 4930   
 4931     /**
 4932       * Sets the designated parameter to a <code>java.sql.NClob</code> object. The object
 4933       * implements the <code>java.sql.NClob</code> interface. This <code>NClob</code>
 4934       * object maps to a SQL <code>NCLOB</code>.
 4935       * @param parameterName the name of the column to be set
 4936       * @param value the parameter value
 4937       * @throws SQLException if the driver does not support national
 4938       *         character sets;  if the driver can detect that a data conversion
 4939       *  error could occur; or if a database access error occurs
 4940       * @since 1.6
 4941       */
 4942       public void setNClob(String parameterName, NClob value) throws SQLException {
 4943            throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4944        }
 4945   
 4946   
 4947     /**
 4948        * Retrieves the value of the designated column in the current row
 4949        * of this <code>ResultSet</code> object as a
 4950        * <code>java.io.Reader</code> object.
 4951        * It is intended for use when
 4952        * accessing  <code>NCHAR</code>,<code>NVARCHAR</code>
 4953        * and <code>LONGNVARCHAR</code> columns.
 4954        *
 4955        * @return a <code>java.io.Reader</code> object that contains the column
 4956        * value; if the value is SQL <code>NULL</code>, the value returned is
 4957        * <code>null</code> in the Java programming language.
 4958        * @param columnIndex the first column is 1, the second is 2, ...
 4959        * @exception SQLException if a database access error occurs
 4960        * @since 1.6
 4961        */
 4962       public java.io.Reader getNCharacterStream(int columnIndex) throws SQLException {
 4963          throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4964        }
 4965   
 4966   
 4967       /**
 4968        * Retrieves the value of the designated column in the current row
 4969        * of this <code>ResultSet</code> object as a
 4970        * <code>java.io.Reader</code> object.
 4971        * It is intended for use when
 4972        * accessing  <code>NCHAR</code>,<code>NVARCHAR</code>
 4973        * and <code>LONGNVARCHAR</code> columns.
 4974        *
 4975        * @param columnName the name of the column
 4976        * @return a <code>java.io.Reader</code> object that contains the column
 4977        * value; if the value is SQL <code>NULL</code>, the value returned is
 4978        * <code>null</code> in the Java programming language
 4979        * @exception SQLException if a database access error occurs
 4980        * @since 1.6
 4981        */
 4982       public java.io.Reader getNCharacterStream(String columnName) throws SQLException {
 4983          throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 4984        }
 4985   
 4986       /**
 4987        * Updates the designated column with a <code>java.sql.SQLXML</code> value.
 4988        * The updater
 4989        * methods are used to update column values in the current row or the insert
 4990        * row. The updater methods do not update the underlying database; instead
 4991        * the <code>updateRow</code> or <code>insertRow</code> methods are called
 4992        * to update the database.
 4993        * @param columnIndex the first column is 1, the second 2, ...
 4994        * @param xmlObject the value for the column to be updated
 4995        * @throws SQLException if a database access error occurs
 4996        * @since 1.6
 4997        */
 4998       public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException {
 4999           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5000       }
 5001   
 5002       /**
 5003        * Updates the designated column with a <code>java.sql.SQLXML</code> value.
 5004        * The updater
 5005        * methods are used to update column values in the current row or the insert
 5006        * row. The updater methods do not update the underlying database; instead
 5007        * the <code>updateRow</code> or <code>insertRow</code> methods are called
 5008        * to update the database.
 5009        *
 5010        * @param columnName the name of the column
 5011        * @param xmlObject the column value
 5012        * @throws SQLException if a database access occurs
 5013        * @since 1.6
 5014        */
 5015       public void updateSQLXML(String columnName, SQLXML xmlObject) throws SQLException {
 5016           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5017       }
 5018   
 5019        /**
 5020        * Retrieves the value of the designated column in the current row
 5021        * of this <code>ResultSet</code> object as
 5022        * a <code>String</code> in the Java programming language.
 5023        * It is intended for use when
 5024        * accessing  <code>NCHAR</code>,<code>NVARCHAR</code>
 5025        * and <code>LONGNVARCHAR</code> columns.
 5026        *
 5027        * @param columnIndex the first column is 1, the second is 2, ...
 5028        * @return the column value; if the value is SQL <code>NULL</code>, the
 5029        * value returned is <code>null</code>
 5030        * @exception SQLException if a database access error occurs
 5031        * @since 1.6
 5032        */
 5033       public String getNString(int columnIndex) throws SQLException {
 5034           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5035       }
 5036   
 5037       /**
 5038        * Retrieves the value of the designated column in the current row
 5039        * of this <code>ResultSet</code> object as
 5040        * a <code>String</code> in the Java programming language.
 5041        * It is intended for use when
 5042        * accessing  <code>NCHAR</code>,<code>NVARCHAR</code>
 5043        * and <code>LONGNVARCHAR</code> columns.
 5044        *
 5045        * @param columnName the SQL name of the column
 5046        * @return the column value; if the value is SQL <code>NULL</code>, the
 5047        * value returned is <code>null</code>
 5048        * @exception SQLException if a database access error occurs
 5049        * @since 1.6
 5050        */
 5051       public String getNString(String columnName) throws SQLException {
 5052           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5053       }
 5054   
 5055        /**
 5056          * Updates the designated column with a character stream value, which will
 5057          * have the specified number of bytes. The driver does the necessary conversion
 5058          * from Java character format to the national character set in the database.
 5059          * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
 5060          * The updater methods are used to update column values in the current row or
 5061          * the insert row. The updater methods do not update the underlying database;
 5062          * instead the updateRow or insertRow methods are called to update the database.
 5063          *
 5064          * @param columnIndex - the first column is 1, the second is 2, ...
 5065          * @param x - the new column value
 5066          * @param length - the length of the stream
 5067          * @exception SQLException if a database access error occurs
 5068          * @since 1.6
 5069          */
 5070          public void updateNCharacterStream(int columnIndex,
 5071                               java.io.Reader x,
 5072                               long length)
 5073                               throws SQLException {
 5074             throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5075          }
 5076   
 5077        /**
 5078          * Updates the designated column with a character stream value, which will
 5079          * have the specified number of bytes. The driver does the necessary conversion
 5080          * from Java character format to the national character set in the database.
 5081          * It is intended for use when updating NCHAR,NVARCHAR and LONGNVARCHAR columns.
 5082          * The updater methods are used to update column values in the current row or
 5083          * the insert row. The updater methods do not update the underlying database;
 5084          * instead the updateRow or insertRow methods are called to update the database.
 5085          *
 5086          * @param columnName - name of the Column
 5087          * @param x - the new column value
 5088          * @param length - the length of the stream
 5089          * @exception SQLException if a database access error occurs
 5090          * @since 1.6
 5091          */
 5092          public void updateNCharacterStream(String columnName,
 5093                               java.io.Reader x,
 5094                               long length)
 5095                               throws SQLException {
 5096             throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5097          }
 5098   
 5099       /**
 5100        * Updates the designated column with a character stream value.   The
 5101        * driver does the necessary conversion from Java character format to
 5102        * the national character set in the database.
 5103        * It is intended for use when
 5104        * updating  <code>NCHAR</code>,<code>NVARCHAR</code>
 5105        * and <code>LONGNVARCHAR</code> columns.
 5106        *
 5107        * The updater methods are used to update column values in the
 5108        * current row or the insert row.  The updater methods do not
 5109        * update the underlying database; instead the <code>updateRow</code> or
 5110        * <code>insertRow</code> methods are called to update the database.
 5111        *
 5112        * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 5113        * it might be more efficient to use a version of
 5114        * <code>updateNCharacterStream</code> which takes a length parameter.
 5115        *
 5116        * @param columnIndex the first column is 1, the second is 2, ...
 5117        * @param x the new column value
 5118        * @exception SQLException if a database access error occurs,
 5119        * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
 5120        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5121        * this method
 5122        * @since 1.6
 5123        */
 5124       public void updateNCharacterStream(int columnIndex,
 5125                                java.io.Reader x) throws SQLException {
 5126           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5127       }
 5128   
 5129       /**
 5130        * Updates the designated column with a character stream value.  The
 5131        * driver does the necessary conversion from Java character format to
 5132        * the national character set in the database.
 5133        * It is intended for use when
 5134        * updating  <code>NCHAR</code>,<code>NVARCHAR</code>
 5135        * and <code>LONGNVARCHAR</code> columns.
 5136        *
 5137        * The updater methods are used to update column values in the
 5138        * current row or the insert row.  The updater methods do not
 5139        * update the underlying database; instead the <code>updateRow</code> or
 5140        * <code>insertRow</code> methods are called to update the database.
 5141        *
 5142        * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 5143        * it might be more efficient to use a version of
 5144        * <code>updateNCharacterStream</code> which takes a length parameter.
 5145        *
 5146        * @param columnLabel the label for the column specified with the SQL AS clause.  If the SQL AS clause was not specified, then the la
 5147   bel is the name of the column
 5148        * @param reader the <code>java.io.Reader</code> object containing
 5149        *        the new column value
 5150        * @exception SQLException if a database access error occurs,
 5151        * the result set concurrency is <code>CONCUR_READ_ONLY</code> or this method is called on a closed result set
 5152         * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5153        * this method
 5154        * @since 1.6
 5155        */
 5156       public void updateNCharacterStream(String columnLabel,
 5157                                java.io.Reader reader) throws SQLException {
 5158           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5159       }
 5160   
 5161       /**
 5162        * Updates the designated column using the given input stream, which
 5163        * will have the specified number of bytes.
 5164        * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
 5165        * parameter, it may be more practical to send it via a
 5166        * <code>java.io.InputStream</code>. Data will be read from the stream
 5167        * as needed until end-of-file is reached.  The JDBC driver will
 5168        * do any necessary conversion from ASCII to the database char format.
 5169        *
 5170        * <P><B>Note:</B> This stream object can either be a standard
 5171        * Java stream object or your own subclass that implements the
 5172        * standard interface.
 5173        * <p>
 5174        * The updater methods are used to update column values in the
 5175        * current row or the insert row.  The updater methods do not
 5176        * update the underlying database; instead the <code>updateRow</code> or
 5177        * <code>insertRow</code> methods are called to update the database.
 5178        *
 5179        * @param columnIndex the first column is 1, the second is 2, ...
 5180        * @param inputStream An object that contains the data to set the parameter
 5181        * value to.
 5182        * @param length the number of bytes in the parameter data.
 5183        * @exception SQLException if a database access error occurs,
 5184        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5185        * or this method is called on a closed result set
 5186        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5187        * this method
 5188        * @since 1.6
 5189        */
 5190       public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException{
 5191           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5192       }
 5193   
 5194       /**
 5195        * Updates the designated column using the given input stream, which
 5196        * will have the specified number of bytes.
 5197        * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
 5198        * parameter, it may be more practical to send it via a
 5199        * <code>java.io.InputStream</code>. Data will be read from the stream
 5200        * as needed until end-of-file is reached.  The JDBC driver will
 5201        * do any necessary conversion from ASCII to the database char format.
 5202        *
 5203        * <P><B>Note:</B> This stream object can either be a standard
 5204        * Java stream object or your own subclass that implements the
 5205        * standard interface.
 5206        * <p>
 5207        * The updater methods are used to update column values in the
 5208        * current row or the insert row.  The updater methods do not
 5209        * update the underlying database; instead the <code>updateRow</code> or
 5210        * <code>insertRow</code> methods are called to update the database.
 5211        *
 5212        * @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
 5213        * @param inputStream An object that contains the data to set the parameter
 5214        * value to.
 5215        * @param length the number of bytes in the parameter data.
 5216        * @exception SQLException if a database access error occurs,
 5217        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5218        * or this method is called on a closed result set
 5219        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5220        * this method
 5221        * @since 1.6
 5222        */
 5223       public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
 5224           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5225       }
 5226   
 5227       /**
 5228        * Updates the designated column using the given input stream.
 5229        * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
 5230        * parameter, it may be more practical to send it via a
 5231        * <code>java.io.InputStream</code>. Data will be read from the stream
 5232        * as needed until end-of-file is reached.  The JDBC driver will
 5233        * do any necessary conversion from ASCII to the database char format.
 5234        *
 5235        * <P><B>Note:</B> This stream object can either be a standard
 5236        * Java stream object or your own subclass that implements the
 5237        * standard interface.
 5238        *
 5239        *  <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 5240        * it might be more efficient to use a version of
 5241        * <code>updateBlob</code> which takes a length parameter.
 5242        * <p>
 5243        * The updater methods are used to update column values in the
 5244        * current row or the insert row.  The updater methods do not
 5245        * update the underlying database; instead the <code>updateRow</code> or
 5246        * <code>insertRow</code> methods are called to update the database.
 5247        *
 5248        * @param columnIndex the first column is 1, the second is 2, ...
 5249        * @param inputStream An object that contains the data to set the parameter
 5250        * value to.
 5251        * @exception SQLException if a database access error occurs,
 5252        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5253        * or this method is called on a closed result set
 5254        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5255        * this method
 5256        * @since 1.6
 5257        */
 5258       public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
 5259           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5260       }
 5261   
 5262       /**
 5263        * Updates the designated column using the given input stream.
 5264        * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
 5265        * parameter, it may be more practical to send it via a
 5266        * <code>java.io.InputStream</code>. Data will be read from the stream
 5267        * as needed until end-of-file is reached.  The JDBC driver will
 5268        * do any necessary conversion from ASCII to the database char format.
 5269        *
 5270        * <P><B>Note:</B> This stream object can either be a standard
 5271        * Java stream object or your own subclass that implements the
 5272        * standard interface.
 5273        *   <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 5274        * it might be more efficient to use a version of
 5275        * <code>updateBlob</code> which takes a length parameter.
 5276        * <p>
 5277        * The updater methods are used to update column values in the
 5278        * current row or the insert row.  The updater methods do not
 5279        * update the underlying database; instead the <code>updateRow</code> or
 5280        * <code>insertRow</code> methods are called to update the database.
 5281        *
 5282        * @param columnLabel the label for the column specified with the SQL AS clause.  If the SQL AS clause was not specified, then the la
 5283   bel is the name of the column
 5284        * @param inputStream An object that contains the data to set the parameter
 5285        * value to.
 5286        * @exception SQLException if a database access error occurs,
 5287        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5288        * or this method is called on a closed result set
 5289        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5290        * this method
 5291        * @since 1.6
 5292        */
 5293       public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
 5294           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5295       }
 5296   
 5297       /**
 5298        * Updates the designated column using the given <code>Reader</code>
 5299        * object, which is the given number of characters long.
 5300        * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
 5301        * parameter, it may be more practical to send it via a
 5302        * <code>java.io.Reader</code> object. The data will be read from the stream
 5303        * as needed until end-of-file is reached.  The JDBC driver will
 5304        * do any necessary conversion from UNICODE to the database char format.
 5305        *
 5306        * <P><B>Note:</B> This stream object can either be a standard
 5307        * Java stream object or your own subclass that implements the
 5308        * standard interface.
 5309        * <p>
 5310        * The updater methods are used to update column values in the
 5311        * current row or the insert row.  The updater methods do not
 5312        * update the underlying database; instead the <code>updateRow</code> or
 5313        * <code>insertRow</code> methods are called to update the database.
 5314        *
 5315        * @param columnIndex the first column is 1, the second is 2, ...
 5316        * @param reader An object that contains the data to set the parameter value to.
 5317        * @param length the number of characters in the parameter data.
 5318        * @exception SQLException if a database access error occurs,
 5319        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5320        * or this method is called on a closed result set
 5321        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5322        * this method
 5323        * @since 1.6
 5324        */
 5325       public void updateClob(int columnIndex,  Reader reader, long length) throws SQLException {
 5326           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5327       }
 5328   
 5329       /**
 5330        * Updates the designated column using the given <code>Reader</code>
 5331        * object, which is the given number of characters long.
 5332        * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
 5333        * parameter, it may be more practical to send it via a
 5334        * <code>java.io.Reader</code> object. The data will be read from the stream
 5335        * as needed until end-of-file is reached.  The JDBC driver will
 5336        * do any necessary conversion from UNICODE to the database char format.
 5337        *
 5338        * <P><B>Note:</B> This stream object can either be a standard
 5339        * Java stream object or your own subclass that implements the
 5340        * standard interface.
 5341        * <p>
 5342        * The updater methods are used to update column values in the
 5343        * current row or the insert row.  The updater methods do not
 5344        * update the underlying database; instead the <code>updateRow</code> or
 5345        * <code>insertRow</code> methods are called to update the database.
 5346        *
 5347        * @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
 5348        * @param reader An object that contains the data to set the parameter value to.
 5349        * @param length the number of characters in the parameter data.
 5350        * @exception SQLException if a database access error occurs,
 5351        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5352        * or this method is called on a closed result set
 5353        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5354        * this method
 5355        * @since 1.6
 5356        */
 5357       public void updateClob(String columnLabel,  Reader reader, long length) throws SQLException {
 5358           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5359       }
 5360   
 5361       /**
 5362        * Updates the designated column using the given <code>Reader</code>
 5363        * object.
 5364        * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
 5365        * parameter, it may be more practical to send it via a
 5366        * <code>java.io.Reader</code> object. The data will be read from the stream
 5367        * as needed until end-of-file is reached.  The JDBC driver will
 5368        * do any necessary conversion from UNICODE to the database char format.
 5369        *
 5370        * <P><B>Note:</B> This stream object can either be a standard
 5371        * Java stream object or your own subclass that implements the
 5372        * standard interface.
 5373        *   <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 5374        * it might be more efficient to use a version of
 5375        * <code>updateClob</code> which takes a length parameter.
 5376        * <p>
 5377        * The updater methods are used to update column values in the
 5378        * current row or the insert row.  The updater methods do not
 5379        * update the underlying database; instead the <code>updateRow</code> or
 5380        * <code>insertRow</code> methods are called to update the database.
 5381        *
 5382        * @param columnIndex the first column is 1, the second is 2, ...
 5383        * @param reader An object that contains the data to set the parameter value to.
 5384        * @exception SQLException if a database access error occurs,
 5385        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5386        * or this method is called on a closed result set
 5387        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5388        * this method
 5389        * @since 1.6
 5390        */
 5391       public void updateClob(int columnIndex,  Reader reader) throws SQLException {
 5392           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5393       }
 5394   
 5395       /**
 5396        * Updates the designated column using the given <code>Reader</code>
 5397        * object.
 5398        * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
 5399        * parameter, it may be more practical to send it via a
 5400        * <code>java.io.Reader</code> object. The data will be read from the stream
 5401        * as needed until end-of-file is reached.  The JDBC driver will
 5402        * do any necessary conversion from UNICODE to the database char format.
 5403        *
 5404        * <P><B>Note:</B> This stream object can either be a standard
 5405        * Java stream object or your own subclass that implements the
 5406        * standard interface.
 5407        *  <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 5408        * it might be more efficient to use a version of
 5409        * <code>updateClob</code> which takes a length parameter.
 5410        * <p>
 5411        * The updater methods are used to update column values in the
 5412        * current row or the insert row.  The updater methods do not
 5413        * update the underlying database; instead the <code>updateRow</code> or
 5414        * <code>insertRow</code> methods are called to update the database.
 5415        *
 5416        * @param columnLabel the label for the column specified with the SQL AS clause.  If the SQL AS clause was not specified, then the la
 5417   bel is the name of the column
 5418        * @param reader An object that contains the data to set the parameter value to.
 5419        * @exception SQLException if a database access error occurs,
 5420        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5421        * or this method is called on a closed result set
 5422        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5423        * this method
 5424        * @since 1.6
 5425        */
 5426       public void updateClob(String columnLabel,  Reader reader) throws SQLException {
 5427           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5428       }
 5429   
 5430      /**
 5431        * Updates the designated column using the given <code>Reader</code>
 5432        * object, which is the given number of characters long.
 5433        * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
 5434        * parameter, it may be more practical to send it via a
 5435        * <code>java.io.Reader</code> object. The data will be read from the stream
 5436        * as needed until end-of-file is reached.  The JDBC driver will
 5437        * do any necessary conversion from UNICODE to the database char format.
 5438        *
 5439        * <P><B>Note:</B> This stream object can either be a standard
 5440        * Java stream object or your own subclass that implements the
 5441        * standard interface.
 5442        * <p>
 5443        * The updater methods are used to update column values in the
 5444        * current row or the insert row.  The updater methods do not
 5445        * update the underlying database; instead the <code>updateRow</code> or
 5446        * <code>insertRow</code> methods are called to update the database.
 5447        *
 5448        * @param columnIndex the first column is 1, the second 2, ...
 5449        * @param reader An object that contains the data to set the parameter value to.
 5450        * @param length the number of characters in the parameter data.
 5451        * @throws SQLException if the driver does not support national
 5452        *         character sets;  if the driver can detect that a data conversion
 5453        *  error could occur; this method is called on a closed result set,
 5454        * if a database access error occurs or
 5455        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5456        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5457        * this method
 5458        * @since 1.6
 5459        */
 5460       public void updateNClob(int columnIndex,  Reader reader, long length) throws SQLException {
 5461           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5462       }
 5463   
 5464       /**
 5465        * Updates the designated column using the given <code>Reader</code>
 5466        * object, which is the given number of characters long.
 5467        * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
 5468        * parameter, it may be more practical to send it via a
 5469        * <code>java.io.Reader</code> object. The data will be read from the stream
 5470        * as needed until end-of-file is reached.  The JDBC driver will
 5471        * do any necessary conversion from UNICODE to the database char format.
 5472        *
 5473        * <P><B>Note:</B> This stream object can either be a standard
 5474        * Java stream object or your own subclass that implements the
 5475        * standard interface.
 5476        * <p>
 5477        * The updater methods are used to update column values in the
 5478        * current row or the insert row.  The updater methods do not
 5479        * update the underlying database; instead the <code>updateRow</code> or
 5480        * <code>insertRow</code> methods are called to update the database.
 5481        *
 5482        * @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
 5483        * @param reader An object that contains the data to set the parameter value to.
 5484        * @param length the number of characters in the parameter data.
 5485        * @throws SQLException if the driver does not support national
 5486        *         character sets;  if the driver can detect that a data conversion
 5487        *  error could occur; this method is called on a closed result set;
 5488        *  if a database access error occurs or
 5489        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5490        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5491        * this method
 5492        * @since 1.6
 5493        */
 5494       public void updateNClob(String columnLabel,  Reader reader, long length) throws SQLException {
 5495           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5496       }
 5497   
 5498       /**
 5499        * Updates the designated column using the given <code>Reader</code>
 5500        * object.
 5501        * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
 5502        * parameter, it may be more practical to send it via a
 5503        * <code>java.io.Reader</code> object. The data will be read from the stream
 5504        * as needed until end-of-file is reached.  The JDBC driver will
 5505        * do any necessary conversion from UNICODE to the database char format.
 5506        *
 5507        * <P><B>Note:</B> This stream object can either be a standard
 5508        * Java stream object or your own subclass that implements the
 5509        * standard interface.
 5510        * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 5511        * it might be more efficient to use a version of
 5512        * <code>updateNClob</code> which takes a length parameter.
 5513        * <p>
 5514        * The updater methods are used to update column values in the
 5515        * current row or the insert row.  The updater methods do not
 5516        * update the underlying database; instead the <code>updateRow</code> or
 5517        * <code>insertRow</code> methods are called to update the database.
 5518        *
 5519        * @param columnIndex the first column is 1, the second 2, ...
 5520        * @param reader An object that contains the data to set the parameter value to.
 5521        * @throws SQLException if the driver does not support national
 5522        *         character sets;  if the driver can detect that a data conversion
 5523        *  error could occur; this method is called on a closed result set,
 5524        * if a database access error occurs or
 5525        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5526        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5527        * this method
 5528        * @since 1.6
 5529        */
 5530       public void updateNClob(int columnIndex,  Reader reader) throws SQLException {
 5531           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5532       }
 5533   
 5534       /**
 5535        * Updates the designated column using the given <code>Reader</code>
 5536        * object.
 5537        * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
 5538        * parameter, it may be more practical to send it via a
 5539        * <code>java.io.Reader</code> object. The data will be read from the stream
 5540        * as needed until end-of-file is reached.  The JDBC driver will
 5541        * do any necessary conversion from UNICODE to the database char format.
 5542        *
 5543        * <P><B>Note:</B> This stream object can either be a standard
 5544        * Java stream object or your own subclass that implements the
 5545        * standard interface.
 5546        * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 5547        * it might be more efficient to use a version of
 5548        * <code>updateNClob</code> which takes a length parameter.
 5549        * <p>
 5550        * The updater methods are used to update column values in the
 5551        * current row or the insert row.  The updater methods do not
 5552        * update the underlying database; instead the <code>updateRow</code> or
 5553        * <code>insertRow</code> methods are called to update the database.
 5554        *
 5555        * @param columnLabel the label for the column specified with the SQL AS clause.  If the SQL AS clause was not specified, then the la
 5556   bel is the name of the column
 5557        * @param reader An object that contains the data to set the parameter value to.
 5558        * @throws SQLException if the driver does not support national
 5559        *         character sets;  if the driver can detect that a data conversion
 5560        *  error could occur; this method is called on a closed result set;
 5561        *  if a database access error occurs or
 5562        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5563        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5564        * this method
 5565        * @since 1.6
 5566        */
 5567       public void updateNClob(String columnLabel,  Reader reader) throws SQLException {
 5568           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5569       }
 5570   
 5571   
 5572           /**
 5573        * Updates the designated column with an ascii stream value, which will have
 5574        * the specified number of bytes.
 5575        * The updater methods are used to update column values in the
 5576        * current row or the insert row.  The updater methods do not
 5577        * update the underlying database; instead the <code>updateRow</code> or
 5578        * <code>insertRow</code> methods are called to update the database.
 5579        *
 5580        * @param columnIndex the first column is 1, the second is 2, ...
 5581        * @param x the new column value
 5582        * @param length the length of the stream
 5583        * @exception SQLException if a database access error occurs,
 5584        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5585        * or this method is called on a closed result set
 5586        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5587        * this method
 5588        * @since 1.6
 5589        */
 5590       public void updateAsciiStream(int columnIndex,
 5591                              java.io.InputStream x,
 5592                              long length) throws SQLException {
 5593           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5594       }
 5595   
 5596       /**
 5597        * Updates the designated column with a binary stream value, which will have
 5598        * the specified number of bytes.
 5599        * The updater methods are used to update column values in the
 5600        * current row or the insert row.  The updater methods do not
 5601        * update the underlying database; instead the <code>updateRow</code> or
 5602        * <code>insertRow</code> methods are called to update the database.
 5603        *
 5604        * @param columnIndex the first column is 1, the second is 2, ...
 5605        * @param x the new column value
 5606        * @param length the length of the stream
 5607        * @exception SQLException if a database access error occurs,
 5608        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5609        * or this method is called on a closed result set
 5610        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5611        * this method
 5612        * @since 1.6
 5613        */
 5614       public void updateBinaryStream(int columnIndex,
 5615                               java.io.InputStream x,
 5616                               long length) throws SQLException {
 5617           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5618       }
 5619   
 5620       /**
 5621        * Updates the designated column with a character stream value, which will have
 5622        * the specified number of bytes.
 5623        * The updater methods are used to update column values in the
 5624        * current row or the insert row.  The updater methods do not
 5625        * update the underlying database; instead the <code>updateRow</code> or
 5626        * <code>insertRow</code> methods are called to update the database.
 5627        *
 5628        * @param columnIndex the first column is 1, the second is 2, ...
 5629        * @param x the new column value
 5630        * @param length the length of the stream
 5631        * @exception SQLException if a database access error occurs,
 5632        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5633        * or this method is called on a closed result set
 5634        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5635        * this method
 5636        * @since 1.6
 5637        */
 5638       public void updateCharacterStream(int columnIndex,
 5639                                java.io.Reader x,
 5640                                long length) throws SQLException {
 5641           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5642       }
 5643   
 5644        /**
 5645        * Updates the designated column with an ascii stream value, which will have
 5646        * the specified number of bytes..
 5647        * The updater methods are used to update column values in the
 5648        * current row or the insert row.  The updater methods do not
 5649        * update the underlying database; instead the <code>updateRow</code> or
 5650        * <code>insertRow</code> methods are called to update the database.
 5651        *
 5652        * @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
 5653        * @param x the new column value
 5654        * @param length the length of the stream
 5655        * @exception SQLException if a database access error occurs,
 5656        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5657        * or this method is called on a closed result set
 5658        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5659        * this method
 5660        * @since 1.6
 5661        */
 5662       public void updateAsciiStream(String columnLabel,
 5663                              java.io.InputStream x,
 5664                              long length) throws SQLException {
 5665           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5666       }
 5667   
 5668       /**
 5669        * Updates the designated column with an ascii stream value.
 5670        * The updater methods are used to update column values in the
 5671        * current row or the insert row.  The updater methods do not
 5672        * update the underlying database; instead the <code>updateRow</code> or
 5673        * <code>insertRow</code> methods are called to update the database.
 5674        *
 5675        * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 5676        * it might be more efficient to use a version of
 5677        * <code>updateAsciiStream</code> which takes a length parameter.
 5678        *
 5679        * @param columnIndex the first column is 1, the second is 2, ...
 5680        * @param x the new column value
 5681        * @exception SQLException if a database access error occurs,
 5682        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5683        * or this method is called on a closed result set
 5684        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5685        * this method
 5686        * @since 1.6
 5687        */
 5688       public void updateAsciiStream(int columnIndex,
 5689                              java.io.InputStream x) throws SQLException {
 5690           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5691       }
 5692   
 5693       /**
 5694        * Updates the designated column with an ascii stream value.
 5695        * The updater methods are used to update column values in the
 5696        * current row or the insert row.  The updater methods do not
 5697        * update the underlying database; instead the <code>updateRow</code> or
 5698        * <code>insertRow</code> methods are called to update the database.
 5699        *
 5700        * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 5701        * it might be more efficient to use a version of
 5702        * <code>updateAsciiStream</code> which takes a length parameter.
 5703        *
 5704        * @param columnLabel the label for the column specified with the SQL AS clause.  If the SQL AS clause was not specified, then the la
 5705   bel is the name of the column
 5706        * @param x the new column value
 5707        * @exception SQLException if a database access error occurs,
 5708        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5709        * or this method is called on a closed result set
 5710        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5711        * this method
 5712        * @since 1.6
 5713        */
 5714       public void updateAsciiStream(String columnLabel,
 5715                              java.io.InputStream x) throws SQLException {
 5716           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5717       }
 5718   
 5719   
 5720       /**
 5721        * Updates the designated column with a binary stream value, which will have
 5722        * the specified number of bytes.
 5723        * The updater methods are used to update column values in the
 5724        * current row or the insert row.  The updater methods do not
 5725        * update the underlying database; instead the <code>updateRow</code> or
 5726        * <code>insertRow</code> methods are called to update the database.
 5727        *
 5728        * @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
 5729        * @param x the new column value
 5730        * @param length the length of the stream
 5731        * @exception SQLException if a database access error occurs,
 5732        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5733        * or this method is called on a closed result set
 5734        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5735        * this method
 5736        * @since 1.6
 5737        */
 5738       public void updateBinaryStream(String columnLabel,
 5739                               java.io.InputStream x,
 5740                               long length) throws SQLException {
 5741           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5742       }
 5743   
 5744       /**
 5745        * Updates the designated column with a binary stream value.
 5746        * The updater methods are used to update column values in the
 5747        * current row or the insert row.  The updater methods do not
 5748        * update the underlying database; instead the <code>updateRow</code> or
 5749        * <code>insertRow</code> methods are called to update the database.
 5750        *
 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>updateBinaryStream</code> which takes a length parameter.
 5754        *
 5755        * @param columnIndex the first column is 1, the second is 2, ...
 5756        * @param x the new column value
 5757        * @exception SQLException if a database access error occurs,
 5758        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5759        * or this method is called on a closed result set
 5760        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5761        * this method
 5762        * @since 1.6
 5763        */
 5764       public void updateBinaryStream(int columnIndex,
 5765                               java.io.InputStream x) throws SQLException {
 5766           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5767       }
 5768   
 5769   
 5770       /**
 5771        * Updates the designated column with a binary stream value.
 5772        * The updater methods are used to update column values in the
 5773        * current row or the insert row.  The updater methods do not
 5774        * update the underlying database; instead the <code>updateRow</code> or
 5775        * <code>insertRow</code> methods are called to update the database.
 5776        *
 5777        * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 5778        * it might be more efficient to use a version of
 5779        * <code>updateBinaryStream</code> which takes a length parameter.
 5780        *
 5781        * @param columnLabel the label for the column specified with the SQL AS clause.  If the SQL AS clause was not specified, then the la
 5782   bel is the name of the column
 5783        * @param x the new column value
 5784        * @exception SQLException if a database access error occurs,
 5785        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5786        * or this method is called on a closed result set
 5787        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5788        * this method
 5789        * @since 1.6
 5790        */
 5791       public void updateBinaryStream(String columnLabel,
 5792                               java.io.InputStream x) throws SQLException {
 5793           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5794       }
 5795   
 5796   
 5797       /**
 5798        * Updates the designated column with a character stream value, which will have
 5799        * the specified number of bytes.
 5800        * The updater methods are used to update column values in the
 5801        * current row or the insert row.  The updater methods do not
 5802        * update the underlying database; instead the <code>updateRow</code> or
 5803        * <code>insertRow</code> methods are called to update the database.
 5804        *
 5805        * @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
 5806        * @param reader the <code>java.io.Reader</code> object containing
 5807        *        the new column value
 5808        * @param length the length of the stream
 5809        * @exception SQLException if a database access error occurs,
 5810        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5811        * or this method is called on a closed result set
 5812        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5813        * this method
 5814        * @since 1.6
 5815        */
 5816       public void updateCharacterStream(String columnLabel,
 5817                                java.io.Reader reader,
 5818                                long length) throws SQLException {
 5819           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5820       }
 5821   
 5822       /**
 5823        * Updates the designated column with a character stream value.
 5824        * The updater methods are used to update column values in the
 5825        * current row or the insert row.  The updater methods do not
 5826        * update the underlying database; instead the <code>updateRow</code> or
 5827        * <code>insertRow</code> methods are called to update the database.
 5828        *
 5829        * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 5830        * it might be more efficient to use a version of
 5831        * <code>updateCharacterStream</code> which takes a length parameter.
 5832        *
 5833        * @param columnIndex the first column is 1, the second is 2, ...
 5834        * @param x the new column value
 5835        * @exception SQLException if a database access error occurs,
 5836        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5837        * or this method is called on a closed result set
 5838        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5839        * this method
 5840        * @since 1.6
 5841        */
 5842       public void updateCharacterStream(int columnIndex,
 5843                                java.io.Reader x) throws SQLException {
 5844           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5845       }
 5846   
 5847       /**
 5848        * Updates the designated column with a character stream value.
 5849        * The updater methods are used to update column values in the
 5850        * current row or the insert row.  The updater methods do not
 5851        * update the underlying database; instead the <code>updateRow</code> or
 5852        * <code>insertRow</code> methods are called to update the database.
 5853        *
 5854        * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 5855        * it might be more efficient to use a version of
 5856        * <code>updateCharacterStream</code> which takes a length parameter.
 5857        *
 5858        * @param columnLabel the label for the column specified with the SQL AS clause.  If the SQL AS clause was not specified, then the la
 5859   bel is the name of the column
 5860        * @param reader the <code>java.io.Reader</code> object containing
 5861        *        the new column value
 5862        * @exception SQLException if a database access error occurs,
 5863        * the result set concurrency is <code>CONCUR_READ_ONLY</code>
 5864        * or this method is called on a closed result set
 5865        * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5866        * this method
 5867        * @since 1.6
 5868        */
 5869       public void updateCharacterStream(String columnLabel,
 5870                                java.io.Reader reader) throws SQLException {
 5871           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5872       }
 5873   
 5874   
 5875        /**
 5876     * Sets the designated parameter to the given <code>java.net.URL</code> value.
 5877     * The driver converts this to an SQL <code>DATALINK</code> value
 5878     * when it sends it to the database.
 5879     *
 5880     * @param parameterIndex the first parameter is 1, the second is 2, ...
 5881     * @param x the <code>java.net.URL</code> object to be set
 5882     * @exception SQLException if a database access error occurs or
 5883     * this method is called on a closed <code>PreparedStatement</code>
 5884     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
 5885     * @since 1.4
 5886     */
 5887     public void setURL(int parameterIndex, java.net.URL x) throws SQLException{
 5888           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5889      }
 5890   
 5891   
 5892      /**
 5893     * Sets the designated parameter to a <code>Reader</code> object.
 5894     * This method differs from the <code>setCharacterStream (int, Reader)</code> method
 5895     * because it informs the driver that the parameter value should be sent to
 5896     * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
 5897     * driver may have to do extra work to determine whether the parameter
 5898     * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
 5899     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 5900     * it might be more efficient to use a version of
 5901     * <code>setNClob</code> which takes a length parameter.
 5902     *
 5903     * @param parameterIndex index of the first parameter is 1, the second is 2, ...
 5904     * @param reader An object that contains the data to set the parameter value to.
 5905     * @throws SQLException if parameterIndex does not correspond to a parameter
 5906     * marker in the SQL statement;
 5907     * if the driver does not support national character sets;
 5908     * if the driver can detect that a data conversion
 5909     *  error could occur;  if a database access error occurs or
 5910     * this method is called on a closed <code>PreparedStatement</code>
 5911     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
 5912     *
 5913     * @since 1.6
 5914     */
 5915     public void setNClob(int parameterIndex, Reader reader)
 5916       throws SQLException{
 5917           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5918      }
 5919   
 5920      /**
 5921     * Sets the designated parameter to a <code>Reader</code> object.  The <code>reader</code> must contain the number
 5922                * of characters specified by length otherwise a <code>SQLException</code> will be
 5923               * generated when the <code>CallableStatement</code> is executed.
 5924               * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
 5925               * because it informs the driver that the parameter value should be sent to
 5926               * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
 5927               * driver may have to do extra work to determine whether the parameter
 5928               * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
 5929               *
 5930               * @param parameterName the name of the parameter to be set
 5931               * @param reader An object that contains the data to set the parameter value to.
 5932               * @param length the number of characters in the parameter data.
 5933               * @throws SQLException if parameterIndex does not correspond to a parameter
 5934               * marker in the SQL statement; if the length specified is less than zero;
 5935               * if the driver does not support national
 5936               *         character sets;  if the driver can detect that a data conversion
 5937               *  error could occur; if a database access error occurs or
 5938               * this method is called on a closed <code>CallableStatement</code>
 5939               * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 5940               * this method
 5941               * @since 1.6
 5942               */
 5943               public void setNClob(String parameterName, Reader reader, long length)
 5944       throws SQLException{
 5945           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5946      }
 5947   
 5948   
 5949    /**
 5950     * Sets the designated parameter to a <code>Reader</code> object.
 5951     * This method differs from the <code>setCharacterStream (int, Reader)</code> method
 5952     * because it informs the driver that the parameter value should be sent to
 5953     * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
 5954     * driver may have to do extra work to determine whether the parameter
 5955     * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
 5956     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 5957     * it might be more efficient to use a version of
 5958     * <code>setNClob</code> which takes a length parameter.
 5959     *
 5960     * @param parameterName the name of the parameter
 5961     * @param reader An object that contains the data to set the parameter value to.
 5962     * @throws SQLException if the driver does not support national character sets;
 5963     * if the driver can detect that a data conversion
 5964     *  error could occur;  if a database access error occurs or
 5965     * this method is called on a closed <code>CallableStatement</code>
 5966     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
 5967     *
 5968     * @since 1.6
 5969     */
 5970     public void setNClob(String parameterName, Reader reader)
 5971       throws SQLException{
 5972                throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 5973      }
 5974   
 5975   
 5976      /**
 5977        ** of characters specified by length otherwise a <code>SQLException</code> will becontain  the number
 5978        * generated when the <code>PreparedStatement</code> is executed.
 5979        * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
 5980        * because it informs the driver that the parameter value should be sent to
 5981        * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
 5982        * driver may have to do extra work to determine whether the parameter
 5983        * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
 5984        * @param parameterIndex index of the first parameter is 1, the second is 2, ...
 5985        * @param reader An object that contains the data to set the parameter value to.
 5986        * @param length the number of characters in the parameter data.
 5987        * @throws SQLException if parameterIndex does not correspond to a parameter
 5988        * marker in the SQL statement; if the length specified is less than zero;
 5989        * if the driver does not support national character sets;
 5990        * if the driver can detect that a data conversion
 5991        *  error could occur;  if a database access error occurs or
 5992        * this method is called on a closed <code>PreparedStatement</code>
 5993        * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
 5994        *
 5995        * @since 1.6
 5996        */
 5997        public void setNClob(int parameterIndex, Reader reader, long length)
 5998          throws SQLException{
 5999           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6000      }
 6001   
 6002   
 6003       /**
 6004        * Sets the designated parameter to a <code>java.sql.NClob</code> object. The driver converts this to
 6005   a
 6006        * SQL <code>NCLOB</code> value when it sends it to the database.
 6007        * @param parameterIndex of the first parameter is 1, the second is 2, ...
 6008        * @param value the parameter value
 6009        * @throws SQLException if the driver does not support national
 6010        *         character sets;  if the driver can detect that a data conversion
 6011        *  error could occur ; or if a database access error occurs
 6012        * @since 1.6
 6013        */
 6014        public void setNClob(int parameterIndex, NClob value) throws SQLException{
 6015           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6016      }
 6017   
 6018   
 6019    /**
 6020     * Sets the designated paramter to the given <code>String</code> object.
 6021     * The driver converts this to a SQL <code>NCHAR</code> or
 6022     * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code>
 6023     * @param parameterName the name of the column to be set
 6024     * @param value the parameter value
 6025     * @throws SQLException if the driver does not support national
 6026     *         character sets;  if the driver can detect that a data conversion
 6027     *  error could occur; or if a database access error occurs
 6028     * @since 1.6
 6029     */
 6030    public void setNString(String parameterName, String value)
 6031            throws SQLException{
 6032           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6033      }
 6034   
 6035    /**
 6036     * Sets the designated parameter to a <code>Reader</code> object. The
 6037     * <code>Reader</code> reads the data till end-of-file is reached. The
 6038     * driver does the necessary conversion from Java character format to
 6039     * the national character set in the database.
 6040     * @param parameterIndex of the first parameter is 1, the second is 2, ...
 6041     * @param value the parameter value
 6042     * @param length the number of characters in the parameter data.
 6043     * @throws SQLException if the driver does not support national
 6044     *         character sets;  if the driver can detect that a data conversion
 6045     *  error could occur ; or if a database access error occurs
 6046     * @since 1.6
 6047     */
 6048     public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException{
 6049           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6050      }
 6051   
 6052   
 6053   
 6054    /**
 6055     * Sets the designated parameter to a <code>Reader</code> object. The
 6056     * <code>Reader</code> reads the data till end-of-file is reached. The
 6057     * driver does the necessary conversion from Java character format to
 6058     * the national character set in the database.
 6059     * @param parameterName the name of the column to be set
 6060     * @param value the parameter value
 6061     * @param length the number of characters in the parameter data.
 6062     * @throws SQLException if the driver does not support national
 6063     *         character sets;  if the driver can detect that a data conversion
 6064     *  error could occur; or if a database access error occurs
 6065     * @since 1.6
 6066     */
 6067    public void setNCharacterStream(String parameterName, Reader value, long length)
 6068            throws SQLException{
 6069           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6070      }
 6071   
 6072     /**
 6073     * Sets the designated parameter to a <code>Reader</code> object. The
 6074     * <code>Reader</code> reads the data till end-of-file is reached. The
 6075     * driver does the necessary conversion from Java character format to
 6076     * the national character set in the database.
 6077   
 6078     * <P><B>Note:</B> This stream object can either be a standard
 6079     * Java stream object or your own subclass that implements the
 6080     * standard interface.
 6081     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 6082     * it might be more efficient to use a version of
 6083     * <code>setNCharacterStream</code> which takes a length parameter.
 6084     *
 6085     * @param parameterName the name of the parameter
 6086     * @param value the parameter value
 6087     * @throws SQLException if the driver does not support national
 6088     *         character sets;  if the driver can detect that a data conversion
 6089     *  error could occur ; if a database access error occurs; or
 6090     * this method is called on a closed <code>CallableStatement</code>
 6091     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
 6092     * @since 1.6
 6093     */
 6094     public void setNCharacterStream(String parameterName, Reader value) throws SQLException{
 6095           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6096      }
 6097   
 6098     /**
 6099       * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value,
 6100       * using the given <code>Calendar</code> object.  The driver uses
 6101       * the <code>Calendar</code> object to construct an SQL <code>TIMESTAMP</code> value,
 6102       * which the driver then sends to the database.  With a
 6103       * a <code>Calendar</code> object, the driver can calculate the timestamp
 6104       * taking into account a custom timezone.  If no
 6105       * <code>Calendar</code> object is specified, the driver uses the default
 6106       * timezone, which is that of the virtual machine running the application.
 6107       *
 6108       * @param parameterName the name of the parameter
 6109       * @param x the parameter value
 6110       * @param cal the <code>Calendar</code> object the driver will use
 6111       *            to construct the timestamp
 6112       * @exception SQLException if a database access error occurs or
 6113       * this method is called on a closed <code>CallableStatement</code>
 6114       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6115       * this method
 6116       * @see #getTimestamp
 6117       * @since 1.4
 6118       */
 6119       public void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal)
 6120          throws SQLException{
 6121           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6122      }
 6123   
 6124       /**
 6125       * Sets the designated parameter to a <code>Reader</code> object.  The <code>reader</code> must contain  the number
 6126                  * of characters specified by length otherwise a <code>SQLException</code> will be
 6127                  * generated when the <code>CallableStatement</code> is executed.
 6128                 * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
 6129                 * because it informs the driver that the parameter value should be sent to
 6130                 * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
 6131                  * driver may have to do extra work to determine whether the parameter
 6132                  * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
 6133                  * @param parameterName the name of the parameter to be set
 6134                 * @param reader An object that contains the data to set the parameter value to.
 6135                 * @param length the number of characters in the parameter data.
 6136                 * @throws SQLException if parameterIndex does not correspond to a parameter
 6137                 * marker in the SQL statement; if the length specified is less than zero;
 6138                 * a database access error occurs or
 6139                 * this method is called on a closed <code>CallableStatement</code>
 6140                 * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6141                 * this method
 6142                 *
 6143                 * @since 1.6
 6144                 */
 6145         public  void setClob(String parameterName, Reader reader, long length)
 6146         throws SQLException{
 6147           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6148      }
 6149   
 6150   
 6151   
 6152     /**
 6153       * Sets the designated parameter to the given <code>java.sql.Clob</code> object.
 6154       * The driver converts this to an SQL <code>CLOB</code> value when it
 6155       * sends it to the database.
 6156       *
 6157       * @param parameterName the name of the parameter
 6158       * @param x a <code>Clob</code> object that maps an SQL <code>CLOB</code> value
 6159       * @exception SQLException if a database access error occurs or
 6160       * this method is called on a closed <code>CallableStatement</code>
 6161       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6162       * this method
 6163       * @since 1.6
 6164       */
 6165       public void setClob (String parameterName, Clob x) throws SQLException{
 6166           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6167      }
 6168   
 6169    /**
 6170       * Sets the designated parameter to a <code>Reader</code> object.
 6171       * This method differs from the <code>setCharacterStream (int, Reader)</code> method
 6172       * because it informs the driver that the parameter value should be sent to
 6173       * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
 6174       * driver may have to do extra work to determine whether the parameter
 6175       * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
 6176       *
 6177       * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 6178       * it might be more efficient to use a version of
 6179       * <code>setClob</code> which takes a length parameter.
 6180       *
 6181       * @param parameterName the name of the parameter
 6182       * @param reader An object that contains the data to set the parameter value to.
 6183       * @throws SQLException if a database access error occurs or this method is called on
 6184       * a closed <code>CallableStatement</code>
 6185       *
 6186       * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
 6187       * @since 1.6
 6188       */
 6189       public void setClob(String parameterName, Reader reader)
 6190         throws SQLException{
 6191           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6192      }
 6193   
 6194   
 6195    /**
 6196       * Sets the designated parameter to the given <code>java.sql.Date</code> value
 6197       * using the default time zone of the virtual machine that is running
 6198       * the application.
 6199       * The driver converts this
 6200       * to an SQL <code>DATE</code> value when it sends it to the database.
 6201       *
 6202       * @param parameterName the name of the parameter
 6203       * @param x the parameter value
 6204       * @exception SQLException if a database access error occurs or
 6205       * this method is called on a closed <code>CallableStatement</code>
 6206       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6207       * this method
 6208       * @see #getDate
 6209       * @since 1.4
 6210       */
 6211       public void setDate(String parameterName, java.sql.Date x)
 6212          throws SQLException{
 6213           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6214      }
 6215   
 6216      /**
 6217       * Sets the designated parameter to the given <code>java.sql.Date</code> value,
 6218       * using the given <code>Calendar</code> object.  The driver uses
 6219       * the <code>Calendar</code> object to construct an SQL <code>DATE</code> value,
 6220       * which the driver then sends to the database.  With a
 6221       * a <code>Calendar</code> object, the driver can calculate the date
 6222       * taking into account a custom timezone.  If no
 6223       * <code>Calendar</code> object is specified, the driver uses the default
 6224       * timezone, which is that of the virtual machine running the application.
 6225       *
 6226       * @param parameterName the name of the parameter
 6227       * @param x the parameter value
 6228       * @param cal the <code>Calendar</code> object the driver will use
 6229       *            to construct the date
 6230       * @exception SQLException if a database access error occurs or
 6231       * this method is called on a closed <code>CallableStatement</code>
 6232       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6233       * this method
 6234       * @see #getDate
 6235       * @since 1.4
 6236       */
 6237      public void setDate(String parameterName, java.sql.Date x, Calendar cal)
 6238          throws SQLException{
 6239           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6240      }
 6241   
 6242   
 6243    /**
 6244       * Sets the designated parameter to the given <code>java.sql.Time</code> value.
 6245       * The driver converts this
 6246       * to an SQL <code>TIME</code> value when it sends it to the database.
 6247       *
 6248       * @param parameterName the name of the parameter
 6249       * @param x the parameter value
 6250       * @exception SQLException if a database access error occurs or
 6251       * this method is called on a closed <code>CallableStatement</code>
 6252       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6253       * this method
 6254       * @see #getTime
 6255       * @since 1.4
 6256       */
 6257      public void setTime(String parameterName, java.sql.Time x)
 6258          throws SQLException{
 6259           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6260      }
 6261   
 6262    /**
 6263       * Sets the designated parameter to the given <code>java.sql.Time</code> value,
 6264       * using the given <code>Calendar</code> object.  The driver uses
 6265       * the <code>Calendar</code> object to construct an SQL <code>TIME</code> value,
 6266       * which the driver then sends to the database.  With a
 6267       * a <code>Calendar</code> object, the driver can calculate the time
 6268       * taking into account a custom timezone.  If no
 6269       * <code>Calendar</code> object is specified, the driver uses the default
 6270       * timezone, which is that of the virtual machine running the application.
 6271       *
 6272       * @param parameterName the name of the parameter
 6273       * @param x the parameter value
 6274       * @param cal the <code>Calendar</code> object the driver will use
 6275       *            to construct the time
 6276       * @exception SQLException if a database access error occurs or
 6277       * this method is called on a closed <code>CallableStatement</code>
 6278       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6279       * this method
 6280       * @see #getTime
 6281       * @since 1.4
 6282       */
 6283      public void setTime(String parameterName, java.sql.Time x, Calendar cal)
 6284          throws SQLException{
 6285           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6286      }
 6287   
 6288      /**
 6289      * Sets the designated parameter to a <code>Reader</code> object.
 6290      * This method differs from the <code>setCharacterStream (int, Reader)</code> method
 6291      * because it informs the driver that the parameter value should be sent to
 6292      * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
 6293      * driver may have to do extra work to determine whether the parameter
 6294      * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
 6295      *
 6296      * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 6297      * it might be more efficient to use a version of
 6298      * <code>setClob</code> which takes a length parameter.
 6299      *
 6300      * @param parameterIndex index of the first parameter is 1, the second is 2, ...
 6301      * @param reader An object that contains the data to set the parameter value to.
 6302      * @throws SQLException if a database access error occurs, this method is called on
 6303      * a closed <code>PreparedStatement</code>or if parameterIndex does not correspond to a parameter
 6304      * marker in the SQL statement
 6305      *
 6306      * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
 6307      * @since 1.6
 6308      */
 6309      public void setClob(int parameterIndex, Reader reader)
 6310        throws SQLException{
 6311           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6312      }
 6313   
 6314   
 6315      /**
 6316      * Sets the designated parameter to a <code>Reader</code> object.  The reader must contain  the number
 6317      * of characters specified by length otherwise a <code>SQLException</code> will be
 6318      * generated when the <code>PreparedStatement</code> is executed.
 6319      *This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
 6320      * because it informs the driver that the parameter value should be sent to
 6321      * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
 6322      * driver may have to do extra work to determine whether the parameter
 6323      * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
 6324      * @param parameterIndex index of the first parameter is 1, the second is 2, ...
 6325      * @param reader An object that contains the data to set the parameter value to.
 6326      * @param length the number of characters in the parameter data.
 6327      * @throws SQLException if a database access error occurs, this method is called on
 6328      * a closed <code>PreparedStatement</code>, if parameterIndex does not correspond to a parameter
 6329      * marker in the SQL statement, or if the length specified is less than zero.
 6330      *
 6331      * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
 6332      * @since 1.6
 6333      */
 6334      public void setClob(int parameterIndex, Reader reader, long length)
 6335        throws SQLException{
 6336           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6337      }
 6338   
 6339   
 6340    /**
 6341       * Sets the designated parameter to a <code>InputStream</code> object.  The inputstream must contain  the number
 6342       * of characters specified by length otherwise a <code>SQLException</code> will be
 6343       * generated when the <code>PreparedStatement</code> is executed.
 6344       * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
 6345       * method because it informs the driver that the parameter value should be
 6346       * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
 6347       * the driver may have to do extra work to determine whether the parameter
 6348       * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
 6349       * @param parameterIndex index of the first parameter is 1,
 6350       * the second is 2, ...
 6351       * @param inputStream An object that contains the data to set the parameter
 6352       * value to.
 6353       * @param length the number of bytes in the parameter data.
 6354       * @throws SQLException if a database access error occurs,
 6355       * this method is called on a closed <code>PreparedStatement</code>,
 6356       * if parameterIndex does not correspond
 6357       * to a parameter marker in the SQL statement,  if the length specified
 6358       * is less than zero or if the number of bytes in the inputstream does not match
 6359       * the specfied length.
 6360       * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
 6361       *
 6362       * @since 1.6
 6363       */
 6364       public void setBlob(int parameterIndex, InputStream inputStream, long length)
 6365          throws SQLException{
 6366           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6367      }
 6368   
 6369    /**
 6370       * Sets the designated parameter to a <code>InputStream</code> object.
 6371       * This method differs from the <code>setBinaryStream (int, InputStream)</code>
 6372       * This method differs from the <code>setBinaryStream (int, InputStream)</code>
 6373       * method because it informs the driver that the parameter value should be
 6374       * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
 6375       * the driver may have to do extra work to determine whether the parameter
 6376       * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
 6377       *
 6378       * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 6379       * it might be more efficient to use a version of
 6380       * <code>setBlob</code> which takes a length parameter.
 6381       *
 6382       * @param parameterIndex index of the first parameter is 1,
 6383       * the second is 2, ...
 6384   
 6385   
 6386       * @param inputStream An object that contains the data to set the parameter
 6387       * value to.
 6388       * @throws SQLException if a database access error occurs,
 6389       * this method is called on a closed <code>PreparedStatement</code> or
 6390       * if parameterIndex does not correspond
 6391       * to a parameter marker in the SQL statement,
 6392       * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
 6393       *
 6394       * @since 1.6
 6395       */
 6396       public void setBlob(int parameterIndex, InputStream inputStream)
 6397          throws SQLException{
 6398           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6399      }
 6400   
 6401    /**
 6402       * Sets the designated parameter to a <code>InputStream</code> object.  The <code>inputstream</code> must contain  the number
 6403         * of characters specified by length, otherwise a <code>SQLException</code> will be
 6404         * generated when the <code>CallableStatement</code> is executed.
 6405         * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
 6406         * method because it informs the driver that the parameter value should be
 6407         * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
 6408         * the driver may have to do extra work to determine whether the parameter
 6409         * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
 6410         *
 6411         * @param parameterName the name of the parameter to be set
 6412         * the second is 2, ...
 6413         *
 6414         * @param inputStream An object that contains the data to set the parameter
 6415         * value to.
 6416         * @param length the number of bytes in the parameter data.
 6417         * @throws SQLException  if parameterIndex does not correspond
 6418         * to a parameter marker in the SQL statement,  or if the length specified
 6419         * is less than zero; if the number of bytes in the inputstream does not match
 6420         * the specfied length; if a database access error occurs or
 6421         * this method is called on a closed <code>CallableStatement</code>
 6422         * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6423         * this method
 6424         *
 6425         * @since 1.6
 6426         */
 6427         public void setBlob(String parameterName, InputStream inputStream, long length)
 6428            throws SQLException{
 6429            throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6430       }
 6431   
 6432   
 6433    /**
 6434       * Sets the designated parameter to the given <code>java.sql.Blob</code> object.
 6435       * The driver converts this to an SQL <code>BLOB</code> value when it
 6436       * sends it to the database.
 6437       *
 6438       * @param parameterName the name of the parameter
 6439       * @param x a <code>Blob</code> object that maps an SQL <code>BLOB</code> value
 6440       * @exception SQLException if a database access error occurs or
 6441       * this method is called on a closed <code>CallableStatement</code>
 6442       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6443       * this method
 6444       * @since 1.6
 6445       */
 6446      public void setBlob (String parameterName, Blob x) throws SQLException{
 6447           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6448      }
 6449   
 6450    /**
 6451       * Sets the designated parameter to a <code>InputStream</code> object.
 6452       * This method differs from the <code>setBinaryStream (int, InputStream)</code>
 6453       * method because it informs the driver that the parameter value should be
 6454       * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
 6455       * the driver may have to do extra work to determine whether the parameter
 6456       * data should be send to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
 6457       *
 6458       * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 6459       * it might be more efficient to use a version of
 6460       * <code>setBlob</code> which takes a length parameter.
 6461       *
 6462       * @param parameterName the name of the parameter
 6463       * @param inputStream An object that contains the data to set the parameter
 6464       * value to.
 6465       * @throws SQLException if a database access error occurs or
 6466       * this method is called on a closed <code>CallableStatement</code>
 6467       * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
 6468       *
 6469       * @since 1.6
 6470       */
 6471       public void setBlob(String parameterName, InputStream inputStream)
 6472          throws SQLException{
 6473           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6474      }
 6475   
 6476     /**
 6477     * Sets the value of the designated parameter with the given object. The second
 6478     * argument must be an object type; for integral values, the
 6479     * <code>java.lang</code> equivalent objects should be used.
 6480     *
 6481     * <p>The given Java object will be converted to the given targetSqlType
 6482     * before being sent to the database.
 6483     *
 6484     * If the object has a custom mapping (is of a class implementing the
 6485     * interface <code>SQLData</code>),
 6486     * the JDBC driver should call the method <code>SQLData.writeSQL</code> to write it
 6487     * to the SQL data stream.
 6488     * If, on the other hand, the object is of a class implementing
 6489     * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,  <code>NClob</code>,
 6490     *  <code>Struct</code>, <code>java.net.URL</code>,
 6491     * or <code>Array</code>, the driver should pass it to the database as a
 6492     * value of the corresponding SQL type.
 6493     * <P>
 6494     * Note that this method may be used to pass datatabase-
 6495     * specific abstract data types.
 6496     *
 6497     * @param parameterName the name of the parameter
 6498     * @param x the object containing the input parameter value
 6499     * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
 6500     * sent to the database. The scale argument may further qualify this type.
 6501     * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,
 6502     *          this is the number of digits after the decimal point.  For all other
 6503     *          types, this value will be ignored.
 6504     * @exception SQLException if a database access error occurs or
 6505     * this method is called on a closed <code>CallableStatement</code>
 6506     * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is
 6507     * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
 6508     * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
 6509     * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
 6510     *  <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
 6511     * or  <code>STRUCT</code> data type and the JDBC driver does not support
 6512     * this data type
 6513     * @see Types
 6514     * @see #getObject
 6515     * @since 1.4
 6516     */
 6517     public void setObject(String parameterName, Object x, int targetSqlType, int scale)
 6518        throws SQLException{
 6519         throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6520    }
 6521   
 6522     /**
 6523       * Sets the value of the designated parameter with the given object.
 6524       * This method is like the method <code>setObject</code>
 6525       * above, except that it assumes a scale of zero.
 6526       *
 6527       * @param parameterName the name of the parameter
 6528       * @param x the object containing the input parameter value
 6529       * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
 6530       *                      sent to the database
 6531       * @exception SQLException if a database access error occurs or
 6532       * this method is called on a closed <code>CallableStatement</code>
 6533       * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is
 6534       * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
 6535       * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
 6536       * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
 6537       *  <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
 6538       * or  <code>STRUCT</code> data type and the JDBC driver does not support
 6539       * this data type
 6540       * @see #getObject
 6541       * @since 1.4
 6542       */
 6543       public void setObject(String parameterName, Object x, int targetSqlType)
 6544          throws SQLException{
 6545           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6546      }
 6547   
 6548    /**
 6549      * Sets the value of the designated parameter with the given object.
 6550      * The second parameter must be of type <code>Object</code>; therefore, the
 6551      * <code>java.lang</code> equivalent objects should be used for built-in types.
 6552      *
 6553      * <p>The JDBC specification specifies a standard mapping from
 6554      * Java <code>Object</code> types to SQL types.  The given argument
 6555      * will be converted to the corresponding SQL type before being
 6556      * sent to the database.
 6557      *
 6558      * <p>Note that this method may be used to pass datatabase-
 6559      * specific abstract data types, by using a driver-specific Java
 6560      * type.
 6561      *
 6562      * If the object is of a class implementing the interface <code>SQLData</code>,
 6563      * the JDBC driver should call the method <code>SQLData.writeSQL</code>
 6564      * to write it to the SQL data stream.
 6565      * If, on the other hand, the object is of a class implementing
 6566      * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,  <code>NClob</code>,
 6567      *  <code>Struct</code>, <code>java.net.URL</code>,
 6568      * or <code>Array</code>, the driver should pass it to the database as a
 6569      * value of the corresponding SQL type.
 6570      * <P>
 6571      * This method throws an exception if there is an ambiguity, for example, if the
 6572      * object is of a class implementing more than one of the interfaces named above.
 6573      *
 6574      * @param parameterName the name of the parameter
 6575      * @param x the object containing the input parameter value
 6576      * @exception SQLException if a database access error occurs,
 6577      * this method is called on a closed <code>CallableStatement</code> or if the given
 6578      *            <code>Object</code> parameter is ambiguous
 6579      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6580      * this method
 6581      * @see #getObject
 6582      * @since 1.4
 6583      */
 6584      public void setObject(String parameterName, Object x) throws SQLException{
 6585           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6586      }
 6587   
 6588     /**
 6589     * Sets the designated parameter to the given input stream, which will have
 6590     * the specified number of bytes.
 6591     * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
 6592     * parameter, it may be more practical to send it via a
 6593     * <code>java.io.InputStream</code>. Data will be read from the stream
 6594     * as needed until end-of-file is reached.  The JDBC driver will
 6595     * do any necessary conversion from ASCII to the database char format.
 6596     *
 6597     * <P><B>Note:</B> This stream object can either be a standard
 6598     * Java stream object or your own subclass that implements the
 6599     * standard interface.
 6600     *
 6601     * @param parameterName the name of the parameter
 6602     * @param x the Java input stream that contains the ASCII parameter value
 6603     * @param length the number of bytes in the stream
 6604     * @exception SQLException if a database access error occurs or
 6605     * this method is called on a closed <code>CallableStatement</code>
 6606     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6607     * this method
 6608     * @since 1.4
 6609     */
 6610    public void setAsciiStream(String parameterName, java.io.InputStream x, int length)
 6611        throws SQLException{
 6612         throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6613    }
 6614   
 6615   
 6616   /**
 6617     * Sets the designated parameter to the given input stream, which will have
 6618     * the specified number of bytes.
 6619     * When a very large binary value is input to a <code>LONGVARBINARY</code>
 6620     * parameter, it may be more practical to send it via a
 6621     * <code>java.io.InputStream</code> object. The data will be read from the stream
 6622     * as needed until end-of-file is reached.
 6623     *
 6624     * <P><B>Note:</B> This stream object can either be a standard
 6625     * Java stream object or your own subclass that implements the
 6626     * standard interface.
 6627     *
 6628     * @param parameterName the name of the parameter
 6629     * @param x the java input stream which contains the binary parameter value
 6630     * @param length the number of bytes in the stream
 6631     * @exception SQLException if a database access error occurs or
 6632     * this method is called on a closed <code>CallableStatement</code>
 6633     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6634     * this method
 6635     * @since 1.4
 6636     */
 6637    public void setBinaryStream(String parameterName, java.io.InputStream x,
 6638                         int length) throws SQLException{
 6639         throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6640    }
 6641   
 6642    /**
 6643      * Sets the designated parameter to the given <code>Reader</code>
 6644      * object, which is the given number of characters long.
 6645      * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
 6646      * parameter, it may be more practical to send it via a
 6647      * <code>java.io.Reader</code> object. The data will be read from the stream
 6648      * as needed until end-of-file is reached.  The JDBC driver will
 6649      * do any necessary conversion from UNICODE to the database char format.
 6650      *
 6651      * <P><B>Note:</B> This stream object can either be a standard
 6652      * Java stream object or your own subclass that implements the
 6653      * standard interface.
 6654      *
 6655      * @param parameterName the name of the parameter
 6656      * @param reader the <code>java.io.Reader</code> object that
 6657      *        contains the UNICODE data used as the designated parameter
 6658      * @param length the number of characters in the stream
 6659      * @exception SQLException if a database access error occurs or
 6660      * this method is called on a closed <code>CallableStatement</code>
 6661      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6662      * this method
 6663      * @since 1.4
 6664      */
 6665     public void setCharacterStream(String parameterName,
 6666                             java.io.Reader reader,
 6667                             int length) throws SQLException{
 6668          throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6669     }
 6670   
 6671     /**
 6672      * Sets the designated parameter to the given input stream.
 6673      * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
 6674      * parameter, it may be more practical to send it via a
 6675      * <code>java.io.InputStream</code>. Data will be read from the stream
 6676      * as needed until end-of-file is reached.  The JDBC driver will
 6677      * do any necessary conversion from ASCII to the database char format.
 6678      *
 6679      * <P><B>Note:</B> This stream object can either be a standard
 6680      * Java stream object or your own subclass that implements the
 6681      * standard interface.
 6682      * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 6683      * it might be more efficient to use a version of
 6684      * <code>setAsciiStream</code> which takes a length parameter.
 6685      *
 6686      * @param parameterName the name of the parameter
 6687      * @param x the Java input stream that contains the ASCII parameter value
 6688      * @exception SQLException if a database access error occurs or
 6689      * this method is called on a closed <code>CallableStatement</code>
 6690      * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
 6691        * @since 1.6
 6692     */
 6693     public void setAsciiStream(String parameterName, java.io.InputStream x)
 6694             throws SQLException{
 6695           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6696      }
 6697   
 6698   
 6699    /**
 6700       * Sets the designated parameter to the given input stream.
 6701       * When a very large binary value is input to a <code>LONGVARBINARY</code>
 6702       * parameter, it may be more practical to send it via a
 6703       * <code>java.io.InputStream</code> object. The data will be read from the
 6704       * stream as needed until end-of-file is reached.
 6705       *
 6706       * <P><B>Note:</B> This stream object can either be a standard
 6707       * Java stream object or your own subclass that implements the
 6708       * standard interface.
 6709       * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 6710       * it might be more efficient to use a version of
 6711       * <code>setBinaryStream</code> which takes a length parameter.
 6712       *
 6713       * @param parameterName the name of the parameter
 6714       * @param x the java input stream which contains the binary parameter value
 6715       * @exception SQLException if a database access error occurs or
 6716       * this method is called on a closed <code>CallableStatement</code>
 6717       * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
 6718       * @since 1.6
 6719       */
 6720      public void setBinaryStream(String parameterName, java.io.InputStream x)
 6721      throws SQLException{
 6722           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6723      }
 6724   
 6725    /**
 6726       * Sets the designated parameter to the given <code>Reader</code>
 6727       * object.
 6728       * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
 6729       * parameter, it may be more practical to send it via a
 6730       * <code>java.io.Reader</code> object. The data will be read from the stream
 6731       * as needed until end-of-file is reached.  The JDBC driver will
 6732       * do any necessary conversion from UNICODE to the database char format.
 6733       *
 6734       * <P><B>Note:</B> This stream object can either be a standard
 6735       * Java stream object or your own subclass that implements the
 6736       * standard interface.
 6737       * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
 6738       * it might be more efficient to use a version of
 6739       * <code>setCharacterStream</code> which takes a length parameter.
 6740       *
 6741       * @param parameterName the name of the parameter
 6742       * @param reader the <code>java.io.Reader</code> object that contains the
 6743       *        Unicode data
 6744       * @exception SQLException if a database access error occurs or
 6745       * this method is called on a closed <code>CallableStatement</code>
 6746       * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
 6747       * @since 1.6
 6748       */
 6749      public void setCharacterStream(String parameterName,
 6750                            java.io.Reader reader) throws SQLException{
 6751           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6752      }
 6753   
 6754      /**
 6755       * Sets the designated parameter to the given
 6756       * <code>java.math.BigDecimal</code> value.
 6757       * The driver converts this to an SQL <code>NUMERIC</code> value when
 6758       * it sends it to the database.
 6759       *
 6760       * @param parameterName the name of the parameter
 6761       * @param x the parameter value
 6762       * @exception SQLException if a database access error occurs or
 6763       * this method is called on a closed <code>CallableStatement</code>
 6764       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6765       * this method
 6766       * @see #getBigDecimal
 6767       * @since 1.4
 6768       */
 6769      public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException{
 6770           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6771      }
 6772   
 6773    /**
 6774       * Sets the designated parameter to the given Java <code>String</code> value.
 6775       * The driver converts this
 6776       * to an SQL <code>VARCHAR</code> or <code>LONGVARCHAR</code> value
 6777       * (depending on the argument's
 6778       * size relative to the driver's limits on <code>VARCHAR</code> values)
 6779       * when it sends it to the database.
 6780       *
 6781       * @param parameterName the name of the parameter
 6782       * @param x the parameter value
 6783       * @exception SQLException if a database access error occurs or
 6784       * this method is called on a closed <code>CallableStatement</code>
 6785       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6786       * this method
 6787       * @see #getString
 6788       * @since 1.4
 6789       */
 6790      public void setString(String parameterName, String x) throws SQLException{
 6791           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6792      }
 6793   
 6794   
 6795   
 6796    /**
 6797       * Sets the designated parameter to the given Java array of bytes.
 6798       * The driver converts this to an SQL <code>VARBINARY</code> or
 6799       * <code>LONGVARBINARY</code> (depending on the argument's size relative
 6800       * to the driver's limits on <code>VARBINARY</code> values) when it sends
 6801       * it to the database.
 6802       *
 6803       * @param parameterName the name of the parameter
 6804       * @param x the parameter value
 6805       * @exception SQLException if a database access error occurs or
 6806       * this method is called on a closed <code>CallableStatement</code>
 6807       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6808       * this method
 6809       * @see #getBytes
 6810       * @since 1.4
 6811       */
 6812      public void setBytes(String parameterName, byte x[]) throws SQLException{
 6813           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6814      }
 6815   
 6816    /**
 6817       * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value.
 6818       * The driver
 6819       * converts this to an SQL <code>TIMESTAMP</code> value when it sends it to the
 6820       * database.
 6821       *
 6822       * @param parameterName the name of the parameter
 6823       * @param x the parameter value
 6824       * @exception SQLException if a database access error occurs or
 6825       * this method is called on a closed <code>CallableStatement</code>
 6826       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6827       * this method
 6828       * @see #getTimestamp
 6829       * @since 1.4
 6830       */
 6831      public void setTimestamp(String parameterName, java.sql.Timestamp x)
 6832          throws SQLException{
 6833           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6834      }
 6835   
 6836       /**
 6837       * Sets the designated parameter to SQL <code>NULL</code>.
 6838       *
 6839       * <P><B>Note:</B> You must specify the parameter's SQL type.
 6840       *
 6841       * @param parameterName the name of the parameter
 6842       * @param sqlType the SQL type code defined in <code>java.sql.Types</code>
 6843       * @exception SQLException if a database access error occurs or
 6844       * this method is called on a closed <code>CallableStatement</code>
 6845       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6846       * this method
 6847       * @since 1.4
 6848       */
 6849      public void setNull(String parameterName, int sqlType) throws SQLException {
 6850           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6851      }
 6852   
 6853    /**
 6854       * Sets the designated parameter to SQL <code>NULL</code>.
 6855       * This version of the method <code>setNull</code> should
 6856       * be used for user-defined types and REF type parameters.  Examples
 6857       * of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and
 6858       * named array types.
 6859       *
 6860       * <P><B>Note:</B> To be portable, applications must give the
 6861       * SQL type code and the fully-qualified SQL type name when specifying
 6862       * a NULL user-defined or REF parameter.  In the case of a user-defined type
 6863       * the name is the type name of the parameter itself.  For a REF
 6864       * parameter, the name is the type name of the referenced type.  If
 6865       * a JDBC driver does not need the type code or type name information,
 6866       * it may ignore it.
 6867       *
 6868       * Although it is intended for user-defined and Ref parameters,
 6869       * this method may be used to set a null parameter of any JDBC type.
 6870       * If the parameter does not have a user-defined or REF type, the given
 6871       * typeName is ignored.
 6872       *
 6873       *
 6874       * @param parameterName the name of the parameter
 6875       * @param sqlType a value from <code>java.sql.Types</code>
 6876       * @param typeName the fully-qualified name of an SQL user-defined type;
 6877       *        ignored if the parameter is not a user-defined type or
 6878       *        SQL <code>REF</code> value
 6879       * @exception SQLException if a database access error occurs or
 6880       * this method is called on a closed <code>CallableStatement</code>
 6881       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6882       * this method
 6883       * @since 1.4
 6884       */
 6885      public void setNull (String parameterName, int sqlType, String typeName)
 6886          throws SQLException{
 6887           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6888      }
 6889   
 6890    /**
 6891       * Sets the designated parameter to the given Java <code>boolean</code> value.
 6892       * The driver converts this
 6893       * to an SQL <code>BIT</code> or <code>BOOLEAN</code> value when it sends it to the database.
 6894       *
 6895       * @param parameterName the name of the parameter
 6896       * @param x the parameter value
 6897       * @exception SQLException if a database access error occurs or
 6898       * this method is called on a closed <code>CallableStatement</code>
 6899       * @see #getBoolean
 6900       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6901       * this method
 6902       * @since 1.4
 6903       */
 6904      public void setBoolean(String parameterName, boolean x) throws SQLException{
 6905           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6906      }
 6907   
 6908   
 6909   
 6910    /**
 6911       * Sets the designated parameter to the given Java <code>byte</code> value.
 6912       * The driver converts this
 6913       * to an SQL <code>TINYINT</code> value when it sends it to the database.
 6914       *
 6915       * @param parameterName the name of the parameter
 6916       * @param x the parameter value
 6917       * @exception SQLException if a database access error occurs or
 6918       * this method is called on a closed <code>CallableStatement</code>
 6919       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6920       * this method
 6921       * @see #getByte
 6922       * @since 1.4
 6923       */
 6924      public void setByte(String parameterName, byte x) throws SQLException{
 6925           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6926      }
 6927   
 6928   
 6929    /**
 6930       * Sets the designated parameter to the given Java <code>short</code> value.
 6931       * The driver converts this
 6932       * to an SQL <code>SMALLINT</code> value when it sends it to the database.
 6933       *
 6934       * @param parameterName the name of the parameter
 6935       * @param x the parameter value
 6936       * @exception SQLException if a database access error occurs or
 6937       * this method is called on a closed <code>CallableStatement</code>
 6938       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6939       * this method
 6940       * @see #getShort
 6941       * @since 1.4
 6942       */
 6943      public void setShort(String parameterName, short x) throws SQLException{
 6944           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6945      }
 6946   
 6947   
 6948      /**
 6949       * Sets the designated parameter to the given Java <code>int</code> value.
 6950       * The driver converts this
 6951       * to an SQL <code>INTEGER</code> value when it sends it to the database.
 6952       *
 6953       * @param parameterName the name of the parameter
 6954       * @param x the parameter value
 6955       * @exception SQLException if a database access error occurs or
 6956       * this method is called on a closed <code>CallableStatement</code>
 6957       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6958       * this method
 6959       * @see #getInt
 6960       * @since 1.4
 6961       */
 6962      public void setInt(String parameterName, int x) throws SQLException{
 6963           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6964      }
 6965   
 6966    /**
 6967       * Sets the designated parameter to the given Java <code>long</code> value.
 6968       * The driver converts this
 6969       * to an SQL <code>BIGINT</code> value when it sends it to the database.
 6970       *
 6971       * @param parameterName the name of the parameter
 6972       * @param x the parameter value
 6973       * @exception SQLException if a database access error occurs or
 6974       * this method is called on a closed <code>CallableStatement</code>
 6975       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6976       * this method
 6977       * @see #getLong
 6978       * @since 1.4
 6979       */
 6980      public void setLong(String parameterName, long x) throws SQLException{
 6981           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 6982      }
 6983   
 6984   
 6985    /**
 6986       * Sets the designated parameter to the given Java <code>float</code> value.
 6987       * The driver converts this
 6988       * to an SQL <code>FLOAT</code> value when it sends it to the database.
 6989       *
 6990       * @param parameterName the name of the parameter
 6991       * @param x the parameter value
 6992       * @exception SQLException if a database access error occurs or
 6993       * this method is called on a closed <code>CallableStatement</code>
 6994       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 6995       * this method
 6996       * @see #getFloat
 6997       * @since 1.4
 6998       */
 6999      public void setFloat(String parameterName, float x) throws SQLException{
 7000           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 7001      }
 7002   
 7003    /**
 7004       * Sets the designated parameter to the given Java <code>double</code> value.
 7005       * The driver converts this
 7006       * to an SQL <code>DOUBLE</code> value when it sends it to the database.
 7007       *
 7008       * @param parameterName the name of the parameter
 7009       * @param x the parameter value
 7010       * @exception SQLException if a database access error occurs or
 7011       * this method is called on a closed <code>CallableStatement</code>
 7012       * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
 7013       * this method
 7014       * @see #getDouble
 7015       * @since 1.4
 7016       */
 7017      public void setDouble(String parameterName, double x) throws SQLException{
 7018           throw new SQLFeatureNotSupportedException(resBundle.handleGetObject("jdbcrowsetimpl.featnotsupp").toString());
 7019      }
 7020   
 7021       /**
 7022        * This method re populates the resBundle
 7023        * during the deserialization process
 7024        *
 7025        */
 7026       private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
 7027           // Default state initialization happens here
 7028           ois.defaultReadObject();
 7029           // Initialization of transient Res Bundle happens here .
 7030           try {
 7031              resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
 7032           } catch(IOException ioe) {}
 7033   
 7034       }
 7035   
 7036      static final long serialVersionUID = -3591946023893483003L;
 7037   
 7038    //------------------------- JDBC 4.1 -----------------------------------
 7039   
 7040       public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
 7041           throw new SQLFeatureNotSupportedException("Not supported yet.");
 7042       }
 7043   
 7044       public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
 7045           throw new SQLFeatureNotSupportedException("Not supported yet.");
 7046       }
 7047   }

Save This Page
Home » openjdk-7 » com.sun » rowset » [javadoc | source]