jdk/src/java.sql.rowset/share/classes/javax/sql/rowset/BaseRowSet.java
changeset 25991 e48157b42439
parent 25976 4de01a56e3ee
parent 25859 3317bb8137f4
child 27776 b2ddbbc58706
equal deleted inserted replaced
25876:d06a6d3c66c0 25991:e48157b42439
   366     /**
   366     /**
   367      * The JDBC URL the reader, writer, or both supply to the method
   367      * The JDBC URL the reader, writer, or both supply to the method
   368      * <code>DriverManager.getConnection</code> when the
   368      * <code>DriverManager.getConnection</code> when the
   369      * <code>DriverManager</code> is used to get a connection.
   369      * <code>DriverManager</code> is used to get a connection.
   370      * <P>
   370      * <P>
   371      * The JDBC URL identifies the driver to be used to make the conndection.
   371      * The JDBC URL identifies the driver to be used to make the connection.
   372      * This URL can be found in the documentation supplied by the driver
   372      * This URL can be found in the documentation supplied by the driver
   373      * vendor.
   373      * vendor.
   374      * @serial
   374      * @serial
   375      */
   375      */
   376     private String URL;
   376     private String URL;
   560     * <p>
   560     * <p>
   561     * <b>Note</b>: if the <code>RowSetListener</code> object is
   561     * <b>Note</b>: if the <code>RowSetListener</code> object is
   562     * <code>null</code>, this method silently discards the <code>null</code>
   562     * <code>null</code>, this method silently discards the <code>null</code>
   563     * value and does not add a null reference to the set of listeners.
   563     * value and does not add a null reference to the set of listeners.
   564     * <p>
   564     * <p>
   565     * <b>Note</b>: if the listener is already set, and the new <code>RowSetListerner</code>
   565     * <b>Note</b>: if the listener is already set, and the new <code>RowSetListener</code>
   566     * instance is added to the set of listeners already registered to receive
   566     * instance is added to the set of listeners already registered to receive
   567     * event notifications from this <code>RowSet</code>.
   567     * event notifications from this <code>RowSet</code>.
   568     *
   568     *
   569     * @param listener an object that has implemented the
   569     * @param listener an object that has implemented the
   570     *     <code>javax.sql.RowSetListener</code> interface and wants to be notified
   570     *     <code>javax.sql.RowSetListener</code> interface and wants to be notified
   765      * property to <code>null</code>. The Url property is a
   765      * property to <code>null</code>. The Url property is a
   766      * JDBC URL that is used when
   766      * JDBC URL that is used when
   767      * the connection is created using a JDBC technology-enabled driver
   767      * the connection is created using a JDBC technology-enabled driver
   768      * ("JDBC driver") and the <code>DriverManager</code>.
   768      * ("JDBC driver") and the <code>DriverManager</code>.
   769      * The correct JDBC URL for the specific driver to be used can be found
   769      * The correct JDBC URL for the specific driver to be used can be found
   770      * in the driver documentation.  Although there are guidelines for for how
   770      * in the driver documentation.  Although there are guidelines for how
   771      * a JDBC URL is formed,
   771      * a JDBC URL is formed,
   772      * a driver vendor can specify any <code>String</code> object except
   772      * a driver vendor can specify any <code>String</code> object except
   773      * one with a length of <code>0</code> (an empty string).
   773      * one with a length of <code>0</code> (an empty string).
   774      * <P>
   774      * <P>
   775      * Setting the Url property is optional if connections are established using
   775      * Setting the Url property is optional if connections are established using
  1091                 throw new SQLException("Invalid transaction isolation set. Must " +
  1091                 throw new SQLException("Invalid transaction isolation set. Must " +
  1092                 "be either " +
  1092                 "be either " +
  1093                 "Connection.TRANSACTION_NONE or " +
  1093                 "Connection.TRANSACTION_NONE or " +
  1094                 "Connection.TRANSACTION_READ_UNCOMMITTED or " +
  1094                 "Connection.TRANSACTION_READ_UNCOMMITTED or " +
  1095                 "Connection.TRANSACTION_READ_COMMITTED or " +
  1095                 "Connection.TRANSACTION_READ_COMMITTED or " +
  1096                 "Connection.RRANSACTION_REPEATABLE_READ or " +
  1096                 "Connection.TRANSACTION_REPEATABLE_READ or " +
  1097                 "Connection.TRANSACTION_SERIALIZABLE");
  1097                 "Connection.TRANSACTION_SERIALIZABLE");
  1098             }
  1098             }
  1099         this.isolation = level;
  1099         this.isolation = level;
  1100     }
  1100     }
  1101 
  1101 
  3191         } //end if
  3191         } //end if
  3192 
  3192 
  3193     } //end getParams
  3193     } //end getParams
  3194 
  3194 
  3195 
  3195 
  3196  /**
  3196    /**
  3197     * Sets the designated parameter to SQL <code>NULL</code>.
  3197     * Sets the designated parameter to SQL <code>NULL</code>.
  3198     *
  3198     *
  3199     * <P><B>Note:</B> You must specify the parameter's SQL type.
  3199     * <P><B>Note:</B> You must specify the parameter's SQL type.
  3200     *
  3200     *
  3201     * @param parameterName the name of the parameter
  3201     * @param parameterName the name of the parameter
  3208     */
  3208     */
  3209    public void setNull(String parameterName, int sqlType) throws SQLException {
  3209    public void setNull(String parameterName, int sqlType) throws SQLException {
  3210         throw new SQLFeatureNotSupportedException("Feature not supported");
  3210         throw new SQLFeatureNotSupportedException("Feature not supported");
  3211    }
  3211    }
  3212 
  3212 
  3213 
  3213    /**
  3214  /**
       
  3215     * Sets the designated parameter to SQL <code>NULL</code>.
  3214     * Sets the designated parameter to SQL <code>NULL</code>.
  3216     * This version of the method <code>setNull</code> should
  3215     * This version of the method <code>setNull</code> should
  3217     * be used for user-defined types and REF type parameters.  Examples
  3216     * be used for user-defined types and REF type parameters.  Examples
  3218     * of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and
  3217     * of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and
  3219     * named array types.
  3218     * named array types.
  3246    public void setNull (String parameterName, int sqlType, String typeName)
  3245    public void setNull (String parameterName, int sqlType, String typeName)
  3247        throws SQLException{
  3246        throws SQLException{
  3248         throw new SQLFeatureNotSupportedException("Feature not supported");
  3247         throw new SQLFeatureNotSupportedException("Feature not supported");
  3249    }
  3248    }
  3250 
  3249 
  3251 
  3250    /**
  3252 
       
  3253  /**
       
  3254     * Sets the designated parameter to the given Java <code>boolean</code> value.
  3251     * Sets the designated parameter to the given Java <code>boolean</code> value.
  3255     * The driver converts this
  3252     * The driver converts this
  3256     * to an SQL <code>BIT</code> or <code>BOOLEAN</code> value when it sends it to the database.
  3253     * to an SQL <code>BIT</code> or <code>BOOLEAN</code> value when it sends it to the database.
  3257     *
  3254     *
  3258     * @param parameterName the name of the parameter
  3255     * @param parameterName the name of the parameter
  3266     */
  3263     */
  3267    public void setBoolean(String parameterName, boolean x) throws SQLException{
  3264    public void setBoolean(String parameterName, boolean x) throws SQLException{
  3268         throw new SQLFeatureNotSupportedException("Feature not supported");
  3265         throw new SQLFeatureNotSupportedException("Feature not supported");
  3269    }
  3266    }
  3270 
  3267 
  3271 
  3268    /**
  3272 
       
  3273  /**
       
  3274     * Sets the designated parameter to the given Java <code>byte</code> value.
  3269     * Sets the designated parameter to the given Java <code>byte</code> value.
  3275     * The driver converts this
  3270     * The driver converts this
  3276     * to an SQL <code>TINYINT</code> value when it sends it to the database.
  3271     * to an SQL <code>TINYINT</code> value when it sends it to the database.
  3277     *
  3272     *
  3278     * @param parameterName the name of the parameter
  3273     * @param parameterName the name of the parameter
  3286     */
  3281     */
  3287    public void setByte(String parameterName, byte x) throws SQLException{
  3282    public void setByte(String parameterName, byte x) throws SQLException{
  3288         throw new SQLFeatureNotSupportedException("Feature not supported");
  3283         throw new SQLFeatureNotSupportedException("Feature not supported");
  3289    }
  3284    }
  3290 
  3285 
  3291 
  3286    /**
  3292 
       
  3293  /**
       
  3294     * Sets the designated parameter to the given Java <code>short</code> value.
  3287     * Sets the designated parameter to the given Java <code>short</code> value.
  3295     * The driver converts this
  3288     * The driver converts this
  3296     * to an SQL <code>SMALLINT</code> value when it sends it to the database.
  3289     * to an SQL <code>SMALLINT</code> value when it sends it to the database.
  3297     *
  3290     *
  3298     * @param parameterName the name of the parameter
  3291     * @param parameterName the name of the parameter
  3306     */
  3299     */
  3307    public void setShort(String parameterName, short x) throws SQLException{
  3300    public void setShort(String parameterName, short x) throws SQLException{
  3308         throw new SQLFeatureNotSupportedException("Feature not supported");
  3301         throw new SQLFeatureNotSupportedException("Feature not supported");
  3309    }
  3302    }
  3310 
  3303 
  3311 
  3304    /**
  3312  /**
       
  3313     * Sets the designated parameter to the given Java <code>int</code> value.
  3305     * Sets the designated parameter to the given Java <code>int</code> value.
  3314     * The driver converts this
  3306     * The driver converts this
  3315     * to an SQL <code>INTEGER</code> value when it sends it to the database.
  3307     * to an SQL <code>INTEGER</code> value when it sends it to the database.
  3316     *
  3308     *
  3317     * @param parameterName the name of the parameter
  3309     * @param parameterName the name of the parameter
  3326    public void setInt(String parameterName, int x) throws SQLException{
  3318    public void setInt(String parameterName, int x) throws SQLException{
  3327         throw new SQLFeatureNotSupportedException("Feature not supported");
  3319         throw new SQLFeatureNotSupportedException("Feature not supported");
  3328    }
  3320    }
  3329 
  3321 
  3330 
  3322 
  3331  /**
  3323    /**
  3332     * Sets the designated parameter to the given Java <code>long</code> value.
  3324     * Sets the designated parameter to the given Java <code>long</code> value.
  3333     * The driver converts this
  3325     * The driver converts this
  3334     * to an SQL <code>BIGINT</code> value when it sends it to the database.
  3326     * to an SQL <code>BIGINT</code> value when it sends it to the database.
  3335     *
  3327     *
  3336     * @param parameterName the name of the parameter
  3328     * @param parameterName the name of the parameter
  3344     */
  3336     */
  3345    public void setLong(String parameterName, long x) throws SQLException{
  3337    public void setLong(String parameterName, long x) throws SQLException{
  3346         throw new SQLFeatureNotSupportedException("Feature not supported");
  3338         throw new SQLFeatureNotSupportedException("Feature not supported");
  3347    }
  3339    }
  3348 
  3340 
  3349 
  3341    /**
  3350  /**
       
  3351     * Sets the designated parameter to the given Java <code>float</code> value.
  3342     * Sets the designated parameter to the given Java <code>float</code> value.
  3352     * The driver converts this
  3343     * The driver converts this
  3353     * to an SQL <code>FLOAT</code> value when it sends it to the database.
  3344     * to an SQL <code>FLOAT</code> value when it sends it to the database.
  3354     *
  3345     *
  3355     * @param parameterName the name of the parameter
  3346     * @param parameterName the name of the parameter
  3363     */
  3354     */
  3364    public void setFloat(String parameterName, float x) throws SQLException{
  3355    public void setFloat(String parameterName, float x) throws SQLException{
  3365         throw new SQLFeatureNotSupportedException("Feature not supported");
  3356         throw new SQLFeatureNotSupportedException("Feature not supported");
  3366    }
  3357    }
  3367 
  3358 
  3368 
  3359    /**
  3369  /**
       
  3370     * Sets the designated parameter to the given Java <code>double</code> value.
  3360     * Sets the designated parameter to the given Java <code>double</code> value.
  3371     * The driver converts this
  3361     * The driver converts this
  3372     * to an SQL <code>DOUBLE</code> value when it sends it to the database.
  3362     * to an SQL <code>DOUBLE</code> value when it sends it to the database.
  3373     *
  3363     *
  3374     * @param parameterName the name of the parameter
  3364     * @param parameterName the name of the parameter
  3382     */
  3372     */
  3383    public void setDouble(String parameterName, double x) throws SQLException{
  3373    public void setDouble(String parameterName, double x) throws SQLException{
  3384         throw new SQLFeatureNotSupportedException("Feature not supported");
  3374         throw new SQLFeatureNotSupportedException("Feature not supported");
  3385    }
  3375    }
  3386 
  3376 
  3387 
  3377    /**
  3388 
       
  3389  /**
       
  3390     * Sets the designated parameter to the given
  3378     * Sets the designated parameter to the given
  3391     * <code>java.math.BigDecimal</code> value.
  3379     * <code>java.math.BigDecimal</code> value.
  3392     * The driver converts this to an SQL <code>NUMERIC</code> value when
  3380     * The driver converts this to an SQL <code>NUMERIC</code> value when
  3393     * it sends it to the database.
  3381     * it sends it to the database.
  3394     *
  3382     *
  3403     */
  3391     */
  3404    public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException{
  3392    public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException{
  3405         throw new SQLFeatureNotSupportedException("Feature not supported");
  3393         throw new SQLFeatureNotSupportedException("Feature not supported");
  3406    }
  3394    }
  3407 
  3395 
  3408 
  3396    /**
  3409 
       
  3410  /**
       
  3411     * Sets the designated parameter to the given Java <code>String</code> value.
  3397     * Sets the designated parameter to the given Java <code>String</code> value.
  3412     * The driver converts this
  3398     * The driver converts this
  3413     * to an SQL <code>VARCHAR</code> or <code>LONGVARCHAR</code> value
  3399     * to an SQL <code>VARCHAR</code> or <code>LONGVARCHAR</code> value
  3414     * (depending on the argument's
  3400     * (depending on the argument's
  3415     * size relative to the driver's limits on <code>VARCHAR</code> values)
  3401     * size relative to the driver's limits on <code>VARCHAR</code> values)
  3426     */
  3412     */
  3427    public void setString(String parameterName, String x) throws SQLException{
  3413    public void setString(String parameterName, String x) throws SQLException{
  3428         throw new SQLFeatureNotSupportedException("Feature not supported");
  3414         throw new SQLFeatureNotSupportedException("Feature not supported");
  3429    }
  3415    }
  3430 
  3416 
  3431 
  3417    /**
  3432 
       
  3433  /**
       
  3434     * Sets the designated parameter to the given Java array of bytes.
  3418     * Sets the designated parameter to the given Java array of bytes.
  3435     * The driver converts this to an SQL <code>VARBINARY</code> or
  3419     * The driver converts this to an SQL <code>VARBINARY</code> or
  3436     * <code>LONGVARBINARY</code> (depending on the argument's size relative
  3420     * <code>LONGVARBINARY</code> (depending on the argument's size relative
  3437     * to the driver's limits on <code>VARBINARY</code> values) when it sends
  3421     * to the driver's limits on <code>VARBINARY</code> values) when it sends
  3438     * it to the database.
  3422     * it to the database.
  3448     */
  3432     */
  3449    public void setBytes(String parameterName, byte x[]) throws SQLException{
  3433    public void setBytes(String parameterName, byte x[]) throws SQLException{
  3450         throw new SQLFeatureNotSupportedException("Feature not supported");
  3434         throw new SQLFeatureNotSupportedException("Feature not supported");
  3451    }
  3435    }
  3452 
  3436 
  3453 
  3437    /**
  3454 
       
  3455  /**
       
  3456     * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value.
  3438     * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value.
  3457     * The driver
  3439     * The driver
  3458     * converts this to an SQL <code>TIMESTAMP</code> value when it sends it to the
  3440     * converts this to an SQL <code>TIMESTAMP</code> value when it sends it to the
  3459     * database.
  3441     * database.
  3460     *
  3442     *
  3470    public void setTimestamp(String parameterName, java.sql.Timestamp x)
  3452    public void setTimestamp(String parameterName, java.sql.Timestamp x)
  3471        throws SQLException{
  3453        throws SQLException{
  3472         throw new SQLFeatureNotSupportedException("Feature not supported");
  3454         throw new SQLFeatureNotSupportedException("Feature not supported");
  3473    }
  3455    }
  3474 
  3456 
  3475 
  3457    /**
  3476 
       
  3477  /**
       
  3478     * Sets the designated parameter to the given input stream, which will have
  3458     * Sets the designated parameter to the given input stream, which will have
  3479     * the specified number of bytes.
  3459     * the specified number of bytes.
  3480     * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
  3460     * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
  3481     * parameter, it may be more practical to send it via a
  3461     * parameter, it may be more practical to send it via a
  3482     * <code>java.io.InputStream</code>. Data will be read from the stream
  3462     * <code>java.io.InputStream</code>. Data will be read from the stream
  3499    public void setAsciiStream(String parameterName, java.io.InputStream x, int length)
  3479    public void setAsciiStream(String parameterName, java.io.InputStream x, int length)
  3500        throws SQLException{
  3480        throws SQLException{
  3501         throw new SQLFeatureNotSupportedException("Feature not supported");
  3481         throw new SQLFeatureNotSupportedException("Feature not supported");
  3502    }
  3482    }
  3503 
  3483 
  3504 
  3484    /**
  3505  /**
       
  3506     * Sets the designated parameter to the given input stream, which will have
  3485     * Sets the designated parameter to the given input stream, which will have
  3507     * the specified number of bytes.
  3486     * the specified number of bytes.
  3508     * When a very large binary value is input to a <code>LONGVARBINARY</code>
  3487     * When a very large binary value is input to a <code>LONGVARBINARY</code>
  3509     * parameter, it may be more practical to send it via a
  3488     * parameter, it may be more practical to send it via a
  3510     * <code>java.io.InputStream</code> object. The data will be read from the stream
  3489     * <code>java.io.InputStream</code> object. The data will be read from the stream
  3526    public void setBinaryStream(String parameterName, java.io.InputStream x,
  3505    public void setBinaryStream(String parameterName, java.io.InputStream x,
  3527                         int length) throws SQLException{
  3506                         int length) throws SQLException{
  3528         throw new SQLFeatureNotSupportedException("Feature not supported");
  3507         throw new SQLFeatureNotSupportedException("Feature not supported");
  3529    }
  3508    }
  3530 
  3509 
  3531 
  3510    /**
  3532   /**
       
  3533     * Sets the designated parameter to the given <code>Reader</code>
  3511     * Sets the designated parameter to the given <code>Reader</code>
  3534     * object, which is the given number of characters long.
  3512     * object, which is the given number of characters long.
  3535     * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
  3513     * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
  3536     * parameter, it may be more practical to send it via a
  3514     * parameter, it may be more practical to send it via a
  3537     * <code>java.io.Reader</code> object. The data will be read from the stream
  3515     * <code>java.io.Reader</code> object. The data will be read from the stream
  3555    public void setCharacterStream(String parameterName,
  3533    public void setCharacterStream(String parameterName,
  3556                            java.io.Reader reader,
  3534                            java.io.Reader reader,
  3557                            int length) throws SQLException{
  3535                            int length) throws SQLException{
  3558         throw new SQLFeatureNotSupportedException("Feature not supported");
  3536         throw new SQLFeatureNotSupportedException("Feature not supported");
  3559    }
  3537    }
  3560 
       
  3561 
  3538 
  3562   /**
  3539   /**
  3563    * Sets the designated parameter to the given input stream.
  3540    * Sets the designated parameter to the given input stream.
  3564    * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
  3541    * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
  3565    * parameter, it may be more practical to send it via a
  3542    * parameter, it may be more practical to send it via a
  3584   public void setAsciiStream(String parameterName, java.io.InputStream x)
  3561   public void setAsciiStream(String parameterName, java.io.InputStream x)
  3585           throws SQLException{
  3562           throws SQLException{
  3586         throw new SQLFeatureNotSupportedException("Feature not supported");
  3563         throw new SQLFeatureNotSupportedException("Feature not supported");
  3587    }
  3564    }
  3588 
  3565 
  3589 
  3566    /**
  3590  /**
       
  3591     * Sets the designated parameter to the given input stream.
  3567     * Sets the designated parameter to the given input stream.
  3592     * When a very large binary value is input to a <code>LONGVARBINARY</code>
  3568     * When a very large binary value is input to a <code>LONGVARBINARY</code>
  3593     * parameter, it may be more practical to send it via a
  3569     * parameter, it may be more practical to send it via a
  3594     * <code>java.io.InputStream</code> object. The data will be read from the
  3570     * <code>java.io.InputStream</code> object. The data will be read from the
  3595     * stream as needed until end-of-file is reached.
  3571     * stream as needed until end-of-file is reached.
  3611    public void setBinaryStream(String parameterName, java.io.InputStream x)
  3587    public void setBinaryStream(String parameterName, java.io.InputStream x)
  3612    throws SQLException{
  3588    throws SQLException{
  3613         throw new SQLFeatureNotSupportedException("Feature not supported");
  3589         throw new SQLFeatureNotSupportedException("Feature not supported");
  3614    }
  3590    }
  3615 
  3591 
  3616 
  3592    /**
  3617 
       
  3618  /**
       
  3619     * Sets the designated parameter to the given <code>Reader</code>
  3593     * Sets the designated parameter to the given <code>Reader</code>
  3620     * object.
  3594     * object.
  3621     * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
  3595     * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
  3622     * parameter, it may be more practical to send it via a
  3596     * parameter, it may be more practical to send it via a
  3623     * <code>java.io.Reader</code> object. The data will be read from the stream
  3597     * <code>java.io.Reader</code> object. The data will be read from the stream
  3641     */
  3615     */
  3642    public void setCharacterStream(String parameterName,
  3616    public void setCharacterStream(String parameterName,
  3643                          java.io.Reader reader) throws SQLException{
  3617                          java.io.Reader reader) throws SQLException{
  3644         throw new SQLFeatureNotSupportedException("Feature not supported");
  3618         throw new SQLFeatureNotSupportedException("Feature not supported");
  3645    }
  3619    }
  3646 
       
  3647 
  3620 
  3648  /**
  3621  /**
  3649   * Sets the designated parameter in this <code>RowSet</code> object's command
  3622   * Sets the designated parameter in this <code>RowSet</code> object's command
  3650   * to a <code>Reader</code> object. The
  3623   * to a <code>Reader</code> object. The
  3651   * <code>Reader</code> reads the data till end-of-file is reached. The
  3624   * <code>Reader</code> reads the data till end-of-file is reached. The
  3670   */
  3643   */
  3671   public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException{
  3644   public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException{
  3672         throw new SQLFeatureNotSupportedException("Feature not supported");
  3645         throw new SQLFeatureNotSupportedException("Feature not supported");
  3673    }
  3646    }
  3674 
  3647 
  3675 
  3648    /**
  3676 
       
  3677  /**
       
  3678     * Sets the value of the designated parameter with the given object. The second
  3649     * Sets the value of the designated parameter with the given object. The second
  3679     * argument must be an object type; for integral values, the
  3650     * argument must be an object type; for integral values, the
  3680     * <code>java.lang</code> equivalent objects should be used.
  3651     * <code>java.lang</code> equivalent objects should be used.
  3681     *
  3652     *
  3682     * <p>The given Java object will be converted to the given targetSqlType
  3653     * <p>The given Java object will be converted to the given targetSqlType
  3690     * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,  <code>NClob</code>,
  3661     * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,  <code>NClob</code>,
  3691     *  <code>Struct</code>, <code>java.net.URL</code>,
  3662     *  <code>Struct</code>, <code>java.net.URL</code>,
  3692     * or <code>Array</code>, the driver should pass it to the database as a
  3663     * or <code>Array</code>, the driver should pass it to the database as a
  3693     * value of the corresponding SQL type.
  3664     * value of the corresponding SQL type.
  3694     * <P>
  3665     * <P>
  3695     * Note that this method may be used to pass datatabase-
  3666     * Note that this method may be used to pass database-
  3696     * specific abstract data types.
  3667     * specific abstract data types.
  3697     *
  3668     *
  3698     * @param parameterName the name of the parameter
  3669     * @param parameterName the name of the parameter
  3699     * @param x the object containing the input parameter value
  3670     * @param x the object containing the input parameter value
  3700     * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
  3671     * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
  3718    public void setObject(String parameterName, Object x, int targetSqlType, int scale)
  3689    public void setObject(String parameterName, Object x, int targetSqlType, int scale)
  3719        throws SQLException{
  3690        throws SQLException{
  3720         throw new SQLFeatureNotSupportedException("Feature not supported");
  3691         throw new SQLFeatureNotSupportedException("Feature not supported");
  3721    }
  3692    }
  3722 
  3693 
  3723 
  3694    /**
  3724 
       
  3725  /**
       
  3726     * Sets the value of the designated parameter with the given object.
  3695     * Sets the value of the designated parameter with the given object.
  3727     * This method is like the method <code>setObject</code>
  3696     * This method is like the method <code>setObject</code>
  3728     * above, except that it assumes a scale of zero.
  3697     * above, except that it assumes a scale of zero.
  3729     *
  3698     *
  3730     * @param parameterName the name of the parameter
  3699     * @param parameterName the name of the parameter
  3746    public void setObject(String parameterName, Object x, int targetSqlType)
  3715    public void setObject(String parameterName, Object x, int targetSqlType)
  3747        throws SQLException{
  3716        throws SQLException{
  3748         throw new SQLFeatureNotSupportedException("Feature not supported");
  3717         throw new SQLFeatureNotSupportedException("Feature not supported");
  3749    }
  3718    }
  3750 
  3719 
  3751 
  3720   /**
  3752  /**
       
  3753    * Sets the value of the designated parameter with the given object.
  3721    * Sets the value of the designated parameter with the given object.
  3754    * The second parameter must be of type <code>Object</code>; therefore, the
  3722    * The second parameter must be of type <code>Object</code>; therefore, the
  3755    * <code>java.lang</code> equivalent objects should be used for built-in types.
  3723    * <code>java.lang</code> equivalent objects should be used for built-in types.
  3756    *
  3724    *
  3757    * <p>The JDBC specification specifies a standard mapping from
  3725    * <p>The JDBC specification specifies a standard mapping from
  3758    * Java <code>Object</code> types to SQL types.  The given argument
  3726    * Java <code>Object</code> types to SQL types.  The given argument
  3759    * will be converted to the corresponding SQL type before being
  3727    * will be converted to the corresponding SQL type before being
  3760    * sent to the database.
  3728    * sent to the database.
  3761    *
  3729    *
  3762    * <p>Note that this method may be used to pass datatabase-
  3730    * <p>Note that this method may be used to pass database-
  3763    * specific abstract data types, by using a driver-specific Java
  3731    * specific abstract data types, by using a driver-specific Java
  3764    * type.
  3732    * type.
  3765    *
  3733    *
  3766    * If the object is of a class implementing the interface <code>SQLData</code>,
  3734    * If the object is of a class implementing the interface <code>SQLData</code>,
  3767    * the JDBC driver should call the method <code>SQLData.writeSQL</code>
  3735    * the JDBC driver should call the method <code>SQLData.writeSQL</code>
  3787    */
  3755    */
  3788   public void setObject(String parameterName, Object x) throws SQLException{
  3756   public void setObject(String parameterName, Object x) throws SQLException{
  3789         throw new SQLFeatureNotSupportedException("Feature not supported");
  3757         throw new SQLFeatureNotSupportedException("Feature not supported");
  3790    }
  3758    }
  3791 
  3759 
  3792 
  3760    /**
  3793 
  3761     * Sets the designated parameter to a <code>InputStream</code> object.
  3794  /**
  3762     * The <code>InputStream</code> must contain  the number
  3795     * Sets the designated parameter to a <code>InputStream</code> object.  The inputstream must contain  the number
       
  3796     * of characters specified by length otherwise a <code>SQLException</code> will be
  3763     * of characters specified by length otherwise a <code>SQLException</code> will be
  3797     * generated when the <code>PreparedStatement</code> is executed.
  3764     * generated when the <code>PreparedStatement</code> is executed.
  3798     * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
  3765     * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
  3799     * method because it informs the driver that the parameter value should be
  3766     * method because it informs the driver that the parameter value should be
  3800     * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
  3767     * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
  3807     * @param length the number of bytes in the parameter data.
  3774     * @param length the number of bytes in the parameter data.
  3808     * @throws SQLException if a database access error occurs,
  3775     * @throws SQLException if a database access error occurs,
  3809     * this method is called on a closed <code>PreparedStatement</code>,
  3776     * this method is called on a closed <code>PreparedStatement</code>,
  3810     * if parameterIndex does not correspond
  3777     * if parameterIndex does not correspond
  3811     * to a parameter marker in the SQL statement,  if the length specified
  3778     * to a parameter marker in the SQL statement,  if the length specified
  3812     * is less than zero or if the number of bytes in the inputstream does not match
  3779     * is less than zero or if the number of bytes in the
  3813     * the specified length.
  3780     * <code>InputStream</code> does not match the specified length.
  3814     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
  3781     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
  3815     *
  3782     *
  3816     * @since 1.6
  3783     * @since 1.6
  3817     */
  3784     */
  3818     public void setBlob(int parameterIndex, InputStream inputStream, long length)
  3785     public void setBlob(int parameterIndex, InputStream inputStream, long length)
  3819        throws SQLException{
  3786        throws SQLException{
  3820         throw new SQLFeatureNotSupportedException("Feature not supported");
  3787         throw new SQLFeatureNotSupportedException("Feature not supported");
  3821    }
  3788    }
  3822 
  3789 
  3823 
  3790    /**
  3824  /**
       
  3825     * Sets the designated parameter to a <code>InputStream</code> object.
  3791     * Sets the designated parameter to a <code>InputStream</code> object.
  3826     * This method differs from the <code>setBinaryStream (int, InputStream)</code>
  3792     * This method differs from the <code>setBinaryStream (int, InputStream)</code>
  3827     * method because it informs the driver that the parameter value should be
  3793     * method because it informs the driver that the parameter value should be
  3828     * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
  3794     * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
  3829     * the driver may have to do extra work to determine whether the parameter
  3795     * the driver may have to do extra work to determine whether the parameter
  3846     * @since 1.6
  3812     * @since 1.6
  3847     */
  3813     */
  3848     public void setBlob(int parameterIndex, InputStream inputStream)
  3814     public void setBlob(int parameterIndex, InputStream inputStream)
  3849        throws SQLException{
  3815        throws SQLException{
  3850         throw new SQLFeatureNotSupportedException("Feature not supported");
  3816         throw new SQLFeatureNotSupportedException("Feature not supported");
  3851    }
  3817     }
  3852 
  3818 
  3853 
  3819     /**
  3854  /**
  3820      * Sets the designated parameter to a <code>InputStream</code> object.
  3855     * Sets the designated parameter to a <code>InputStream</code> object.  The <code>inputstream</code> must contain  the number
  3821      * The <code>Inputstream</code> must contain  the number
  3856      * of characters specified by length, otherwise a <code>SQLException</code> will be
  3822      * of characters specified by length, otherwise a <code>SQLException</code> will be
  3857      * generated when the <code>CallableStatement</code> is executed.
  3823      * generated when the <code>CallableStatement</code> is executed.
  3858      * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
  3824      * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
  3859      * method because it informs the driver that the parameter value should be
  3825      * method because it informs the driver that the parameter value should be
  3860      * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
  3826      * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
  3867      * @param inputStream An object that contains the data to set the parameter
  3833      * @param inputStream An object that contains the data to set the parameter
  3868      * value to.
  3834      * value to.
  3869      * @param length the number of bytes in the parameter data.
  3835      * @param length the number of bytes in the parameter data.
  3870      * @throws SQLException  if parameterIndex does not correspond
  3836      * @throws SQLException  if parameterIndex does not correspond
  3871      * to a parameter marker in the SQL statement,  or if the length specified
  3837      * to a parameter marker in the SQL statement,  or if the length specified
  3872      * is less than zero; if the number of bytes in the inputstream does not match
  3838      * is less than zero; if the number of bytes in the <code>InputStream</code> does not match
  3873      * the specified length; if a database access error occurs or
  3839      * the specified length; if a database access error occurs or
  3874      * this method is called on a closed <code>CallableStatement</code>
  3840      * this method is called on a closed <code>CallableStatement</code>
  3875      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
  3841      * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
  3876      * this method
  3842      * this method
  3877      *
  3843      *
  3880      public void setBlob(String parameterName, InputStream inputStream, long length)
  3846      public void setBlob(String parameterName, InputStream inputStream, long length)
  3881         throws SQLException{
  3847         throws SQLException{
  3882         throw new SQLFeatureNotSupportedException("Feature not supported");
  3848         throw new SQLFeatureNotSupportedException("Feature not supported");
  3883    }
  3849    }
  3884 
  3850 
  3885 
  3851    /**
  3886  /**
       
  3887     * Sets the designated parameter to the given <code>java.sql.Blob</code> object.
  3852     * Sets the designated parameter to the given <code>java.sql.Blob</code> object.
  3888     * The driver converts this to an SQL <code>BLOB</code> value when it
  3853     * The driver converts this to an SQL <code>BLOB</code> value when it
  3889     * sends it to the database.
  3854     * sends it to the database.
  3890     *
  3855     *
  3891     * @param parameterName the name of the parameter
  3856     * @param parameterName the name of the parameter
  3898     */
  3863     */
  3899    public void setBlob (String parameterName, Blob x) throws SQLException{
  3864    public void setBlob (String parameterName, Blob x) throws SQLException{
  3900         throw new SQLFeatureNotSupportedException("Feature not supported");
  3865         throw new SQLFeatureNotSupportedException("Feature not supported");
  3901    }
  3866    }
  3902 
  3867 
  3903 
  3868    /**
  3904  /**
       
  3905     * Sets the designated parameter to a <code>InputStream</code> object.
  3869     * Sets the designated parameter to a <code>InputStream</code> object.
  3906     * This method differs from the <code>setBinaryStream (int, InputStream)</code>
  3870     * This method differs from the <code>setBinaryStream (int, InputStream)</code>
  3907     * method because it informs the driver that the parameter value should be
  3871     * method because it informs the driver that the parameter value should be
  3908     * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
  3872     * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
  3909     * the driver may have to do extra work to determine whether the parameter
  3873     * the driver may have to do extra work to determine whether the parameter
  3923     * @since 1.6
  3887     * @since 1.6
  3924     */
  3888     */
  3925     public void setBlob(String parameterName, InputStream inputStream)
  3889     public void setBlob(String parameterName, InputStream inputStream)
  3926        throws SQLException{
  3890        throws SQLException{
  3927         throw new SQLFeatureNotSupportedException("Feature not supported");
  3891         throw new SQLFeatureNotSupportedException("Feature not supported");
  3928    }
  3892     }
  3929 
  3893 
  3930 
  3894    /**
  3931  /**
  3895     * Sets the designated parameter to a <code>Reader</code> object.
  3932    * Sets the designated parameter to a <code>Reader</code> object.  The reader must contain  the number
  3896     * The reader must contain  the number
  3933    * of characters specified by length otherwise a <code>SQLException</code> will be
  3897     * of characters specified by length otherwise a <code>SQLException</code> will be
  3934    * generated when the <code>PreparedStatement</code> is executed.
  3898     * generated when the <code>PreparedStatement</code> is executed.
  3935    *This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
  3899     * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
  3936    * because it informs the driver that the parameter value should be sent to
  3900     * because it informs the driver that the parameter value should be sent to
  3937    * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
  3901     * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
  3938    * driver may have to do extra work to determine whether the parameter
  3902     * driver may have to do extra work to determine whether the parameter
  3939    * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
  3903     * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
  3940    * @param parameterIndex index of the first parameter is 1, the second is 2, ...
  3904     * @param parameterIndex index of the first parameter is 1, the second is 2, ...
  3941    * @param reader An object that contains the data to set the parameter value to.
  3905     * @param reader An object that contains the data to set the parameter value to.
  3942    * @param length the number of characters in the parameter data.
  3906     * @param length the number of characters in the parameter data.
  3943    * @throws SQLException if a database access error occurs, this method is called on
  3907     * @throws SQLException if a database access error occurs, this method is called on
  3944    * a closed <code>PreparedStatement</code>, if parameterIndex does not correspond to a parameter
  3908     * a closed <code>PreparedStatement</code>, if parameterIndex does not correspond to a parameter
  3945    * marker in the SQL statement, or if the length specified is less than zero.
  3909     * marker in the SQL statement, or if the length specified is less than zero.
  3946    *
  3910     *
  3947    * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
  3911     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
  3948    * @since 1.6
  3912     * @since 1.6
  3949    */
  3913     */
  3950    public void setClob(int parameterIndex, Reader reader, long length)
  3914    public void setClob(int parameterIndex, Reader reader, long length)
  3951      throws SQLException{
  3915      throws SQLException{
  3952         throw new SQLFeatureNotSupportedException("Feature not supported");
  3916         throw new SQLFeatureNotSupportedException("Feature not supported");
  3953    }
  3917    }
  3954 
  3918 
  3955 
  3919   /**
  3956 /**
       
  3957    * Sets the designated parameter to a <code>Reader</code> object.
  3920    * Sets the designated parameter to a <code>Reader</code> object.
  3958    * This method differs from the <code>setCharacterStream (int, Reader)</code> method
  3921    * This method differs from the <code>setCharacterStream (int, Reader)</code> method
  3959    * because it informs the driver that the parameter value should be sent to
  3922    * because it informs the driver that the parameter value should be sent to
  3960    * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
  3923    * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
  3961    * driver may have to do extra work to determine whether the parameter
  3924    * driver may have to do extra work to determine whether the parameter
  3977    public void setClob(int parameterIndex, Reader reader)
  3940    public void setClob(int parameterIndex, Reader reader)
  3978      throws SQLException{
  3941      throws SQLException{
  3979         throw new SQLFeatureNotSupportedException("Feature not supported");
  3942         throw new SQLFeatureNotSupportedException("Feature not supported");
  3980    }
  3943    }
  3981 
  3944 
  3982 
  3945    /**
  3983  /**
  3946     * Sets the designated parameter to a <code>Reader</code> object.
  3984     * Sets the designated parameter to a <code>Reader</code> object.  The <code>reader</code> must contain  the number
  3947     * The <code>reader</code> must contain  the number
  3985                * of characters specified by length otherwise a <code>SQLException</code> will be
  3948     * of characters specified by length otherwise a <code>SQLException</code> will be
  3986                * generated when the <code>CallableStatement</code> is executed.
  3949     * generated when the <code>CallableStatement</code> is executed.
  3987               * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
  3950     * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
  3988               * because it informs the driver that the parameter value should be sent to
  3951     * because it informs the driver that the parameter value should be sent to
  3989               * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
  3952     * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
  3990               * driver may have to do extra work to determine whether the parameter
  3953     * driver may have to do extra work to determine whether the parameter
  3991               * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
  3954     * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
  3992               * @param parameterName the name of the parameter to be set
  3955     * @param parameterName the name of the parameter to be set
  3993               * @param reader An object that contains the data to set the parameter value to.
  3956     * @param reader An object that contains the data to set the parameter value to.
  3994               * @param length the number of characters in the parameter data.
  3957     * @param length the number of characters in the parameter data.
  3995               * @throws SQLException if parameterIndex does not correspond to a parameter
  3958     * @throws SQLException if parameterIndex does not correspond to a parameter
  3996               * marker in the SQL statement; if the length specified is less than zero;
  3959     * marker in the SQL statement; if the length specified is less than zero;
  3997               * a database access error occurs or
  3960     * a database access error occurs or
  3998               * this method is called on a closed <code>CallableStatement</code>
  3961     * this method is called on a closed <code>CallableStatement</code>
  3999               * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
  3962     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
  4000               * this method
  3963     * this method
  4001               *
  3964     *
  4002               * @since 1.6
  3965     * @since 1.6
  4003               */
  3966     */
  4004               public void setClob(String parameterName, Reader reader, long length)
  3967    public void setClob(String parameterName, Reader reader, long length)
  4005       throws SQLException{
  3968       throws SQLException {
  4006         throw new SQLFeatureNotSupportedException("Feature not supported");
  3969        throw new SQLFeatureNotSupportedException("Feature not supported");
  4007    }
  3970    }
  4008 
  3971 
  4009 
  3972    /**
  4010   /**
       
  4011     * Sets the designated parameter to the given <code>java.sql.Clob</code> object.
  3973     * Sets the designated parameter to the given <code>java.sql.Clob</code> object.
  4012     * The driver converts this to an SQL <code>CLOB</code> value when it
  3974     * The driver converts this to an SQL <code>CLOB</code> value when it
  4013     * sends it to the database.
  3975     * sends it to the database.
  4014     *
  3976     *
  4015     * @param parameterName the name of the parameter
  3977     * @param parameterName the name of the parameter
  4018     * this method is called on a closed <code>CallableStatement</code>
  3980     * this method is called on a closed <code>CallableStatement</code>
  4019     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
  3981     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
  4020     * this method
  3982     * this method
  4021     * @since 1.6
  3983     * @since 1.6
  4022     */
  3984     */
  4023    public void setClob (String parameterName, Clob x) throws SQLException{
  3985    public void setClob (String parameterName, Clob x) throws SQLException {
  4024         throw new SQLFeatureNotSupportedException("Feature not supported");
  3986        throw new SQLFeatureNotSupportedException("Feature not supported");
  4025    }
  3987    }
  4026 
  3988 
  4027 
  3989    /**
  4028  /**
       
  4029     * Sets the designated parameter to a <code>Reader</code> object.
  3990     * Sets the designated parameter to a <code>Reader</code> object.
  4030     * This method differs from the <code>setCharacterStream (int, Reader)</code> method
  3991     * This method differs from the <code>setCharacterStream (int, Reader)</code> method
  4031     * because it informs the driver that the parameter value should be sent to
  3992     * because it informs the driver that the parameter value should be sent to
  4032     * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
  3993     * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
  4033     * driver may have to do extra work to determine whether the parameter
  3994     * driver may have to do extra work to determine whether the parameter
  4043     * a closed <code>CallableStatement</code>
  4004     * a closed <code>CallableStatement</code>
  4044     *
  4005     *
  4045     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
  4006     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
  4046     * @since 1.6
  4007     * @since 1.6
  4047     */
  4008     */
  4048     public void setClob(String parameterName, Reader reader)
  4009     public void setClob(String parameterName, Reader reader) throws SQLException {
  4049       throws SQLException{
       
  4050         throw new SQLFeatureNotSupportedException("Feature not supported");
  4010         throw new SQLFeatureNotSupportedException("Feature not supported");
  4051    }
  4011     }
  4052 
  4012 
  4053 
  4013    /**
  4054  /**
       
  4055     * Sets the designated parameter to the given <code>java.sql.Date</code> value
  4014     * Sets the designated parameter to the given <code>java.sql.Date</code> value
  4056     * using the default time zone of the virtual machine that is running
  4015     * using the default time zone of the virtual machine that is running
  4057     * the application.
  4016     * the application.
  4058     * The driver converts this
  4017     * The driver converts this
  4059     * to an SQL <code>DATE</code> value when it sends it to the database.
  4018     * to an SQL <code>DATE</code> value when it sends it to the database.
  4066     * this method
  4025     * this method
  4067     * @see #getParams
  4026     * @see #getParams
  4068     * @since 1.4
  4027     * @since 1.4
  4069     */
  4028     */
  4070    public void setDate(String parameterName, java.sql.Date x)
  4029    public void setDate(String parameterName, java.sql.Date x)
  4071        throws SQLException{
  4030            throws SQLException {
  4072         throw new SQLFeatureNotSupportedException("Feature not supported");
  4031        throw new SQLFeatureNotSupportedException("Feature not supported");
  4073    }
  4032    }
  4074 
  4033 
  4075 
  4034    /**
  4076  /**
       
  4077     * Sets the designated parameter to the given <code>java.sql.Date</code> value,
  4035     * Sets the designated parameter to the given <code>java.sql.Date</code> value,
  4078     * using the given <code>Calendar</code> object.  The driver uses
  4036     * using the given <code>Calendar</code> object.  The driver uses
  4079     * the <code>Calendar</code> object to construct an SQL <code>DATE</code> value,
  4037     * the <code>Calendar</code> object to construct an SQL <code>DATE</code> value,
  4080     * which the driver then sends to the database.  With a
  4038     * which the driver then sends to the database.  With a
  4081     * a <code>Calendar</code> object, the driver can calculate the date
  4039     * a <code>Calendar</code> object, the driver can calculate the date
  4093     * this method
  4051     * this method
  4094     * @see #getParams
  4052     * @see #getParams
  4095     * @since 1.4
  4053     * @since 1.4
  4096     */
  4054     */
  4097    public void setDate(String parameterName, java.sql.Date x, Calendar cal)
  4055    public void setDate(String parameterName, java.sql.Date x, Calendar cal)
  4098        throws SQLException{
  4056            throws SQLException {
  4099         throw new SQLFeatureNotSupportedException("Feature not supported");
  4057         throw new SQLFeatureNotSupportedException("Feature not supported");
  4100    }
  4058    }
  4101 
  4059 
  4102 
  4060    /**
  4103  /**
       
  4104     * Sets the designated parameter to the given <code>java.sql.Time</code> value.
  4061     * Sets the designated parameter to the given <code>java.sql.Time</code> value.
  4105     * The driver converts this
  4062     * The driver converts this
  4106     * to an SQL <code>TIME</code> value when it sends it to the database.
  4063     * to an SQL <code>TIME</code> value when it sends it to the database.
  4107     *
  4064     *
  4108     * @param parameterName the name of the parameter
  4065     * @param parameterName the name of the parameter
  4113     * this method
  4070     * this method
  4114     * @see #getParams
  4071     * @see #getParams
  4115     * @since 1.4
  4072     * @since 1.4
  4116     */
  4073     */
  4117    public void setTime(String parameterName, java.sql.Time x)
  4074    public void setTime(String parameterName, java.sql.Time x)
  4118        throws SQLException{
  4075            throws SQLException {
  4119         throw new SQLFeatureNotSupportedException("Feature not supported");
  4076         throw new SQLFeatureNotSupportedException("Feature not supported");
  4120    }
  4077    }
  4121 
  4078 
  4122 
  4079    /**
  4123  /**
       
  4124     * Sets the designated parameter to the given <code>java.sql.Time</code> value,
  4080     * Sets the designated parameter to the given <code>java.sql.Time</code> value,
  4125     * using the given <code>Calendar</code> object.  The driver uses
  4081     * using the given <code>Calendar</code> object.  The driver uses
  4126     * the <code>Calendar</code> object to construct an SQL <code>TIME</code> value,
  4082     * the <code>Calendar</code> object to construct an SQL <code>TIME</code> value,
  4127     * which the driver then sends to the database.  With a
  4083     * which the driver then sends to the database.  With a
  4128     * a <code>Calendar</code> object, the driver can calculate the time
  4084     * a <code>Calendar</code> object, the driver can calculate the time
  4140     * this method
  4096     * this method
  4141     * @see #getParams
  4097     * @see #getParams
  4142     * @since 1.4
  4098     * @since 1.4
  4143     */
  4099     */
  4144    public void setTime(String parameterName, java.sql.Time x, Calendar cal)
  4100    public void setTime(String parameterName, java.sql.Time x, Calendar cal)
  4145        throws SQLException{
  4101            throws SQLException {
  4146         throw new SQLFeatureNotSupportedException("Feature not supported");
  4102         throw new SQLFeatureNotSupportedException("Feature not supported");
  4147    }
  4103    }
  4148 
  4104 
  4149 
  4105    /**
  4150  /**
       
  4151     * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value,
  4106     * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value,
  4152     * using the given <code>Calendar</code> object.  The driver uses
  4107     * using the given <code>Calendar</code> object.  The driver uses
  4153     * the <code>Calendar</code> object to construct an SQL <code>TIMESTAMP</code> value,
  4108     * the <code>Calendar</code> object to construct an SQL <code>TIMESTAMP</code> value,
  4154     * which the driver then sends to the database.  With a
  4109     * which the driver then sends to the database.  With a
  4155     * a <code>Calendar</code> object, the driver can calculate the timestamp
  4110     * a <code>Calendar</code> object, the driver can calculate the timestamp
  4167     * this method
  4122     * this method
  4168     * @see #getParams
  4123     * @see #getParams
  4169     * @since 1.4
  4124     * @since 1.4
  4170     */
  4125     */
  4171    public void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal)
  4126    public void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal)
  4172        throws SQLException{
  4127            throws SQLException {
  4173         throw new SQLFeatureNotSupportedException("Feature not supported");
  4128         throw new SQLFeatureNotSupportedException("Feature not supported");
  4174    }
  4129    }
  4175 
  4130 
  4176 
  4131    /**
  4177  /**
  4132     * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
  4178   * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
  4133     * SQL <code>XML</code> value when it sends it to the database.
  4179   * SQL <code>XML</code> value when it sends it to the database.
  4134     * @param parameterIndex index of the first parameter is 1, the second is 2, ...
  4180   * @param parameterIndex index of the first parameter is 1, the second is 2, ...
  4135     * @param xmlObject a <code>SQLXML</code> object that maps an SQL <code>XML</code> value
  4181   * @param xmlObject a <code>SQLXML</code> object that maps an SQL <code>XML</code> value
  4136     * @throws SQLException if a database access error occurs, this method
  4182   * @throws SQLException if a database access error occurs, this method
  4137     *  is called on a closed result set,
  4183   *  is called on a closed result set,
  4138     * the <code>java.xml.transform.Result</code>,
  4184   * the <code>java.xml.transform.Result</code>,
  4139     *  <code>Writer</code> or <code>OutputStream</code> has not been closed
  4185   *  <code>Writer</code> or <code>OutputStream</code> has not been closed
  4140     * for the <code>SQLXML</code> object  or
  4186   * for the <code>SQLXML</code> object  or
  4141     *  if there is an error processing the XML value.  The <code>getCause</code> method
  4187   *  if there is an error processing the XML value.  The <code>getCause</code> method
  4142     *  of the exception may provide a more detailed exception, for example, if the
  4188   *  of the exception may provide a more detailed exception, for example, if the
  4143     *  stream does not contain valid XML.
  4189   *  stream does not contain valid XML.
  4144     * @throws SQLFeatureNotSupportedException if the JDBC driver does not
  4190   * @throws SQLFeatureNotSupportedException if the JDBC driver does not
  4145     * support this method
  4191   * support this method
  4146     * @since 1.6
  4192   * @since 1.6
  4147     */
  4193   */
  4148    public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
  4194  public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException{
  4149        throw new SQLFeatureNotSupportedException("Feature not supported");
  4195      throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4196  }
       
  4197 
       
  4198 
       
  4199  /**
       
  4200   * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
       
  4201   * <code>SQL XML</code> value when it sends it to the database.
       
  4202   * @param parameterName the name of the parameter
       
  4203   * @param xmlObject a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
       
  4204   * @throws SQLException if a database access error occurs, this method
       
  4205   *  is called on a closed result set,
       
  4206   * the <code>java.xml.transform.Result</code>,
       
  4207   *  <code>Writer</code> or <code>OutputStream</code> has not been closed
       
  4208   * for the <code>SQLXML</code> object  or
       
  4209   *  if there is an error processing the XML value.  The <code>getCause</code> method
       
  4210   *  of the exception may provide a more detailed exception, for example, if the
       
  4211   *  stream does not contain valid XML.
       
  4212   * @throws SQLFeatureNotSupportedException if the JDBC driver does not
       
  4213   * support this method
       
  4214   * @since 1.6
       
  4215   */
       
  4216  public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException{
       
  4217      throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4218  }
       
  4219 
       
  4220 
       
  4221  /**
       
  4222   * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
       
  4223   * driver converts this to a SQL <code>ROWID</code> value when it sends it
       
  4224   * to the database
       
  4225   *
       
  4226   * @param parameterIndex the first parameter is 1, the second is 2, ...
       
  4227   * @param x the parameter value
       
  4228   * @throws SQLException if a database access error occurs
       
  4229   * @throws SQLFeatureNotSupportedException if the JDBC driver does not
       
  4230   * support this method
       
  4231   *
       
  4232   * @since 1.6
       
  4233   */
       
  4234  public void setRowId(int parameterIndex, RowId x) throws SQLException{
       
  4235      throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4236  }
       
  4237 
       
  4238 
       
  4239  /**
       
  4240   * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
       
  4241   * driver converts this to a SQL <code>ROWID</code> when it sends it to the
       
  4242   * database.
       
  4243   *
       
  4244   * @param parameterName the name of the parameter
       
  4245   * @param x the parameter value
       
  4246   * @throws SQLException if a database access error occurs
       
  4247   * @throws SQLFeatureNotSupportedException if the JDBC driver does not
       
  4248   * support this method
       
  4249   * @since 1.6
       
  4250   */
       
  4251  public void setRowId(String parameterName, RowId x) throws SQLException{
       
  4252      throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4253  }
       
  4254 
       
  4255  /**
       
  4256   * Sets the designated parameter to the given <code>String</code> object.
       
  4257   * The driver converts this to a SQL <code>NCHAR</code> or
       
  4258   * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
       
  4259   * (depending on the argument's
       
  4260   * size relative to the driver's limits on <code>NVARCHAR</code> values)
       
  4261   * when it sends it to the database.
       
  4262   *
       
  4263   * @param parameterIndex of the first parameter is 1, the second is 2, ...
       
  4264   * @param value the parameter value
       
  4265   * @throws SQLException if the driver does not support national
       
  4266   *         character sets;  if the driver can detect that a data conversion
       
  4267   *  error could occur ; or if a database access error occurs
       
  4268   * @throws SQLFeatureNotSupportedException if the JDBC driver does not
       
  4269   * support this method
       
  4270   * @since 1.6
       
  4271   */
       
  4272  public void setNString(int parameterIndex, String value) throws SQLException{
       
  4273      throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4274  }
       
  4275 
       
  4276 
       
  4277  /**
       
  4278   * Sets the designated parameter to the given <code>String</code> object.
       
  4279   * The driver converts this to a SQL <code>NCHAR</code> or
       
  4280   * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code>
       
  4281   * @param parameterName the name of the column to be set
       
  4282   * @param value the parameter value
       
  4283   * @throws SQLException if the driver does not support national
       
  4284   *         character sets;  if the driver can detect that a data conversion
       
  4285   *  error could occur; or if a database access error occurs
       
  4286   * @throws SQLFeatureNotSupportedException if the JDBC driver does not
       
  4287   * support this method
       
  4288   * @since 1.6
       
  4289   */
       
  4290  public void setNString(String parameterName, String value)
       
  4291          throws SQLException{
       
  4292      throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4293  }
       
  4294 
       
  4295 
       
  4296  /**
       
  4297   * Sets the designated parameter to a <code>Reader</code> object. The
       
  4298   * <code>Reader</code> reads the data till end-of-file is reached. The
       
  4299   * driver does the necessary conversion from Java character format to
       
  4300   * the national character set in the database.
       
  4301   * @param parameterIndex of the first parameter is 1, the second is 2, ...
       
  4302   * @param value the parameter value
       
  4303   * @param length the number of characters in the parameter data.
       
  4304   * @throws SQLException if the driver does not support national
       
  4305   *         character sets;  if the driver can detect that a data conversion
       
  4306   *  error could occur ; or if a database access error occurs
       
  4307   * @throws SQLFeatureNotSupportedException if the JDBC driver does not
       
  4308   * support this method
       
  4309   * @since 1.6
       
  4310   */
       
  4311  public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException{
       
  4312      throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4313  }
       
  4314 
       
  4315 
       
  4316  /**
       
  4317   * Sets the designated parameter to a <code>Reader</code> object. The
       
  4318   * <code>Reader</code> reads the data till end-of-file is reached. The
       
  4319   * driver does the necessary conversion from Java character format to
       
  4320   * the national character set in the database.
       
  4321   * @param parameterName the name of the column to be set
       
  4322   * @param value the parameter value
       
  4323   * @param length the number of characters in the parameter data.
       
  4324   * @throws SQLException if the driver does not support national
       
  4325   *         character sets;  if the driver can detect that a data conversion
       
  4326   *  error could occur; or if a database access error occurs
       
  4327   * @throws SQLFeatureNotSupportedException  if the JDBC driver does not
       
  4328   * support this method
       
  4329   * @since 1.6
       
  4330   */
       
  4331  public void setNCharacterStream(String parameterName, Reader value, long length)
       
  4332          throws SQLException{
       
  4333      throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4334  }
       
  4335 
       
  4336 
       
  4337  /**
       
  4338   * Sets the designated parameter to a <code>Reader</code> object. The
       
  4339   * <code>Reader</code> reads the data till end-of-file is reached. The
       
  4340   * driver does the necessary conversion from Java character format to
       
  4341   * the national character set in the database.
       
  4342 
       
  4343   * <P><B>Note:</B> This stream object can either be a standard
       
  4344   * Java stream object or your own subclass that implements the
       
  4345   * standard interface.
       
  4346   * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
       
  4347   * it might be more efficient to use a version of
       
  4348   * <code>setNCharacterStream</code> which takes a length parameter.
       
  4349   *
       
  4350   * @param parameterName the name of the parameter
       
  4351   * @param value the parameter value
       
  4352   * @throws SQLException if the driver does not support national
       
  4353   *         character sets;  if the driver can detect that a data conversion
       
  4354   *  error could occur ; if a database access error occurs; or
       
  4355   * this method is called on a closed <code>CallableStatement</code>
       
  4356   * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
       
  4357   * @since 1.6
       
  4358   */
       
  4359   public void setNCharacterStream(String parameterName, Reader value) throws SQLException{
       
  4360         throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4361    }
  4150    }
  4362 
  4151 
       
  4152    /**
       
  4153     * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
       
  4154     * <code>SQL XML</code> value when it sends it to the database.
       
  4155     * @param parameterName the name of the parameter
       
  4156     * @param xmlObject a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
       
  4157     * @throws SQLException if a database access error occurs, this method
       
  4158     *  is called on a closed result set,
       
  4159     * the <code>java.xml.transform.Result</code>,
       
  4160     *  <code>Writer</code> or <code>OutputStream</code> has not been closed
       
  4161     * for the <code>SQLXML</code> object  or
       
  4162     *  if there is an error processing the XML value.  The <code>getCause</code> method
       
  4163     *  of the exception may provide a more detailed exception, for example, if the
       
  4164     *  stream does not contain valid XML.
       
  4165     * @throws SQLFeatureNotSupportedException if the JDBC driver does not
       
  4166     * support this method
       
  4167     * @since 1.6
       
  4168     */
       
  4169    public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
       
  4170        throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4171    }
       
  4172 
       
  4173    /**
       
  4174    * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
       
  4175    * driver converts this to a SQL <code>ROWID</code> value when it sends it
       
  4176    * to the database
       
  4177    *
       
  4178    * @param parameterIndex the first parameter is 1, the second is 2, ...
       
  4179    * @param x the parameter value
       
  4180    * @throws SQLException if a database access error occurs
       
  4181    * @throws SQLFeatureNotSupportedException if the JDBC driver does not
       
  4182    * support this method
       
  4183    *
       
  4184    * @since 1.6
       
  4185    */
       
  4186   public void setRowId(int parameterIndex, RowId x) throws SQLException {
       
  4187       throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4188   }
  4363 
  4189 
  4364   /**
  4190   /**
  4365    * Sets the designated parameter to a <code>java.sql.NClob</code> object. The object
  4191    * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
  4366    * implements the <code>java.sql.NClob</code> interface. This <code>NClob</code>
  4192    * driver converts this to a SQL <code>ROWID</code> when it sends it to the
  4367    * object maps to a SQL <code>NCLOB</code>.
  4193    * database.
       
  4194    *
       
  4195    * @param parameterName the name of the parameter
       
  4196    * @param x the parameter value
       
  4197    * @throws SQLException if a database access error occurs
       
  4198    * @throws SQLFeatureNotSupportedException if the JDBC driver does not
       
  4199    * support this method
       
  4200    * @since 1.6
       
  4201    */
       
  4202   public void setRowId(String parameterName, RowId x) throws SQLException {
       
  4203       throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4204   }
       
  4205 
       
  4206   /**
       
  4207    * Sets the designated parameter to the given <code>String</code> object.
       
  4208    * The driver converts this to a SQL <code>NCHAR</code> or
       
  4209    * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
       
  4210    * (depending on the argument's
       
  4211    * size relative to the driver's limits on <code>NVARCHAR</code> values)
       
  4212    * when it sends it to the database.
       
  4213    *
       
  4214    * @param parameterIndex of the first parameter is 1, the second is 2, ...
       
  4215    * @param value the parameter value
       
  4216    * @throws SQLException if the driver does not support national
       
  4217    * character sets;  if the driver can detect that a data conversion
       
  4218    * error could occur ; or if a database access error occurs
       
  4219    * @throws SQLFeatureNotSupportedException if the JDBC driver does not
       
  4220    * support this method
       
  4221    * @since 1.6
       
  4222    */
       
  4223   public void setNString(int parameterIndex, String value) throws SQLException {
       
  4224       throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4225   }
       
  4226 
       
  4227   /**
       
  4228    * Sets the designated parameter to the given <code>String</code> object.
       
  4229    * The driver converts this to a SQL <code>NCHAR</code> or
       
  4230    * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code>
  4368    * @param parameterName the name of the column to be set
  4231    * @param parameterName the name of the column to be set
  4369    * @param value the parameter value
  4232    * @param value the parameter value
       
  4233    * @throws SQLException if the driver does not support national
       
  4234    * character sets;  if the driver can detect that a data conversion
       
  4235    * error could occur; or if a database access error occurs
       
  4236    * @throws SQLFeatureNotSupportedException if the JDBC driver does not
       
  4237    * support this method
       
  4238    * @since 1.6
       
  4239    */
       
  4240   public void setNString(String parameterName, String value) throws SQLException {
       
  4241      throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4242   }
       
  4243 
       
  4244   /**
       
  4245    * Sets the designated parameter to a <code>Reader</code> object. The
       
  4246    * <code>Reader</code> reads the data till end-of-file is reached. The
       
  4247    * driver does the necessary conversion from Java character format to
       
  4248    * the national character set in the database.
       
  4249    * @param parameterIndex of the first parameter is 1, the second is 2, ...
       
  4250    * @param value the parameter value
       
  4251    * @param length the number of characters in the parameter data.
       
  4252    * @throws SQLException if the driver does not support national
       
  4253    *         character sets;  if the driver can detect that a data conversion
       
  4254    *  error could occur ; or if a database access error occurs
       
  4255    * @throws SQLFeatureNotSupportedException if the JDBC driver does not
       
  4256    * support this method
       
  4257    * @since 1.6
       
  4258    */
       
  4259   public void setNCharacterStream(int parameterIndex, Reader value, long length)
       
  4260           throws SQLException {
       
  4261       throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4262   }
       
  4263 
       
  4264   /**
       
  4265    * Sets the designated parameter to a <code>Reader</code> object. The
       
  4266    * <code>Reader</code> reads the data till end-of-file is reached. The
       
  4267    * driver does the necessary conversion from Java character format to
       
  4268    * the national character set in the database.
       
  4269    * @param parameterName the name of the column to be set
       
  4270    * @param value the parameter value
       
  4271    * @param length the number of characters in the parameter data.
  4370    * @throws SQLException if the driver does not support national
  4272    * @throws SQLException if the driver does not support national
  4371    *         character sets;  if the driver can detect that a data conversion
  4273    *         character sets;  if the driver can detect that a data conversion
  4372    *  error could occur; or if a database access error occurs
  4274    *  error could occur; or if a database access error occurs
  4373    * @throws SQLFeatureNotSupportedException  if the JDBC driver does not
  4275    * @throws SQLFeatureNotSupportedException  if the JDBC driver does not
  4374    * support this method
  4276    * support this method
  4375    * @since 1.6
  4277    * @since 1.6
  4376    */
  4278    */
  4377   public void setNClob(String parameterName, NClob value) throws SQLException{
  4279   public void setNCharacterStream(String parameterName, Reader value, long length)
  4378         throw new SQLFeatureNotSupportedException("Feature not supported");
  4280           throws SQLException {
       
  4281       throw new SQLFeatureNotSupportedException("Feature not supported");
  4379   }
  4282   }
  4380 
  4283 
  4381 
       
  4382   /**
  4284   /**
  4383    * Sets the designated parameter to a <code>Reader</code> object.  The <code>reader</code> must contain
  4285    * Sets the designated parameter to a <code>Reader</code> object. The
  4384    * the number
  4286    * <code>Reader</code> reads the data till end-of-file is reached. The
  4385    * of characters specified by length otherwise a <code>SQLException</code> will be
  4287    * driver does the necessary conversion from Java character format to
  4386    * generated when the <code>CallableStatement</code> is executed.
  4288    * the national character set in the database.
  4387    * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
  4289    * <P><B>Note:</B> This stream object can either be a standard
  4388    * because it informs the driver that the parameter value should be sent to
  4290    * Java stream object or your own subclass that implements the
  4389    * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
  4291    * standard interface.
  4390    * driver may have to do extra work to determine whether the parameter
       
  4391    * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
       
  4392    *
       
  4393    * @param parameterName the name of the parameter to be set
       
  4394    * @param reader An object that contains the data to set the parameter value to.
       
  4395    * @param length the number of characters in the parameter data.
       
  4396    * @throws SQLException if parameterIndex does not correspond to a parameter
       
  4397    * marker in the SQL statement; if the length specified is less than zero;
       
  4398    * if the driver does not support national
       
  4399    *         character sets;  if the driver can detect that a data conversion
       
  4400    *  error could occur; if a database access error occurs or
       
  4401    * this method is called on a closed <code>CallableStatement</code>
       
  4402    * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
       
  4403    * this method
       
  4404    * @since 1.6
       
  4405    */
       
  4406   public void setNClob(String parameterName, Reader reader, long length)
       
  4407            throws SQLException{
       
  4408        throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4409   }
       
  4410 
       
  4411 
       
  4412   /**
       
  4413    * Sets the designated parameter to a <code>Reader</code> object.
       
  4414    * This method differs from the <code>setCharacterStream (int, Reader)</code> method
       
  4415    * because it informs the driver that the parameter value should be sent to
       
  4416    * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
       
  4417    * driver may have to do extra work to determine whether the parameter
       
  4418    * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
       
  4419    * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
  4292    * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
  4420    * it might be more efficient to use a version of
  4293    * it might be more efficient to use a version of
  4421    * <code>setNClob</code> which takes a length parameter.
  4294    * <code>setNCharacterStream</code> which takes a length parameter.
  4422    *
  4295    *
  4423    * @param parameterName the name of the parameter
  4296    * @param parameterName the name of the parameter
  4424    * @param reader An object that contains the data to set the parameter value to.
       
  4425    * @throws SQLException if the driver does not support national character sets;
       
  4426    * if the driver can detect that a data conversion
       
  4427    *  error could occur;  if a database access error occurs or
       
  4428    * this method is called on a closed <code>CallableStatement</code>
       
  4429    * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
       
  4430    *
       
  4431    * @since 1.6
       
  4432    */
       
  4433   public void setNClob(String parameterName, Reader reader)
       
  4434     throws SQLException{
       
  4435         throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4436   }
       
  4437 
       
  4438 
       
  4439   /**
       
  4440    * Sets the designated parameter to a <code>Reader</code> object.  The reader must contain  the number
       
  4441    * of characters specified by length otherwise a <code>SQLException</code> will be
       
  4442    * generated when the <code>PreparedStatement</code> is executed.
       
  4443    * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
       
  4444    * because it informs the driver that the parameter value should be sent to
       
  4445    * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
       
  4446    * driver may have to do extra work to determine whether the parameter
       
  4447    * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
       
  4448    * @param parameterIndex index of the first parameter is 1, the second is 2, ...
       
  4449    * @param reader An object that contains the data to set the parameter value to.
       
  4450    * @param length the number of characters in the parameter data.
       
  4451    * @throws SQLException if parameterIndex does not correspond to a parameter
       
  4452    * marker in the SQL statement; if the length specified is less than zero;
       
  4453    * if the driver does not support national character sets;
       
  4454    * if the driver can detect that a data conversion
       
  4455    *  error could occur;  if a database access error occurs or
       
  4456    * this method is called on a closed <code>PreparedStatement</code>
       
  4457    * @throws SQLFeatureNotSupportedException  if the JDBC driver does not
       
  4458    * support this method
       
  4459    *
       
  4460    * @since 1.6
       
  4461    */
       
  4462   public void setNClob(int parameterIndex, Reader reader, long length)
       
  4463        throws SQLException{
       
  4464         throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4465   }
       
  4466 
       
  4467 
       
  4468   /**
       
  4469    * Sets the designated parameter to a <code>java.sql.NClob</code> object. The driver converts this oa
       
  4470    * SQL <code>NCLOB</code> value when it sends it to the database.
       
  4471    * @param parameterIndex of the first parameter is 1, the second is 2, ...
       
  4472    * @param value the parameter value
  4297    * @param value the parameter value
  4473    * @throws SQLException if the driver does not support national
  4298    * @throws SQLException if the driver does not support national
  4474    *         character sets;  if the driver can detect that a data conversion
  4299    *         character sets;  if the driver can detect that a data conversion
  4475    *  error could occur ; or if a database access error occurs
  4300    *  error could occur ; if a database access error occurs; or
  4476    * @throws SQLFeatureNotSupportedException  if the JDBC driver does not
  4301    * this method is called on a closed <code>CallableStatement</code>
  4477    * support this method
  4302    * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
  4478    * @since 1.6
  4303    * @since 1.6
  4479    */
  4304    */
  4480  public void setNClob(int parameterIndex, NClob value) throws SQLException{
  4305   public void setNCharacterStream(String parameterName, Reader value)
       
  4306           throws SQLException {
       
  4307       throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4308    }
       
  4309 
       
  4310    /**
       
  4311     * Sets the designated parameter to a <code>java.sql.NClob</code> object. The object
       
  4312     * implements the <code>java.sql.NClob</code> interface. This <code>NClob</code>
       
  4313     * object maps to a SQL <code>NCLOB</code>.
       
  4314     * @param parameterName the name of the column to be set
       
  4315     * @param value the parameter value
       
  4316     * @throws SQLException if the driver does not support national
       
  4317     *         character sets;  if the driver can detect that a data conversion
       
  4318     *  error could occur; or if a database access error occurs
       
  4319     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not
       
  4320     * support this method
       
  4321     * @since 1.6
       
  4322     */
       
  4323    public void setNClob(String parameterName, NClob value) throws SQLException {
       
  4324        throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4325    }
       
  4326 
       
  4327    /**
       
  4328     * Sets the designated parameter to a <code>Reader</code> object.  The <code>reader</code> must contain
       
  4329     * the number
       
  4330     * of characters specified by length otherwise a <code>SQLException</code> will be
       
  4331     * generated when the <code>CallableStatement</code> is executed.
       
  4332     * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
       
  4333     * because it informs the driver that the parameter value should be sent to
       
  4334     * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
       
  4335     * driver may have to do extra work to determine whether the parameter
       
  4336     * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
       
  4337     *
       
  4338     * @param parameterName the name of the parameter to be set
       
  4339     * @param reader An object that contains the data to set the parameter value to.
       
  4340     * @param length the number of characters in the parameter data.
       
  4341     * @throws SQLException if parameterIndex does not correspond to a parameter
       
  4342     * marker in the SQL statement; if the length specified is less than zero;
       
  4343     * if the driver does not support national
       
  4344     *         character sets;  if the driver can detect that a data conversion
       
  4345     *  error could occur; if a database access error occurs or
       
  4346     * this method is called on a closed <code>CallableStatement</code>
       
  4347     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
       
  4348     * this method
       
  4349     * @since 1.6
       
  4350     */
       
  4351    public void setNClob(String parameterName, Reader reader, long length)
       
  4352            throws SQLException {
       
  4353        throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4354    }
       
  4355 
       
  4356    /**
       
  4357     * Sets the designated parameter to a <code>Reader</code> object.
       
  4358     * This method differs from the <code>setCharacterStream (int, Reader)</code> method
       
  4359     * because it informs the driver that the parameter value should be sent to
       
  4360     * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
       
  4361     * driver may have to do extra work to determine whether the parameter
       
  4362     * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
       
  4363     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
       
  4364     * it might be more efficient to use a version of
       
  4365     * <code>setNClob</code> which takes a length parameter.
       
  4366     *
       
  4367     * @param parameterName the name of the parameter
       
  4368     * @param reader An object that contains the data to set the parameter value to.
       
  4369     * @throws SQLException if the driver does not support national character sets;
       
  4370     * if the driver can detect that a data conversion
       
  4371     *  error could occur;  if a database access error occurs or
       
  4372     * this method is called on a closed <code>CallableStatement</code>
       
  4373     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
       
  4374     *
       
  4375     * @since 1.6
       
  4376     */
       
  4377    public void setNClob(String parameterName, Reader reader) throws SQLException {
       
  4378        throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4379    }
       
  4380 
       
  4381    /**
       
  4382     * Sets the designated parameter to a <code>Reader</code> object.  The reader must contain  the number
       
  4383     * of characters specified by length otherwise a <code>SQLException</code> will be
       
  4384     * generated when the <code>PreparedStatement</code> is executed.
       
  4385     * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
       
  4386     * because it informs the driver that the parameter value should be sent to
       
  4387     * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
       
  4388     * driver may have to do extra work to determine whether the parameter
       
  4389     * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
       
  4390     * @param parameterIndex index of the first parameter is 1, the second is 2, ...
       
  4391     * @param reader An object that contains the data to set the parameter value to.
       
  4392     * @param length the number of characters in the parameter data.
       
  4393     * @throws SQLException if parameterIndex does not correspond to a parameter
       
  4394     * marker in the SQL statement; if the length specified is less than zero;
       
  4395     * if the driver does not support national character sets;
       
  4396     * if the driver can detect that a data conversion
       
  4397     *  error could occur;  if a database access error occurs or
       
  4398     * this method is called on a closed <code>PreparedStatement</code>
       
  4399     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not
       
  4400     * support this method
       
  4401     *
       
  4402     * @since 1.6
       
  4403     */
       
  4404    public void setNClob(int parameterIndex, Reader reader, long length)
       
  4405            throws SQLException {
       
  4406        throw new SQLFeatureNotSupportedException("Feature not supported");
       
  4407    }
       
  4408 
       
  4409    /**
       
  4410     * Sets the designated parameter to a <code>java.sql.NClob</code> object. The driver converts this oa
       
  4411     * SQL <code>NCLOB</code> value when it sends it to the database.
       
  4412     * @param parameterIndex of the first parameter is 1, the second is 2, ...
       
  4413     * @param value the parameter value
       
  4414     * @throws SQLException if the driver does not support national
       
  4415     *         character sets;  if the driver can detect that a data conversion
       
  4416     *  error could occur ; or if a database access error occurs
       
  4417     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not
       
  4418     * support this method
       
  4419     * @since 1.6
       
  4420     */
       
  4421    public void setNClob(int parameterIndex, NClob value) throws SQLException {
  4481         throw new SQLFeatureNotSupportedException("Feature not supported");
  4422         throw new SQLFeatureNotSupportedException("Feature not supported");
  4482  }
  4423    }
  4483 
  4424 
  4484 
  4425    /**
  4485  /**
  4426     * Sets the designated parameter to a <code>Reader</code> object.
  4486   * Sets the designated parameter to a <code>Reader</code> object.
  4427     * This method differs from the <code>setCharacterStream (int, Reader)</code> method
  4487   * This method differs from the <code>setCharacterStream (int, Reader)</code> method
  4428     * because it informs the driver that the parameter value should be sent to
  4488   * because it informs the driver that the parameter value should be sent to
  4429     * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
  4489   * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
  4430     * driver may have to do extra work to determine whether the parameter
  4490   * driver may have to do extra work to determine whether the parameter
  4431     * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
  4491   * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
  4432     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
  4492   * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
  4433     * it might be more efficient to use a version of
  4493   * it might be more efficient to use a version of
  4434     * <code>setNClob</code> which takes a length parameter.
  4494   * <code>setNClob</code> which takes a length parameter.
  4435     *
  4495   *
  4436     * @param parameterIndex index of the first parameter is 1, the second is 2, ...
  4496   * @param parameterIndex index of the first parameter is 1, the second is 2, ...
  4437     * @param reader An object that contains the data to set the parameter value to.
  4497   * @param reader An object that contains the data to set the parameter value to.
  4438     * @throws SQLException if parameterIndex does not correspond to a parameter
  4498   * @throws SQLException if parameterIndex does not correspond to a parameter
  4439     * marker in the SQL statement;
  4499   * marker in the SQL statement;
  4440     * if the driver does not support national character sets;
  4500   * if the driver does not support national character sets;
  4441     * if the driver can detect that a data conversion
  4501   * if the driver can detect that a data conversion
  4442     *  error could occur;  if a database access error occurs or
  4502   *  error could occur;  if a database access error occurs or
  4443     * this method is called on a closed <code>PreparedStatement</code>
  4503   * this method is called on a closed <code>PreparedStatement</code>
  4444     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
  4504   * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
  4445     *
  4505   *
  4446     * @since 1.6
  4506   * @since 1.6
  4447     */
  4507   */
  4448    public void setNClob(int parameterIndex, Reader reader)throws SQLException {
  4508   public void setNClob(int parameterIndex, Reader reader)
  4449        throw new SQLFeatureNotSupportedException("Feature not supported");
  4509     throws SQLException{
  4450    }
  4510         throw new SQLFeatureNotSupportedException("Feature not supported");
  4451 
  4511   }
  4452    /**
  4512 
  4453     * Sets the designated parameter to the given <code>java.net.URL</code> value.
  4513 
  4454     * The driver converts this to an SQL <code>DATALINK</code> value
  4514   /**
  4455     * when it sends it to the database.
  4515    * Sets the designated parameter to the given <code>java.net.URL</code> value.
  4456     *
  4516    * The driver converts this to an SQL <code>DATALINK</code> value
  4457     * @param parameterIndex the first parameter is 1, the second is 2, ...
  4517    * when it sends it to the database.
  4458     * @param x the <code>java.net.URL</code> object to be set
  4518    *
  4459     * @exception SQLException if a database access error occurs or
  4519    * @param parameterIndex the first parameter is 1, the second is 2, ...
  4460     * this method is called on a closed <code>PreparedStatement</code>
  4520    * @param x the <code>java.net.URL</code> object to be set
  4461     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
  4521    * @exception SQLException if a database access error occurs or
  4462     * @since 1.4
  4522    * this method is called on a closed <code>PreparedStatement</code>
  4463     */
  4523    * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
  4464    public void setURL(int parameterIndex, java.net.URL x) throws SQLException {
  4524    * @since 1.4
  4465        throw new SQLFeatureNotSupportedException("Feature not supported");
  4525    */
  4466    }
  4526   public void setURL(int parameterIndex, java.net.URL x) throws SQLException{
  4467 
  4527         throw new SQLFeatureNotSupportedException("Feature not supported");
  4468    static final long serialVersionUID = 4886719666485113312L;
  4528   }
       
  4529 
       
  4530 
       
  4531 
       
  4532   static final long serialVersionUID = 4886719666485113312L;
       
  4533 
  4469 
  4534 } //end class
  4470 } //end class