jdk/src/share/classes/javax/sql/RowSet.java
author duke
Sat, 01 Dec 2007 00:00:00 +0000
changeset 2 90ce3da70b43
child 5506 202f599c92aa
permissions -rw-r--r--
Initial load
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
90ce3da70b43 Initial load
duke
parents:
diff changeset
     2
 * Copyright 2000-2006 Sun Microsystems, Inc.  All Rights Reserved.
90ce3da70b43 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
90ce3da70b43 Initial load
duke
parents:
diff changeset
     4
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
90ce3da70b43 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
90ce3da70b43 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.  Sun designates this
90ce3da70b43 Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
90ce3da70b43 Initial load
duke
parents:
diff changeset
     9
 * by Sun in the LICENSE file that accompanied this code.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    10
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
90ce3da70b43 Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    16
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
90ce3da70b43 Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    20
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    21
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    22
 * CA 95054 USA or visit www.sun.com if you need additional information or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    23
 * have any questions.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    24
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    25
90ce3da70b43 Initial load
duke
parents:
diff changeset
    26
package javax.sql;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
90ce3da70b43 Initial load
duke
parents:
diff changeset
    28
import java.sql.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    29
import java.io.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    30
import java.math.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    31
import java.util.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    32
90ce3da70b43 Initial load
duke
parents:
diff changeset
    33
/**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    34
 * The interface that adds support to the JDBC API for the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    35
 * JavaBeans<sup><font size=-2>TM</font></sup> component model.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    36
 * A rowset, which can be used as a JavaBeans component in
90ce3da70b43 Initial load
duke
parents:
diff changeset
    37
 * a visual Bean development environment, can be created and
90ce3da70b43 Initial load
duke
parents:
diff changeset
    38
 * configured at design time and executed at run time.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    39
 * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
 * The <code>RowSet</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
 * interface provides a set of JavaBeans properties that allow a <code>RowSet</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
 * instance to be configured to connect to a JDBC data source and read
90ce3da70b43 Initial load
duke
parents:
diff changeset
    43
 * some data from the data source.  A group of setter methods (<code>setInt</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    44
 * <code>setBytes</code>, <code>setString</code>, and so on)
90ce3da70b43 Initial load
duke
parents:
diff changeset
    45
 * provide a way to pass input parameters to a rowset's command property.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
 * This command is the SQL query the rowset uses when it gets its data from
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
 * a relational database, which is generally the case.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    48
 * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    49
 * The <code>RowSet</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    50
 * interface supports JavaBeans events, allowing other components in an
90ce3da70b43 Initial load
duke
parents:
diff changeset
    51
 * application to be notified when an event occurs on a rowset,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    52
 * such as a change in its value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    53
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
 * <P>The <code>RowSet</code> interface is unique in that it is intended to be
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
 * implemented using the rest of the JDBC API.  In other words, a
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
 * <code>RowSet</code> implementation is a layer of software that executes "on top"
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
 * of a JDBC driver.  Implementations of the <code>RowSet</code> interface can
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
 * be provided by anyone, including JDBC driver vendors who want to
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
 * provide a <code>RowSet</code> implementation as part of their JDBC products.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
 * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
 * A <code>RowSet</code> object may make a connection with a data source and
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
 * maintain that connection throughout its life cycle, in which case it is
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
 * called a <i>connected</i> rowset.  A rowset may also make a connection with
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
 * a data source, get data from it, and then close the connection. Such a rowset
90ce3da70b43 Initial load
duke
parents:
diff changeset
    65
 * is called a <i>disconnected</i> rowset.  A disconnected rowset may make
90ce3da70b43 Initial load
duke
parents:
diff changeset
    66
 * changes to its data while it is disconnected and then send the changes back
90ce3da70b43 Initial load
duke
parents:
diff changeset
    67
 * to the original source of the data, but it must reestablish a connection to do so.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
 * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
 * A disconnected rowset may have a reader (a <code>RowSetReader</code> object)
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
 * and a writer (a <code>RowSetWriter</code> object) associated with it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
 * The reader may be implemented in many different ways to populate a rowset
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
 * with data, including getting data from a non-relational data source. The
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
 * writer can also be implemented in many different ways to propagate changes
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
 * made to the rowset's data back to the underlying data source.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    75
 * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    76
 * Rowsets are easy to use.  The <code>RowSet</code> interface extends the standard
90ce3da70b43 Initial load
duke
parents:
diff changeset
    77
 * <code>java.sql.ResultSet</code> interface.  The <code>RowSetMetaData</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
 * interface extends the <code>java.sql.ResultSetMetaData</code> interface.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
 * Thus, developers familiar
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
 * with the JDBC API will have to learn a minimal number of new APIs to
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
 * use rowsets.  In addition, third-party software tools that work with
90ce3da70b43 Initial load
duke
parents:
diff changeset
    82
 * JDBC <code>ResultSet</code> objects will also easily be made to work with rowsets.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    83
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
 * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    86
90ce3da70b43 Initial load
duke
parents:
diff changeset
    87
public interface RowSet extends ResultSet {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
90ce3da70b43 Initial load
duke
parents:
diff changeset
    89
  //-----------------------------------------------------------------------
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
  // Properties
90ce3da70b43 Initial load
duke
parents:
diff changeset
    91
  //-----------------------------------------------------------------------
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
  //-----------------------------------------------------------------------
90ce3da70b43 Initial load
duke
parents:
diff changeset
    94
  // The following properties may be used to create a Connection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    95
  //-----------------------------------------------------------------------
90ce3da70b43 Initial load
duke
parents:
diff changeset
    96
90ce3da70b43 Initial load
duke
parents:
diff changeset
    97
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    98
   * Retrieves the url property this <code>RowSet</code> object will use to
90ce3da70b43 Initial load
duke
parents:
diff changeset
    99
   * create a connection if it uses the <code>DriverManager</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   100
   * instead of a <code>DataSource</code> object to establish the connection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   101
   * The default value is <code>null</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   102
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   103
   * @return a string url
90ce3da70b43 Initial load
duke
parents:
diff changeset
   104
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   105
   * @see #setUrl
90ce3da70b43 Initial load
duke
parents:
diff changeset
   106
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   107
  String getUrl() throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   108
90ce3da70b43 Initial load
duke
parents:
diff changeset
   109
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   110
   * Sets the URL this <code>RowSet</code> object will use when it uses the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   111
   * <code>DriverManager</code> to create a connection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   112
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   113
   * Setting this property is optional.  If a URL is used, a JDBC driver
90ce3da70b43 Initial load
duke
parents:
diff changeset
   114
   * that accepts the URL must be loaded before the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   115
   * rowset is used to connect to a database.  The rowset will use the URL
90ce3da70b43 Initial load
duke
parents:
diff changeset
   116
   * internally to create a database connection when reading or writing
90ce3da70b43 Initial load
duke
parents:
diff changeset
   117
   * data.  Either a URL or a data source name is used to create a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   118
   * connection, whichever was set to non null value most recently.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   119
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   120
   * @param url a string value; may be <code>null</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   121
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   122
   * @see #getUrl
90ce3da70b43 Initial load
duke
parents:
diff changeset
   123
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   124
  void setUrl(String url) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   125
90ce3da70b43 Initial load
duke
parents:
diff changeset
   126
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   127
   * Retrieves the logical name that identifies the data source for this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   128
   * <code>RowSet</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   129
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   130
   * @return a data source name
90ce3da70b43 Initial load
duke
parents:
diff changeset
   131
   * @see #setDataSourceName
90ce3da70b43 Initial load
duke
parents:
diff changeset
   132
   * @see #setUrl
90ce3da70b43 Initial load
duke
parents:
diff changeset
   133
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   134
  String getDataSourceName();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   135
90ce3da70b43 Initial load
duke
parents:
diff changeset
   136
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   137
   * Sets the data source name property for this <code>RowSet</code> object to the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   138
   * given <code>String</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   139
   * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   140
   * The value of the data source name property can be used to do a lookup of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   141
   * a <code>DataSource</code> object that has been registered with a naming
90ce3da70b43 Initial load
duke
parents:
diff changeset
   142
   * service.  After being retrieved, the <code>DataSource</code> object can be
90ce3da70b43 Initial load
duke
parents:
diff changeset
   143
   * used to create a connection to the data source that it represents.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   144
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   145
   * @param name the logical name of the data source for this <code>RowSet</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   146
   *        object; may be <code>null</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   147
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   148
   * @see #getDataSourceName
90ce3da70b43 Initial load
duke
parents:
diff changeset
   149
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   150
  void setDataSourceName(String name) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   151
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
   * Retrieves the username used to create a database connection for this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   154
   * <code>RowSet</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   155
   * The username property is set at run time before calling the method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
   * <code>execute</code>.  It is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
   * not usually part of the serialized state of a <code>RowSet</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   158
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   159
   * @return the username property
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
   * @see #setUsername
90ce3da70b43 Initial load
duke
parents:
diff changeset
   161
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   162
  String getUsername();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   163
90ce3da70b43 Initial load
duke
parents:
diff changeset
   164
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   165
   * Sets the username property for this <code>RowSet</code> object to the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   166
   * given <code>String</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   167
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   168
   * @param name a user name
90ce3da70b43 Initial load
duke
parents:
diff changeset
   169
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   170
   * @see #getUsername
90ce3da70b43 Initial load
duke
parents:
diff changeset
   171
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   172
  void setUsername(String name) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   173
90ce3da70b43 Initial load
duke
parents:
diff changeset
   174
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   175
   * Retrieves the password used to create a database connection.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   176
   * The password property is set at run time before calling the method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   177
   * <code>execute</code>.  It is not usually part of the serialized state
90ce3da70b43 Initial load
duke
parents:
diff changeset
   178
   * of a <code>RowSet</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   179
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   180
   * @return the password for making a database connection
90ce3da70b43 Initial load
duke
parents:
diff changeset
   181
   * @see #setPassword
90ce3da70b43 Initial load
duke
parents:
diff changeset
   182
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   183
  String getPassword();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   184
90ce3da70b43 Initial load
duke
parents:
diff changeset
   185
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   186
   * Sets the database password for this <code>RowSet</code> object to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   187
   * the given <code>String</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   188
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   189
   * @param password the password string
90ce3da70b43 Initial load
duke
parents:
diff changeset
   190
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   191
   * @see #getPassword
90ce3da70b43 Initial load
duke
parents:
diff changeset
   192
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   193
  void setPassword(String password) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   194
90ce3da70b43 Initial load
duke
parents:
diff changeset
   195
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   196
   * Retrieves the transaction isolation level set for this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   197
   * <code>RowSet</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   198
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   199
   * @return the transaction isolation level; one of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   200
   *      <code>Connection.TRANSACTION_READ_UNCOMMITTED</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   201
   *      <code>Connection.TRANSACTION_READ_COMMITTED</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   202
   *      <code>Connection.TRANSACTION_REPEATABLE_READ</code>, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   203
   *      <code>Connection.TRANSACTION_SERIALIZABLE</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   204
   * @see #setTransactionIsolation
90ce3da70b43 Initial load
duke
parents:
diff changeset
   205
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   206
  int getTransactionIsolation();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   207
90ce3da70b43 Initial load
duke
parents:
diff changeset
   208
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   209
   * Sets the transaction isolation level for this <code>RowSet</code> obejct.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   210
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   211
   * @param level the transaction isolation level; one of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   212
   *      <code>Connection.TRANSACTION_READ_UNCOMMITTED</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   213
   *      <code>Connection.TRANSACTION_READ_COMMITTED</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   214
   *      <code>Connection.TRANSACTION_REPEATABLE_READ</code>, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   215
   *      <code>Connection.TRANSACTION_SERIALIZABLE</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   216
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   217
   * @see #getTransactionIsolation
90ce3da70b43 Initial load
duke
parents:
diff changeset
   218
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   219
  void setTransactionIsolation(int level) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   220
90ce3da70b43 Initial load
duke
parents:
diff changeset
   221
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   222
   * Retrieves the <code>Map</code> object associated with this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   223
   * <code>RowSet</code> object, which specifies the custom mapping
90ce3da70b43 Initial load
duke
parents:
diff changeset
   224
   * of SQL user-defined types, if any.  The default is for the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   225
   * type map to be empty.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   226
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   227
   * @return a <code>java.util.Map</code> object containing the names of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   228
   *         SQL user-defined types and the Java classes to which they are
90ce3da70b43 Initial load
duke
parents:
diff changeset
   229
   *         to be mapped
90ce3da70b43 Initial load
duke
parents:
diff changeset
   230
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   231
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   232
   * @see #setTypeMap
90ce3da70b43 Initial load
duke
parents:
diff changeset
   233
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   234
   java.util.Map<String,Class<?>> getTypeMap() throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   235
90ce3da70b43 Initial load
duke
parents:
diff changeset
   236
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   237
   * Installs the given <code>java.util.Map</code> object as the default
90ce3da70b43 Initial load
duke
parents:
diff changeset
   238
   * type map for this <code>RowSet</code> object. This type map will be
90ce3da70b43 Initial load
duke
parents:
diff changeset
   239
   * used unless another type map is supplied as a method parameter.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   240
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   241
   * @param map  a <code>java.util.Map</code> object containing the names of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   242
   *         SQL user-defined types and the Java classes to which they are
90ce3da70b43 Initial load
duke
parents:
diff changeset
   243
   *         to be mapped
90ce3da70b43 Initial load
duke
parents:
diff changeset
   244
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   245
   * @see #getTypeMap
90ce3da70b43 Initial load
duke
parents:
diff changeset
   246
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   247
   void setTypeMap(java.util.Map<String,Class<?>> map) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   248
90ce3da70b43 Initial load
duke
parents:
diff changeset
   249
  //-----------------------------------------------------------------------
90ce3da70b43 Initial load
duke
parents:
diff changeset
   250
  // The following properties may be used to create a Statement.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   251
  //-----------------------------------------------------------------------
90ce3da70b43 Initial load
duke
parents:
diff changeset
   252
90ce3da70b43 Initial load
duke
parents:
diff changeset
   253
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   254
   * Retrieves this <code>RowSet</code> object's command property.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   255
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   256
   * The command property contains a command string, which must be an SQL
90ce3da70b43 Initial load
duke
parents:
diff changeset
   257
   * query, that can be executed to fill the rowset with data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   258
   * The default value is <code>null</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   259
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   260
   * @return the command string; may be <code>null</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   261
   * @see #setCommand
90ce3da70b43 Initial load
duke
parents:
diff changeset
   262
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   263
  String getCommand();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   264
90ce3da70b43 Initial load
duke
parents:
diff changeset
   265
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   266
   * Sets this <code>RowSet</code> object's command property to the given
90ce3da70b43 Initial load
duke
parents:
diff changeset
   267
   * SQL query.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   268
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   269
   * This property is optional
90ce3da70b43 Initial load
duke
parents:
diff changeset
   270
   * when a rowset gets its data from a data source that does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   271
   * commands, such as a spreadsheet.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   272
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   273
   * @param cmd the SQL query that will be used to get the data for this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   274
   *        <code>RowSet</code> object; may be <code>null</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   275
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   276
   * @see #getCommand
90ce3da70b43 Initial load
duke
parents:
diff changeset
   277
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   278
  void setCommand(String cmd) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   279
90ce3da70b43 Initial load
duke
parents:
diff changeset
   280
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   281
   * Retrieves whether this <code>RowSet</code> object is read-only.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   282
   * If updates are possible, the default is for a rowset to be
90ce3da70b43 Initial load
duke
parents:
diff changeset
   283
   * updatable.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   284
   * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   285
   * Attempts to update a read-only rowset will result in an
90ce3da70b43 Initial load
duke
parents:
diff changeset
   286
   * <code>SQLException</code> being thrown.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   287
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   288
   * @return <code>true</code> if this <code>RowSet</code> object is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   289
   *         read-only; <code>false</code> if it is updatable
90ce3da70b43 Initial load
duke
parents:
diff changeset
   290
   * @see #setReadOnly
90ce3da70b43 Initial load
duke
parents:
diff changeset
   291
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   292
  boolean isReadOnly();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   293
90ce3da70b43 Initial load
duke
parents:
diff changeset
   294
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   295
   * Sets whether this <code>RowSet</code> object is read-only to the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   296
   * given <code>boolean</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   297
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   298
   * @param value <code>true</code> if read-only; <code>false</code> if
90ce3da70b43 Initial load
duke
parents:
diff changeset
   299
   *        updatable
90ce3da70b43 Initial load
duke
parents:
diff changeset
   300
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   301
   * @see #isReadOnly
90ce3da70b43 Initial load
duke
parents:
diff changeset
   302
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   303
  void setReadOnly(boolean value) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   304
90ce3da70b43 Initial load
duke
parents:
diff changeset
   305
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   306
   * Retrieves the maximum number of bytes that may be returned
90ce3da70b43 Initial load
duke
parents:
diff changeset
   307
   * for certain column values.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   308
   * This limit applies only to <code>BINARY</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   309
   * <code>VARBINARY</code>, <code>LONGVARBINARYBINARY</code>, <code>CHAR</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   310
   * <code>VARCHAR</code>, <code>LONGVARCHAR</code>, <code>NCHAR</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   311
   * and <code>NVARCHAR</code> columns.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   312
   * If the limit is exceeded, the excess data is silently discarded.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   313
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   314
   * @return the current maximum column size limit; zero means that there
90ce3da70b43 Initial load
duke
parents:
diff changeset
   315
   *          is no limit
90ce3da70b43 Initial load
duke
parents:
diff changeset
   316
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   317
   * @see #setMaxFieldSize
90ce3da70b43 Initial load
duke
parents:
diff changeset
   318
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   319
  int getMaxFieldSize() throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   320
90ce3da70b43 Initial load
duke
parents:
diff changeset
   321
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   322
   * Sets the maximum number of bytes that can be returned for a column
90ce3da70b43 Initial load
duke
parents:
diff changeset
   323
   * value to the given number of bytes.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   324
   * This limit applies only to <code>BINARY</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   325
   * <code>VARBINARY</code>, <code>LONGVARBINARYBINARY</code>, <code>CHAR</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   326
   * <code>VARCHAR</code>, <code>LONGVARCHAR</code>, <code>NCHAR</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
   * and <code>NVARCHAR</code> columns.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   328
   * If the limit is exceeded, the excess data is silently discarded.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   329
   * For maximum portability, use values greater than 256.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   330
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   331
   * @param max the new max column size limit in bytes; zero means unlimited
90ce3da70b43 Initial load
duke
parents:
diff changeset
   332
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   333
   * @see #getMaxFieldSize
90ce3da70b43 Initial load
duke
parents:
diff changeset
   334
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   335
  void setMaxFieldSize(int max) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   336
90ce3da70b43 Initial load
duke
parents:
diff changeset
   337
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   338
   * Retrieves the maximum number of rows that this <code>RowSet</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   339
   * object can contain.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   340
   * If the limit is exceeded, the excess rows are silently dropped.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   341
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   342
   * @return the current maximum number of rows that this <code>RowSet</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   343
   *         object can contain; zero means unlimited
90ce3da70b43 Initial load
duke
parents:
diff changeset
   344
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   345
   * @see #setMaxRows
90ce3da70b43 Initial load
duke
parents:
diff changeset
   346
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   347
  int getMaxRows() throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   348
90ce3da70b43 Initial load
duke
parents:
diff changeset
   349
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   350
   * Sets the maximum number of rows that this <code>RowSet</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   351
   * object can contain to the specified number.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   352
   * If the limit is exceeded, the excess rows are silently dropped.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   353
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   354
   * @param max the new maximum number of rows; zero means unlimited
90ce3da70b43 Initial load
duke
parents:
diff changeset
   355
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   356
   * @see #getMaxRows
90ce3da70b43 Initial load
duke
parents:
diff changeset
   357
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   358
  void setMaxRows(int max) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   359
90ce3da70b43 Initial load
duke
parents:
diff changeset
   360
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   361
   * Retrieves whether escape processing is enabled for this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   362
   * <code>RowSet</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   363
   * If escape scanning is enabled, which is the default, the driver will do
90ce3da70b43 Initial load
duke
parents:
diff changeset
   364
   * escape substitution before sending an SQL statement to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   365
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   366
   * @return <code>true</code> if escape processing is enabled;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   367
   *         <code>false</code> if it is disabled
90ce3da70b43 Initial load
duke
parents:
diff changeset
   368
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   369
   * @see #setEscapeProcessing
90ce3da70b43 Initial load
duke
parents:
diff changeset
   370
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   371
  boolean getEscapeProcessing() throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   372
90ce3da70b43 Initial load
duke
parents:
diff changeset
   373
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   374
   * Sets escape processing for this <code>RowSet</code> object on or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   375
   * off. If escape scanning is on (the default), the driver will do
90ce3da70b43 Initial load
duke
parents:
diff changeset
   376
   * escape substitution before sending an SQL statement to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   377
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   378
   * @param enable <code>true</code> to enable escape processing;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   379
   *        <code>false</code> to disable it
90ce3da70b43 Initial load
duke
parents:
diff changeset
   380
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   381
   * @see #getEscapeProcessing
90ce3da70b43 Initial load
duke
parents:
diff changeset
   382
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   383
  void setEscapeProcessing(boolean enable) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   384
90ce3da70b43 Initial load
duke
parents:
diff changeset
   385
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   386
   * Retrieves the maximum number of seconds the driver will wait for
90ce3da70b43 Initial load
duke
parents:
diff changeset
   387
   * a statement to execute.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   388
   * If this limit is exceeded, an <code>SQLException</code> is thrown.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   389
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   390
   * @return the current query timeout limit in seconds; zero means
90ce3da70b43 Initial load
duke
parents:
diff changeset
   391
   *          unlimited
90ce3da70b43 Initial load
duke
parents:
diff changeset
   392
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   393
   * @see #setQueryTimeout
90ce3da70b43 Initial load
duke
parents:
diff changeset
   394
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   395
  int getQueryTimeout() throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   396
90ce3da70b43 Initial load
duke
parents:
diff changeset
   397
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   398
   * Sets the maximum time the driver will wait for
90ce3da70b43 Initial load
duke
parents:
diff changeset
   399
   * a statement to execute to the given number of seconds.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   400
   * If this limit is exceeded, an <code>SQLException</code> is thrown.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   401
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   402
   * @param seconds the new query timeout limit in seconds; zero means
90ce3da70b43 Initial load
duke
parents:
diff changeset
   403
   *        that there is no limit
90ce3da70b43 Initial load
duke
parents:
diff changeset
   404
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   405
   * @see #getQueryTimeout
90ce3da70b43 Initial load
duke
parents:
diff changeset
   406
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   407
  void setQueryTimeout(int seconds) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   408
90ce3da70b43 Initial load
duke
parents:
diff changeset
   409
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   410
   * Sets the type of this <code>RowSet</code> object to the given type.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   411
   * This method is used to change the type of a rowset, which is by
90ce3da70b43 Initial load
duke
parents:
diff changeset
   412
   * default read-only and non-scrollable.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   413
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   414
   * @param type one of the <code>ResultSet</code> constants specifying a type:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   415
   *        <code>ResultSet.TYPE_FORWARD_ONLY</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   416
   *        <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   417
   *        <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   418
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   419
   * @see java.sql.ResultSet#getType
90ce3da70b43 Initial load
duke
parents:
diff changeset
   420
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   421
  void setType(int type) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   422
90ce3da70b43 Initial load
duke
parents:
diff changeset
   423
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   424
   * Sets the concurrency of this <code>RowSet</code> object to the given
90ce3da70b43 Initial load
duke
parents:
diff changeset
   425
   * concurrency level. This method is used to change the concurrency level
90ce3da70b43 Initial load
duke
parents:
diff changeset
   426
   * of a rowset, which is by default <code>ResultSet.CONCUR_READ_ONLY</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   427
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   428
   * @param concurrency one of the <code>ResultSet</code> constants specifying a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   429
   *        concurrency level:  <code>ResultSet.CONCUR_READ_ONLY</code> or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   430
   *        <code>ResultSet.CONCUR_UPDATABLE</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   431
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   432
   * @see ResultSet#getConcurrency
90ce3da70b43 Initial load
duke
parents:
diff changeset
   433
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   434
  void setConcurrency(int concurrency) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   435
90ce3da70b43 Initial load
duke
parents:
diff changeset
   436
  //-----------------------------------------------------------------------
90ce3da70b43 Initial load
duke
parents:
diff changeset
   437
  // Parameters
90ce3da70b43 Initial load
duke
parents:
diff changeset
   438
  //-----------------------------------------------------------------------
90ce3da70b43 Initial load
duke
parents:
diff changeset
   439
90ce3da70b43 Initial load
duke
parents:
diff changeset
   440
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   441
   * The <code>RowSet</code> setter methods are used to set any input parameters
90ce3da70b43 Initial load
duke
parents:
diff changeset
   442
   * needed by the <code>RowSet</code> object's command.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   443
   * Parameters are set at run time, as opposed to design time.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   444
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   445
90ce3da70b43 Initial load
duke
parents:
diff changeset
   446
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   447
   * Sets the designated parameter in this <code>RowSet</code> object's SQL
90ce3da70b43 Initial load
duke
parents:
diff changeset
   448
   * command to SQL <code>NULL</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   449
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   450
   * <P><B>Note:</B> You must specify the parameter's SQL type.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   451
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   452
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   453
   * @param sqlType a SQL type code defined by <code>java.sql.Types</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   454
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   455
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   456
  void setNull(int parameterIndex, int sqlType) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   457
90ce3da70b43 Initial load
duke
parents:
diff changeset
   458
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   459
     * Sets the designated parameter to SQL <code>NULL</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   460
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   461
     * <P><B>Note:</B> You must specify the parameter's SQL type.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   462
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   463
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
   464
     * @param sqlType the SQL type code defined in <code>java.sql.Types</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   465
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   466
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   467
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   468
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   469
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   470
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   471
    void setNull(String parameterName, int sqlType) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   472
90ce3da70b43 Initial load
duke
parents:
diff changeset
   473
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   474
   * Sets the designated parameter in this <code>RowSet</code> object's SQL
90ce3da70b43 Initial load
duke
parents:
diff changeset
   475
   * command to SQL <code>NULL</code>. This version of the method <code>setNull</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   476
   * should  be used for SQL user-defined types (UDTs) and <code>REF</code> type
90ce3da70b43 Initial load
duke
parents:
diff changeset
   477
   * parameters.  Examples of UDTs include: <code>STRUCT</code>, <code>DISTINCT</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   478
   * <code>JAVA_OBJECT</code>, and named array types.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   479
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   480
   * <P><B>Note:</B> To be portable, applications must give the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   481
   * SQL type code and the fully qualified SQL type name when specifying
90ce3da70b43 Initial load
duke
parents:
diff changeset
   482
   * a NULL UDT or <code>REF</code> parameter.  In the case of a UDT,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   483
   * the name is the type name of the parameter itself.  For a <code>REF</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   484
   * parameter, the name is the type name of the referenced type.  If
90ce3da70b43 Initial load
duke
parents:
diff changeset
   485
   * a JDBC driver does not need the type code or type name information,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   486
   * it may ignore it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   487
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   488
   * Although it is intended for UDT and <code>REF</code> parameters,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   489
   * this method may be used to set a null parameter of any JDBC type.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   490
   * If the parameter does not have a user-defined or <code>REF</code> type,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   491
   * the typeName parameter is ignored.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   492
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   493
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   494
   * @param paramIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   495
   * @param sqlType a value from <code>java.sql.Types</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   496
   * @param typeName the fully qualified name of an SQL UDT or the type
90ce3da70b43 Initial load
duke
parents:
diff changeset
   497
   *        name of the SQL structured type being referenced by a <code>REF</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   498
   *        type; ignored if the parameter is not a UDT or <code>REF</code> type
90ce3da70b43 Initial load
duke
parents:
diff changeset
   499
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   500
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   501
  void setNull (int paramIndex, int sqlType, String typeName)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   502
    throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   503
90ce3da70b43 Initial load
duke
parents:
diff changeset
   504
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   505
     * Sets the designated parameter to SQL <code>NULL</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   506
     * This version of the method <code>setNull</code> should
90ce3da70b43 Initial load
duke
parents:
diff changeset
   507
     * be used for user-defined types and REF type parameters.  Examples
90ce3da70b43 Initial load
duke
parents:
diff changeset
   508
     * of user-defined types include: STRUCT, DISTINCT, JAVA_OBJECT, and
90ce3da70b43 Initial load
duke
parents:
diff changeset
   509
     * named array types.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   510
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   511
     * <P><B>Note:</B> To be portable, applications must give the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   512
     * SQL type code and the fully-qualified SQL type name when specifying
90ce3da70b43 Initial load
duke
parents:
diff changeset
   513
     * a NULL user-defined or REF parameter.  In the case of a user-defined type
90ce3da70b43 Initial load
duke
parents:
diff changeset
   514
     * the name is the type name of the parameter itself.  For a REF
90ce3da70b43 Initial load
duke
parents:
diff changeset
   515
     * parameter, the name is the type name of the referenced type.  If
90ce3da70b43 Initial load
duke
parents:
diff changeset
   516
     * a JDBC driver does not need the type code or type name information,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   517
     * it may ignore it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   518
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   519
     * Although it is intended for user-defined and Ref parameters,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   520
     * this method may be used to set a null parameter of any JDBC type.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   521
     * If the parameter does not have a user-defined or REF type, the given
90ce3da70b43 Initial load
duke
parents:
diff changeset
   522
     * typeName is ignored.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   523
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   524
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   525
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
   526
     * @param sqlType a value from <code>java.sql.Types</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   527
     * @param typeName the fully-qualified name of an SQL user-defined type;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   528
     *        ignored if the parameter is not a user-defined type or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   529
     *        SQL <code>REF</code> value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   530
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   531
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   532
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   533
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   534
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   535
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   536
    void setNull (String parameterName, int sqlType, String typeName)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   537
        throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   538
90ce3da70b43 Initial load
duke
parents:
diff changeset
   539
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   540
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   541
   * to the given Java <code>boolean</code> value. The driver converts this to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   542
   * an SQL <code>BIT</code> value before sending it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   543
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   544
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   545
   * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   546
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   547
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   548
  void setBoolean(int parameterIndex, boolean x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   549
90ce3da70b43 Initial load
duke
parents:
diff changeset
   550
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   551
     * Sets the designated parameter to the given Java <code>boolean</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   552
     * The driver converts this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   553
     * to an SQL <code>BIT</code> or <code>BOOLEAN</code> value when it sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   554
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   555
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
   556
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   557
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   558
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   559
     * @see #getBoolean
90ce3da70b43 Initial load
duke
parents:
diff changeset
   560
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   561
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   562
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   563
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   564
    void setBoolean(String parameterName, boolean x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   565
90ce3da70b43 Initial load
duke
parents:
diff changeset
   566
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   567
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   568
   * to the given Java <code>byte</code> value. The driver converts this to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   569
   * an SQL <code>TINYINT</code> value before sending it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   570
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   571
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   572
   * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   573
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   574
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   575
  void setByte(int parameterIndex, byte x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   576
90ce3da70b43 Initial load
duke
parents:
diff changeset
   577
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   578
     * Sets the designated parameter to the given Java <code>byte</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   579
     * The driver converts this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   580
     * to an SQL <code>TINYINT</code> value when it sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   581
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   582
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
   583
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   584
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   585
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   586
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   587
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   588
     * @see #getByte
90ce3da70b43 Initial load
duke
parents:
diff changeset
   589
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   590
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   591
    void setByte(String parameterName, byte x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   592
90ce3da70b43 Initial load
duke
parents:
diff changeset
   593
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   594
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   595
   * to the given Java <code>short</code> value. The driver converts this to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   596
   * an SQL <code>SMALLINT</code> value before sending it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   597
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   598
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   599
   * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   600
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   601
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   602
  void setShort(int parameterIndex, short x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   603
90ce3da70b43 Initial load
duke
parents:
diff changeset
   604
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   605
     * Sets the designated parameter to the given Java <code>short</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   606
     * The driver converts this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   607
     * to an SQL <code>SMALLINT</code> value when it sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   608
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   609
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
   610
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   611
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   612
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   613
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   614
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   615
     * @see #getShort
90ce3da70b43 Initial load
duke
parents:
diff changeset
   616
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   617
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   618
    void setShort(String parameterName, short x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   619
90ce3da70b43 Initial load
duke
parents:
diff changeset
   620
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   621
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   622
   * to the given Java <code>int</code> value. The driver converts this to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   623
   * an SQL <code>INTEGER</code> value before sending it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   624
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   625
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   626
   * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   627
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   628
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   629
  void setInt(int parameterIndex, int x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   630
90ce3da70b43 Initial load
duke
parents:
diff changeset
   631
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   632
     * Sets the designated parameter to the given Java <code>int</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   633
     * The driver converts this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   634
     * to an SQL <code>INTEGER</code> value when it sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   635
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   636
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
   637
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   638
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   639
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   640
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   641
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   642
     * @see #getInt
90ce3da70b43 Initial load
duke
parents:
diff changeset
   643
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   644
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   645
    void setInt(String parameterName, int x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   646
90ce3da70b43 Initial load
duke
parents:
diff changeset
   647
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   648
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   649
   * to the given Java <code>long</code> value. The driver converts this to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   650
   * an SQL <code>BIGINT</code> value before sending it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   651
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   652
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   653
   * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   654
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   655
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   656
  void setLong(int parameterIndex, long x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   657
90ce3da70b43 Initial load
duke
parents:
diff changeset
   658
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   659
     * Sets the designated parameter to the given Java <code>long</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   660
     * The driver converts this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   661
     * to an SQL <code>BIGINT</code> value when it sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   662
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   663
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
   664
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   665
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   666
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   667
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   668
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   669
     * @see #getLong
90ce3da70b43 Initial load
duke
parents:
diff changeset
   670
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   671
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   672
    void setLong(String parameterName, long x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   673
90ce3da70b43 Initial load
duke
parents:
diff changeset
   674
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   675
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   676
   * to the given Java <code>float</code> value. The driver converts this to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   677
   * an SQL <code>REAL</code> value before sending it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   678
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   679
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   680
   * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   681
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   682
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   683
  void setFloat(int parameterIndex, float x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   684
90ce3da70b43 Initial load
duke
parents:
diff changeset
   685
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   686
     * Sets the designated parameter to the given Java <code>float</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   687
     * The driver converts this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   688
     * to an SQL <code>FLOAT</code> value when it sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   689
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   690
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
   691
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   692
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   693
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   694
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   695
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   696
     * @see #getFloat
90ce3da70b43 Initial load
duke
parents:
diff changeset
   697
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   698
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   699
    void setFloat(String parameterName, float x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   700
90ce3da70b43 Initial load
duke
parents:
diff changeset
   701
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   702
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   703
   * to the given Java <code>double</code> value. The driver converts this to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   704
   * an SQL <code>DOUBLE</code> value before sending it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   705
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   706
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   707
   * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   708
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   709
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   710
  void setDouble(int parameterIndex, double x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   711
90ce3da70b43 Initial load
duke
parents:
diff changeset
   712
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   713
     * Sets the designated parameter to the given Java <code>double</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   714
     * The driver converts this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   715
     * to an SQL <code>DOUBLE</code> value when it sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   716
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   717
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
   718
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   719
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   720
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   721
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   722
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   723
     * @see #getDouble
90ce3da70b43 Initial load
duke
parents:
diff changeset
   724
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   725
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   726
    void setDouble(String parameterName, double x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   727
90ce3da70b43 Initial load
duke
parents:
diff changeset
   728
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   729
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   730
   * to the given <code>java.math.BigDeciaml</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   731
   * The driver converts this to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   732
   * an SQL <code>NUMERIC</code> value before sending it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   733
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   734
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   735
   * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   736
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   737
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   738
  void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   739
90ce3da70b43 Initial load
duke
parents:
diff changeset
   740
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   741
     * Sets the designated parameter to the given
90ce3da70b43 Initial load
duke
parents:
diff changeset
   742
     * <code>java.math.BigDecimal</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   743
     * The driver converts this to an SQL <code>NUMERIC</code> value when
90ce3da70b43 Initial load
duke
parents:
diff changeset
   744
     * it sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   745
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   746
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
   747
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   748
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   749
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   750
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   751
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   752
     * @see #getBigDecimal
90ce3da70b43 Initial load
duke
parents:
diff changeset
   753
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   754
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   755
    void setBigDecimal(String parameterName, BigDecimal x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   756
90ce3da70b43 Initial load
duke
parents:
diff changeset
   757
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   758
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   759
   * to the given Java <code>String</code> value. Before sending it to the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   760
   * database, the driver converts this to an SQL <code>VARCHAR</code> or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   761
   * <code>LONGVARCHAR</code> value, depending on the argument's size relative
90ce3da70b43 Initial load
duke
parents:
diff changeset
   762
   * to the driver's limits on <code>VARCHAR</code> values.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   763
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   764
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   765
   * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   766
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   767
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   768
  void setString(int parameterIndex, String x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   769
90ce3da70b43 Initial load
duke
parents:
diff changeset
   770
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   771
     * Sets the designated parameter to the given Java <code>String</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   772
     * The driver converts this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   773
     * to an SQL <code>VARCHAR</code> or <code>LONGVARCHAR</code> value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   774
     * (depending on the argument's
90ce3da70b43 Initial load
duke
parents:
diff changeset
   775
     * size relative to the driver's limits on <code>VARCHAR</code> values)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   776
     * when it sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   777
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   778
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
   779
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   780
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   781
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   782
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   783
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   784
     * @see #getString
90ce3da70b43 Initial load
duke
parents:
diff changeset
   785
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   786
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   787
    void setString(String parameterName, String x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   788
90ce3da70b43 Initial load
duke
parents:
diff changeset
   789
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   790
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   791
   * to the given Java array of <code>byte</code> values. Before sending it to the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   792
   * database, the driver converts this to an SQL <code>VARBINARY</code> or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   793
   * <code>LONGVARBINARY</code> value, depending on the argument's size relative
90ce3da70b43 Initial load
duke
parents:
diff changeset
   794
   * to the driver's limits on <code>VARBINARY</code> values.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   795
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   796
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   797
   * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   798
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   799
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   800
  void setBytes(int parameterIndex, byte x[]) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   801
90ce3da70b43 Initial load
duke
parents:
diff changeset
   802
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   803
     * Sets the designated parameter to the given Java array of bytes.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   804
     * The driver converts this to an SQL <code>VARBINARY</code> or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   805
     * <code>LONGVARBINARY</code> (depending on the argument's size relative
90ce3da70b43 Initial load
duke
parents:
diff changeset
   806
     * to the driver's limits on <code>VARBINARY</code> values) when it sends
90ce3da70b43 Initial load
duke
parents:
diff changeset
   807
     * it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   808
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   809
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
   810
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   811
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   812
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   813
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   814
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   815
     * @see #getBytes
90ce3da70b43 Initial load
duke
parents:
diff changeset
   816
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   817
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   818
    void setBytes(String parameterName, byte x[]) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   819
90ce3da70b43 Initial load
duke
parents:
diff changeset
   820
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   821
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   822
   * to the given <code>java.sql.Date</code> value. The driver converts this to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   823
   * an SQL <code>DATE</code> value before sending it to the database, using the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   824
   * default <code>java.util.Calendar</code> to calculate the date.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   825
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   826
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   827
   * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   828
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   829
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   830
  void setDate(int parameterIndex, java.sql.Date x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   831
90ce3da70b43 Initial load
duke
parents:
diff changeset
   832
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   833
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   834
   * to the given <code>java.sql.Time</code> value. The driver converts this to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   835
   * an SQL <code>TIME</code> value before sending it to the database, using the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   836
   * default <code>java.util.Calendar</code> to calculate it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   837
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   838
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   839
   * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   840
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   841
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   842
  void setTime(int parameterIndex, java.sql.Time x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   843
90ce3da70b43 Initial load
duke
parents:
diff changeset
   844
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   845
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   846
   * to the given <code>java.sql.Timestamp</code> value. The driver converts this to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   847
   * an SQL <code>TIMESTAMP</code> value before sending it to the database, using the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   848
   * default <code>java.util.Calendar</code> to calculate it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   849
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   850
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   851
   * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   852
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   853
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   854
  void setTimestamp(int parameterIndex, java.sql.Timestamp x)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   855
    throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   856
90ce3da70b43 Initial load
duke
parents:
diff changeset
   857
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   858
     * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   859
     * The driver
90ce3da70b43 Initial load
duke
parents:
diff changeset
   860
     * converts this to an SQL <code>TIMESTAMP</code> value when it sends it to the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   861
     * database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   862
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   863
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
   864
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   865
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   866
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   867
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   868
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   869
     * @see #getTimestamp
90ce3da70b43 Initial load
duke
parents:
diff changeset
   870
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   871
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   872
    void setTimestamp(String parameterName, java.sql.Timestamp x)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   873
        throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   874
90ce3da70b43 Initial load
duke
parents:
diff changeset
   875
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   876
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   877
   * to the given <code>java.io.InputStream</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   878
   * It may be more practical to send a very large ASCII value via a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   879
   * <code>java.io.InputStream</code> rather than as a <code>LONGVARCHAR</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   880
   * parameter. The driver will read the data from the stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
   881
   * as needed until it reaches end-of-file.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   882
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   883
   * <P><B>Note:</B> This stream object can either be a standard
90ce3da70b43 Initial load
duke
parents:
diff changeset
   884
   * Java stream object or your own subclass that implements the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   885
   * standard interface.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   886
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   887
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   888
   * @param x the Java input stream that contains the ASCII parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   889
   * @param length the number of bytes in the stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
   890
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   891
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   892
  void setAsciiStream(int parameterIndex, java.io.InputStream x, int length)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   893
    throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   894
90ce3da70b43 Initial load
duke
parents:
diff changeset
   895
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   896
     * Sets the designated parameter to the given input stream, which will have
90ce3da70b43 Initial load
duke
parents:
diff changeset
   897
     * the specified number of bytes.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   898
     * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   899
     * parameter, it may be more practical to send it via a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   900
     * <code>java.io.InputStream</code>. Data will be read from the stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
   901
     * as needed until end-of-file is reached.  The JDBC driver will
90ce3da70b43 Initial load
duke
parents:
diff changeset
   902
     * do any necessary conversion from ASCII to the database char format.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   903
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   904
     * <P><B>Note:</B> This stream object can either be a standard
90ce3da70b43 Initial load
duke
parents:
diff changeset
   905
     * Java stream object or your own subclass that implements the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   906
     * standard interface.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   907
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   908
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
   909
     * @param x the Java input stream that contains the ASCII parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   910
     * @param length the number of bytes in the stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
   911
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   912
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   913
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   914
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   915
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   916
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   917
    void setAsciiStream(String parameterName, java.io.InputStream x, int length)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   918
        throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   919
90ce3da70b43 Initial load
duke
parents:
diff changeset
   920
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   921
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   922
   * to the given <code>java.io.InputStream</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   923
   * It may be more practical to send a very large binary value via a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   924
   * <code>java.io.InputStream</code> rather than as a <code>LONGVARBINARY</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   925
   * parameter. The driver will read the data from the stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
   926
   * as needed until it reaches end-of-file.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   927
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   928
   * <P><B>Note:</B> This stream object can either be a standard
90ce3da70b43 Initial load
duke
parents:
diff changeset
   929
   * Java stream object or your own subclass that implements the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   930
   * standard interface.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   931
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   932
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   933
   * @param x the java input stream which contains the binary parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   934
   * @param length the number of bytes in the stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
   935
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   936
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   937
  void setBinaryStream(int parameterIndex, java.io.InputStream x,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   938
                       int length) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   939
90ce3da70b43 Initial load
duke
parents:
diff changeset
   940
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   941
     * Sets the designated parameter to the given input stream, which will have
90ce3da70b43 Initial load
duke
parents:
diff changeset
   942
     * the specified number of bytes.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   943
     * When a very large binary value is input to a <code>LONGVARBINARY</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   944
     * parameter, it may be more practical to send it via a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   945
     * <code>java.io.InputStream</code> object. The data will be read from the stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
   946
     * as needed until end-of-file is reached.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   947
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   948
     * <P><B>Note:</B> This stream object can either be a standard
90ce3da70b43 Initial load
duke
parents:
diff changeset
   949
     * Java stream object or your own subclass that implements the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   950
     * standard interface.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   951
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   952
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
   953
     * @param x the java input stream which contains the binary parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
   954
     * @param length the number of bytes in the stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
   955
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
   956
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   957
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
   958
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   959
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   960
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   961
    void setBinaryStream(String parameterName, java.io.InputStream x,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   962
                         int length) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   963
90ce3da70b43 Initial load
duke
parents:
diff changeset
   964
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   965
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
   966
   * to the given <code>java.io.Reader</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   967
   * It may be more practical to send a very large UNICODE value via a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   968
   * <code>java.io.Reader</code> rather than as a <code>LONGVARCHAR</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   969
   * parameter. The driver will read the data from the stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
   970
   * as needed until it reaches end-of-file.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   971
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   972
   * <P><B>Note:</B> This stream object can either be a standard
90ce3da70b43 Initial load
duke
parents:
diff changeset
   973
   * Java stream object or your own subclass that implements the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   974
   * standard interface.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   975
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   976
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
   977
   * @param reader the <code>Reader</code> object that contains the UNICODE data
90ce3da70b43 Initial load
duke
parents:
diff changeset
   978
   *        to be set
90ce3da70b43 Initial load
duke
parents:
diff changeset
   979
   * @param length the number of characters in the stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
   980
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
   981
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   982
  void setCharacterStream(int parameterIndex,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   983
                          Reader reader,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   984
                          int length) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   985
90ce3da70b43 Initial load
duke
parents:
diff changeset
   986
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   987
     * Sets the designated parameter to the given <code>Reader</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   988
     * object, which is the given number of characters long.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   989
     * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   990
     * parameter, it may be more practical to send it via a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   991
     * <code>java.io.Reader</code> object. The data will be read from the stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
   992
     * as needed until end-of-file is reached.  The JDBC driver will
90ce3da70b43 Initial load
duke
parents:
diff changeset
   993
     * do any necessary conversion from UNICODE to the database char format.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   994
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   995
     * <P><B>Note:</B> This stream object can either be a standard
90ce3da70b43 Initial load
duke
parents:
diff changeset
   996
     * Java stream object or your own subclass that implements the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   997
     * standard interface.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   998
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   999
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1000
     * @param reader the <code>java.io.Reader</code> object that
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1001
     *        contains the UNICODE data used as the designated parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1002
     * @param length the number of characters in the stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1003
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1004
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1005
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1006
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1007
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1008
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1009
    void setCharacterStream(String parameterName,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1010
                            java.io.Reader reader,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1011
                            int length) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1012
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1013
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1014
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1015
   * to the given input stream.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1016
   * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1017
   * parameter, it may be more practical to send it via a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1018
   * <code>java.io.InputStream</code>. Data will be read from the stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1019
   * as needed until end-of-file is reached.  The JDBC driver will
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1020
   * do any necessary conversion from ASCII to the database char format.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1021
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1022
   * <P><B>Note:</B> This stream object can either be a standard
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1023
   * Java stream object or your own subclass that implements the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1024
   * standard interface.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1025
   * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1026
   * it might be more efficient to use a version of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1027
   * <code>setAsciiStream</code> which takes a length parameter.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1028
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1029
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1030
   * @param x the Java input stream that contains the ASCII parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1031
   * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1032
   * this method is called on a closed <code>PreparedStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1033
   * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1034
   * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1035
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1036
  void setAsciiStream(int parameterIndex, java.io.InputStream x)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1037
                      throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1038
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1039
   /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1040
     * Sets the designated parameter to the given input stream.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1041
     * When a very large ASCII value is input to a <code>LONGVARCHAR</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1042
     * parameter, it may be more practical to send it via a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1043
     * <code>java.io.InputStream</code>. Data will be read from the stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1044
     * as needed until end-of-file is reached.  The JDBC driver will
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1045
     * do any necessary conversion from ASCII to the database char format.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1046
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1047
     * <P><B>Note:</B> This stream object can either be a standard
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1048
     * Java stream object or your own subclass that implements the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1049
     * standard interface.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1050
     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1051
     * it might be more efficient to use a version of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1052
     * <code>setAsciiStream</code> which takes a length parameter.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1053
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1054
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1055
     * @param x the Java input stream that contains the ASCII parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1056
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1057
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1058
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1059
       * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1060
    */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1061
    void setAsciiStream(String parameterName, java.io.InputStream x)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1062
            throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1063
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1064
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1065
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1066
   * to the given input stream.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1067
   * When a very large binary value is input to a <code>LONGVARBINARY</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1068
   * parameter, it may be more practical to send it via a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1069
   * <code>java.io.InputStream</code> object. The data will be read from the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1070
   * stream as needed until end-of-file is reached.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1071
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1072
   * <P><B>Note:</B> This stream object can either be a standard
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1073
   * Java stream object or your own subclass that implements the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1074
   * standard interface.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1075
   * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1076
   * it might be more efficient to use a version of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1077
   * <code>setBinaryStream</code> which takes a length parameter.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1078
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1079
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1080
   * @param x the java input stream which contains the binary parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1081
   * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1082
   * this method is called on a closed <code>PreparedStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1083
   * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1084
   * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1085
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1086
  void setBinaryStream(int parameterIndex, java.io.InputStream x)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1087
                       throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1088
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1089
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1090
     * Sets the designated parameter to the given input stream.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1091
     * When a very large binary value is input to a <code>LONGVARBINARY</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1092
     * parameter, it may be more practical to send it via a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1093
     * <code>java.io.InputStream</code> object. The data will be read from the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1094
     * stream as needed until end-of-file is reached.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1095
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1096
     * <P><B>Note:</B> This stream object can either be a standard
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1097
     * Java stream object or your own subclass that implements the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1098
     * standard interface.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1099
     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1100
     * it might be more efficient to use a version of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1101
     * <code>setBinaryStream</code> which takes a length parameter.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1102
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1103
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1104
     * @param x the java input stream which contains the binary parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1105
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1106
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1107
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1108
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1109
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1110
    void setBinaryStream(String parameterName, java.io.InputStream x)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1111
    throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1112
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1113
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1114
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1115
   * to the given <code>Reader</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1116
   * object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1117
   * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1118
   * parameter, it may be more practical to send it via a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1119
   * <code>java.io.Reader</code> object. The data will be read from the stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1120
   * as needed until end-of-file is reached.  The JDBC driver will
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1121
   * do any necessary conversion from UNICODE to the database char format.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1122
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1123
   * <P><B>Note:</B> This stream object can either be a standard
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1124
   * Java stream object or your own subclass that implements the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1125
   * standard interface.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1126
   * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1127
   * it might be more efficient to use a version of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1128
   * <code>setCharacterStream</code> which takes a length parameter.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1129
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1130
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1131
   * @param reader the <code>java.io.Reader</code> object that contains the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1132
   *        Unicode data
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1133
   * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1134
   * this method is called on a closed <code>PreparedStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1135
   * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1136
   * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1137
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1138
  void setCharacterStream(int parameterIndex,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1139
                          java.io.Reader reader) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1140
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1141
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1142
     * Sets the designated parameter to the given <code>Reader</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1143
     * object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1144
     * When a very large UNICODE value is input to a <code>LONGVARCHAR</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1145
     * parameter, it may be more practical to send it via a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1146
     * <code>java.io.Reader</code> object. The data will be read from the stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1147
     * as needed until end-of-file is reached.  The JDBC driver will
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1148
     * do any necessary conversion from UNICODE to the database char format.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1149
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1150
     * <P><B>Note:</B> This stream object can either be a standard
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1151
     * Java stream object or your own subclass that implements the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1152
     * standard interface.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1153
     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1154
     * it might be more efficient to use a version of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1155
     * <code>setCharacterStream</code> which takes a length parameter.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1156
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1157
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1158
     * @param reader the <code>java.io.Reader</code> object that contains the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1159
     *        Unicode data
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1160
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1161
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1162
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1163
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1164
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1165
    void setCharacterStream(String parameterName,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1166
                          java.io.Reader reader) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1167
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1168
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1169
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1170
   * to a <code>Reader</code> object. The
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1171
   * <code>Reader</code> reads the data till end-of-file is reached. The
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1172
   * driver does the necessary conversion from Java character format to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1173
   * the national character set in the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1174
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1175
   * <P><B>Note:</B> This stream object can either be a standard
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1176
   * Java stream object or your own subclass that implements the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1177
   * standard interface.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1178
   * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1179
   * it might be more efficient to use a version of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1180
   * <code>setNCharacterStream</code> which takes a length parameter.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1181
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1182
   * @param parameterIndex of the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1183
   * @param value the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1184
   * @throws SQLException if the driver does not support national
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1185
   *         character sets;  if the driver can detect that a data conversion
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1186
   *  error could occur ; if a database access error occurs; or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1187
   * this method is called on a closed <code>PreparedStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1188
   * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1189
   * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1190
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1191
   void setNCharacterStream(int parameterIndex, Reader value) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1192
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1193
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1194
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1195
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1196
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1197
   * with the given Java <code>Object</code>.  For integral values, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1198
   * <code>java.lang</code> equivalent objects should be used (for example,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1199
   * an instance of the class <code>Integer</code> for an <code>int</code>).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1200
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1201
   * If the second argument is an <code>InputStream</code> then the stream must contain
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1202
   * the number of bytes specified by scaleOrLength.  If the second argument is a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1203
   * <code>Reader</code> then the reader must contain the number of characters specified    * by scaleOrLength. If these conditions are not true the driver will generate a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1204
   * <code>SQLException</code> when the prepared statement is executed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1205
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1206
   * <p>The given Java object will be converted to the targetSqlType
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1207
   * before being sent to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1208
   * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1209
   * If the object is of a class implementing <code>SQLData</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1210
   * the rowset should call the method <code>SQLData.writeSQL</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1211
   * to write the object to an <code>SQLOutput</code> data stream.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1212
   * If, on the other hand, the object is of a class implementing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1213
   * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,  <code>NClob</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1214
   *  <code>Struct</code>, <code>java.net.URL</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1215
   * or <code>Array</code>, the driver should pass it to the database as a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1216
   * value of the corresponding SQL type.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1217
   * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1218
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1219
   * <p>Note that this method may be used to pass datatabase-specific
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1220
   * abstract data types.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1221
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1222
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1223
   * @param x the object containing the input parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1224
   * @param targetSqlType the SQL type (as defined in <code>java.sql.Types</code>)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1225
   *        to be sent to the database. The scale argument may further qualify this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1226
   *        type.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1227
   * @param scaleOrLength for <code>java.sql.Types.DECIMAL</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1228
   *          or <code>java.sql.Types.NUMERIC types</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1229
   *          this is the number of digits after the decimal point. For
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1230
   *          Java Object types <code>InputStream</code> and <code>Reader</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1231
   *          this is the length
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1232
   *          of the data in the stream or reader.  For all other types,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1233
   *          this value will be ignored.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1234
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1235
   * @see java.sql.Types
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1236
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1237
  void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1238
            throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1239
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1240
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1241
     * Sets the value of the designated parameter with the given object. The second
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1242
     * argument must be an object type; for integral values, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1243
     * <code>java.lang</code> equivalent objects should be used.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1244
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1245
     * <p>The given Java object will be converted to the given targetSqlType
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1246
     * before being sent to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1247
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1248
     * If the object has a custom mapping (is of a class implementing the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1249
     * interface <code>SQLData</code>),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1250
     * the JDBC driver should call the method <code>SQLData.writeSQL</code> to write it
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1251
     * to the SQL data stream.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1252
     * If, on the other hand, the object is of a class implementing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1253
     * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,  <code>NClob</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1254
     *  <code>Struct</code>, <code>java.net.URL</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1255
     * or <code>Array</code>, the driver should pass it to the database as a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1256
     * value of the corresponding SQL type.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1257
     * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1258
     * Note that this method may be used to pass datatabase-
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1259
     * specific abstract data types.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1260
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1261
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1262
     * @param x the object containing the input parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1263
     * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1264
     * sent to the database. The scale argument may further qualify this type.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1265
     * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1266
     *          this is the number of digits after the decimal point.  For all other
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1267
     *          types, this value will be ignored.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1268
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1269
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1270
     * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1271
     * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1272
     * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1273
     * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1274
     *  <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1275
     * or  <code>STRUCT</code> data type and the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1276
     * this data type
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1277
     * @see Types
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1278
     * @see #getObject
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1279
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1280
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1281
    void setObject(String parameterName, Object x, int targetSqlType, int scale)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1282
        throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1283
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1284
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1285
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1286
   * with a Java <code>Object</code>.  For integral values, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1287
   * <code>java.lang</code> equivalent objects should be used.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1288
   * This method is like <code>setObject</code> above, but the scale used is the scale
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1289
   * of the second parameter.  Scalar values have a scale of zero.  Literal
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1290
   * values have the scale present in the literal.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1291
   * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1292
   * Even though it is supported, it is not recommended that this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1293
   * be called with floating point input values.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1294
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1295
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1296
   * @param x the object containing the input parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1297
   * @param targetSqlType the SQL type (as defined in <code>java.sql.Types</code>)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1298
   *        to be sent to the database
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1299
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1300
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1301
  void setObject(int parameterIndex, Object x,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1302
                 int targetSqlType) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1303
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1304
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1305
     * Sets the value of the designated parameter with the given object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1306
     * This method is like the method <code>setObject</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1307
     * above, except that it assumes a scale of zero.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1308
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1309
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1310
     * @param x the object containing the input parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1311
     * @param targetSqlType the SQL type (as defined in java.sql.Types) to be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1312
     *                      sent to the database
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1313
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1314
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1315
     * @exception SQLFeatureNotSupportedException if <code>targetSqlType</code> is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1316
     * a <code>ARRAY</code>, <code>BLOB</code>, <code>CLOB</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1317
     * <code>DATALINK</code>, <code>JAVA_OBJECT</code>, <code>NCHAR</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1318
     * <code>NCLOB</code>, <code>NVARCHAR</code>, <code>LONGNVARCHAR</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1319
     *  <code>REF</code>, <code>ROWID</code>, <code>SQLXML</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1320
     * or  <code>STRUCT</code> data type and the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1321
     * this data type
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1322
     * @see #getObject
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1323
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1324
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1325
    void setObject(String parameterName, Object x, int targetSqlType)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1326
        throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1327
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1328
   /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1329
     * Sets the value of the designated parameter with the given object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1330
     * The second parameter must be of type <code>Object</code>; therefore, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1331
     * <code>java.lang</code> equivalent objects should be used for built-in types.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1332
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1333
     * <p>The JDBC specification specifies a standard mapping from
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1334
     * Java <code>Object</code> types to SQL types.  The given argument
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1335
     * will be converted to the corresponding SQL type before being
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1336
     * sent to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1337
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1338
     * <p>Note that this method may be used to pass datatabase-
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1339
     * specific abstract data types, by using a driver-specific Java
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1340
     * type.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1341
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1342
     * If the object is of a class implementing the interface <code>SQLData</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1343
     * the JDBC driver should call the method <code>SQLData.writeSQL</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1344
     * to write it to the SQL data stream.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1345
     * If, on the other hand, the object is of a class implementing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1346
     * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,  <code>NClob</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1347
     *  <code>Struct</code>, <code>java.net.URL</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1348
     * or <code>Array</code>, the driver should pass it to the database as a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1349
     * value of the corresponding SQL type.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1350
     * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1351
     * This method throws an exception if there is an ambiguity, for example, if the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1352
     * object is of a class implementing more than one of the interfaces named above.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1353
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1354
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1355
     * @param x the object containing the input parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1356
     * @exception SQLException if a database access error occurs,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1357
     * this method is called on a closed <code>CallableStatement</code> or if the given
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1358
     *            <code>Object</code> parameter is ambiguous
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1359
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1360
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1361
     * @see #getObject
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1362
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1363
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1364
    void setObject(String parameterName, Object x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1365
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1366
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1367
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1368
   * with a Java <code>Object</code>.  For integral values, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1369
   * <code>java.lang</code> equivalent objects should be used.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1370
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1371
   * <p>The JDBC specification provides a standard mapping from
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1372
   * Java Object types to SQL types.  The driver will convert the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1373
   * given Java object to its standard SQL mapping before sending it
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1374
   * to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1375
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1376
   * <p>Note that this method may be used to pass datatabase-specific
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1377
   * abstract data types by using a driver-specific Java type.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1378
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1379
   * If the object is of a class implementing <code>SQLData</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1380
   * the rowset should call the method <code>SQLData.writeSQL</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1381
   * to write the object to an <code>SQLOutput</code> data stream.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1382
   * If, on the other hand, the object is of a class implementing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1383
   * <code>Ref</code>, <code>Blob</code>, <code>Clob</code>,  <code>NClob</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1384
   *  <code>Struct</code>, <code>java.net.URL</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1385
   * or <code>Array</code>, the driver should pass it to the database as a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1386
   * value of the corresponding SQL type.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1387
   * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1388
   * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1389
   * An exception is thrown if there is an ambiguity, for example, if the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1390
   * object is of a class implementing more than one of these interfaces.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1391
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1392
   * @param parameterIndex The first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1393
   * @param x The object containing the input parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1394
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1395
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1396
  void setObject(int parameterIndex, Object x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1397
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1398
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1399
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1400
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1401
   * with the given  <code>Ref</code> value.  The driver will convert this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1402
   * to the appropriate <code>REF(&lt;structured-type&gt;)</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1403
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1404
   * @param i the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1405
   * @param x an object representing data of an SQL <code>REF</code> type
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1406
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1407
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1408
  void setRef (int i, Ref x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1409
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1410
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1411
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1412
   * with the given  <code>Blob</code> value.  The driver will convert this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1413
   * to the <code>BLOB</code> value that the <code>Blob</code> object
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1414
   * represents before sending it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1415
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1416
   * @param i the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1417
   * @param x an object representing a BLOB
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1418
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1419
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1420
  void setBlob (int i, Blob x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1421
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1422
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1423
     * Sets the designated parameter to a <code>InputStream</code> object.  The inputstream must contain  the number
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1424
     * of characters specified by length otherwise a <code>SQLException</code> will be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1425
     * generated when the <code>PreparedStatement</code> is executed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1426
     * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1427
     * method because it informs the driver that the parameter value should be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1428
     * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1429
     * the driver may have to do extra work to determine whether the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1430
     * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1431
     * @param parameterIndex index of the first parameter is 1,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1432
     * the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1433
     * @param inputStream An object that contains the data to set the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1434
     * value to.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1435
     * @param length the number of bytes in the parameter data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1436
     * @throws SQLException if a database access error occurs,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1437
     * this method is called on a closed <code>PreparedStatement</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1438
     * if parameterIndex does not correspond
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1439
     * to a parameter marker in the SQL statement,  if the length specified
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1440
     * is less than zero or if the number of bytes in the inputstream does not match
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1441
     * the specfied length.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1442
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1443
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1444
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1445
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1446
     void setBlob(int parameterIndex, InputStream inputStream, long length)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1447
        throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1448
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1449
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1450
     * Sets the designated parameter to a <code>InputStream</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1451
     * This method differs from the <code>setBinaryStream (int, InputStream)</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1452
     * method because it informs the driver that the parameter value should be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1453
     * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1454
     * the driver may have to do extra work to determine whether the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1455
     * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1456
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1457
     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1458
     * it might be more efficient to use a version of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1459
     * <code>setBlob</code> which takes a length parameter.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1460
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1461
     * @param parameterIndex index of the first parameter is 1,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1462
     * the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1463
     * @param inputStream An object that contains the data to set the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1464
     * value to.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1465
     * @throws SQLException if a database access error occurs,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1466
     * this method is called on a closed <code>PreparedStatement</code> or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1467
     * if parameterIndex does not correspond
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1468
     * to a parameter marker in the SQL statement,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1469
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1470
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1471
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1472
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1473
     void setBlob(int parameterIndex, InputStream inputStream)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1474
        throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1475
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1476
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1477
     * Sets the designated parameter to a <code>InputStream</code> object.  The <code>inputstream</code> must contain  the number
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1478
     * of characters specified by length, otherwise a <code>SQLException</code> will be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1479
     * generated when the <code>CallableStatement</code> is executed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1480
     * This method differs from the <code>setBinaryStream (int, InputStream, int)</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1481
     * method because it informs the driver that the parameter value should be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1482
     * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1483
     * the driver may have to do extra work to determine whether the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1484
     * data should be sent to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1485
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1486
     * @param parameterName the name of the parameter to be set
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1487
     * the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1488
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1489
     * @param inputStream An object that contains the data to set the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1490
     * value to.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1491
     * @param length the number of bytes in the parameter data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1492
     * @throws SQLException  if parameterIndex does not correspond
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1493
     * to a parameter marker in the SQL statement,  or if the length specified
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1494
     * is less than zero; if the number of bytes in the inputstream does not match
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1495
     * the specfied length; if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1496
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1497
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1498
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1499
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1500
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1501
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1502
     void setBlob(String parameterName, InputStream inputStream, long length)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1503
        throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1504
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1505
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1506
     * Sets the designated parameter to the given <code>java.sql.Blob</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1507
     * The driver converts this to an SQL <code>BLOB</code> value when it
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1508
     * sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1509
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1510
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1511
     * @param x a <code>Blob</code> object that maps an SQL <code>BLOB</code> value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1512
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1513
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1514
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1515
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1516
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1517
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1518
    void setBlob (String parameterName, Blob x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1519
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1520
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1521
     * Sets the designated parameter to a <code>InputStream</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1522
     * This method differs from the <code>setBinaryStream (int, InputStream)</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1523
     * method because it informs the driver that the parameter value should be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1524
     * sent to the server as a <code>BLOB</code>.  When the <code>setBinaryStream</code> method is used,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1525
     * the driver may have to do extra work to determine whether the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1526
     * data should be send to the server as a <code>LONGVARBINARY</code> or a <code>BLOB</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1527
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1528
     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1529
     * it might be more efficient to use a version of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1530
     * <code>setBlob</code> which takes a length parameter.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1531
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1532
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1533
     * @param inputStream An object that contains the data to set the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1534
     * value to.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1535
     * @throws SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1536
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1537
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1538
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1539
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1540
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1541
     void setBlob(String parameterName, InputStream inputStream)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1542
        throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1543
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1544
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1545
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1546
   * with the given  <code>Clob</code> value.  The driver will convert this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1547
   * to the <code>CLOB</code> value that the <code>Clob</code> object
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1548
   * represents before sending it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1549
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1550
   * @param i the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1551
   * @param x an object representing a CLOB
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1552
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1553
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1554
  void setClob (int i, Clob x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1555
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1556
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1557
     * Sets the designated parameter to a <code>Reader</code> object.  The reader must contain  the number
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1558
     * of characters specified by length otherwise a <code>SQLException</code> will be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1559
     * generated when the <code>PreparedStatement</code> is executed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1560
     *This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1561
     * because it informs the driver that the parameter value should be sent to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1562
     * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1563
     * driver may have to do extra work to determine whether the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1564
     * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1565
     * @param parameterIndex index of the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1566
     * @param reader An object that contains the data to set the parameter value to.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1567
     * @param length the number of characters in the parameter data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1568
     * @throws SQLException if a database access error occurs, this method is called on
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1569
     * a closed <code>PreparedStatement</code>, if parameterIndex does not correspond to a parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1570
     * marker in the SQL statement, or if the length specified is less than zero.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1571
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1572
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1573
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1574
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1575
     void setClob(int parameterIndex, Reader reader, long length)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1576
       throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1577
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1578
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1579
     * Sets the designated parameter to a <code>Reader</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1580
     * This method differs from the <code>setCharacterStream (int, Reader)</code> method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1581
     * because it informs the driver that the parameter value should be sent to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1582
     * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1583
     * driver may have to do extra work to determine whether the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1584
     * data should be sent to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1585
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1586
     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1587
     * it might be more efficient to use a version of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1588
     * <code>setClob</code> which takes a length parameter.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1589
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1590
     * @param parameterIndex index of the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1591
     * @param reader An object that contains the data to set the parameter value to.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1592
     * @throws SQLException if a database access error occurs, this method is called on
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1593
     * a closed <code>PreparedStatement</code>or if parameterIndex does not correspond to a parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1594
     * marker in the SQL statement
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1595
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1596
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1597
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1598
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1599
     void setClob(int parameterIndex, Reader reader)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1600
       throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1601
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1602
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1603
     * Sets the designated parameter to a <code>Reader</code> object.  The <code>reader</code> must contain  the number
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1604
     * of characters specified by length otherwise a <code>SQLException</code> will be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1605
     * generated when the <code>CallableStatement</code> is executed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1606
     * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1607
     * because it informs the driver that the parameter value should be sent to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1608
     * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1609
     * driver may have to do extra work to determine whether the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1610
     * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1611
     * @param parameterName the name of the parameter to be set
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1612
     * @param reader An object that contains the data to set the parameter value to.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1613
     * @param length the number of characters in the parameter data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1614
     * @throws SQLException if parameterIndex does not correspond to a parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1615
     * marker in the SQL statement; if the length specified is less than zero;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1616
     * a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1617
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1618
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1619
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1620
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1621
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1622
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1623
     void setClob(String parameterName, Reader reader, long length)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1624
       throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1625
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1626
   /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1627
     * Sets the designated parameter to the given <code>java.sql.Clob</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1628
     * The driver converts this to an SQL <code>CLOB</code> value when it
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1629
     * sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1630
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1631
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1632
     * @param x a <code>Clob</code> object that maps an SQL <code>CLOB</code> value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1633
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1634
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1635
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1636
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1637
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1638
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1639
    void setClob (String parameterName, Clob x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1640
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1641
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1642
     * Sets the designated parameter to a <code>Reader</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1643
     * This method differs from the <code>setCharacterStream (int, Reader)</code> method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1644
     * because it informs the driver that the parameter value should be sent to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1645
     * the server as a <code>CLOB</code>.  When the <code>setCharacterStream</code> method is used, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1646
     * driver may have to do extra work to determine whether the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1647
     * data should be send to the server as a <code>LONGVARCHAR</code> or a <code>CLOB</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1648
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1649
     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1650
     * it might be more efficient to use a version of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1651
     * <code>setClob</code> which takes a length parameter.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1652
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1653
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1654
     * @param reader An object that contains the data to set the parameter value to.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1655
     * @throws SQLException if a database access error occurs or this method is called on
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1656
     * a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1657
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1658
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1659
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1660
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1661
     void setClob(String parameterName, Reader reader)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1662
       throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1663
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1664
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1665
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1666
   * with the given  <code>Array</code> value.  The driver will convert this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1667
   * to the <code>ARRAY</code> value that the <code>Array</code> object
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1668
   * represents before sending it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1669
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1670
   * @param i the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1671
   * @param x an object representing an SQL array
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1672
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1673
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1674
  void setArray (int i, Array x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1675
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1676
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1677
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1678
   * with the given  <code>java.sql.Date</code> value.  The driver will convert this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1679
   * to an SQL <code>DATE</code> value, using the given <code>java.util.Calendar</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1680
   * object to calculate the date.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1681
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1682
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1683
   * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1684
   * @param cal the <code>java.util.Calendar</code> object to use for calculating the date
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1685
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1686
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1687
  void setDate(int parameterIndex, java.sql.Date x, Calendar cal)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1688
    throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1689
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1690
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1691
     * Sets the designated parameter to the given <code>java.sql.Date</code> value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1692
     * using the default time zone of the virtual machine that is running
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1693
     * the application.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1694
     * The driver converts this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1695
     * to an SQL <code>DATE</code> value when it sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1696
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1697
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1698
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1699
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1700
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1701
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1702
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1703
     * @see #getDate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1704
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1705
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1706
    void setDate(String parameterName, java.sql.Date x)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1707
        throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1708
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1709
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1710
     * Sets the designated parameter to the given <code>java.sql.Date</code> value,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1711
     * using the given <code>Calendar</code> object.  The driver uses
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1712
     * the <code>Calendar</code> object to construct an SQL <code>DATE</code> value,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1713
     * which the driver then sends to the database.  With a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1714
     * a <code>Calendar</code> object, the driver can calculate the date
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1715
     * taking into account a custom timezone.  If no
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1716
     * <code>Calendar</code> object is specified, the driver uses the default
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1717
     * timezone, which is that of the virtual machine running the application.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1718
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1719
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1720
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1721
     * @param cal the <code>Calendar</code> object the driver will use
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1722
     *            to construct the date
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1723
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1724
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1725
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1726
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1727
     * @see #getDate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1728
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1729
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1730
    void setDate(String parameterName, java.sql.Date x, Calendar cal)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1731
        throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1732
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1733
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1734
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1735
   * with the given  <code>java.sql.Time</code> value.  The driver will convert this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1736
   * to an SQL <code>TIME</code> value, using the given <code>java.util.Calendar</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1737
   * object to calculate it, before sending it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1738
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1739
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1740
   * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1741
   * @param cal the <code>java.util.Calendar</code> object to use for calculating the time
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1742
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1743
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1744
  void setTime(int parameterIndex, java.sql.Time x, Calendar cal)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1745
    throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1746
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1747
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1748
     * Sets the designated parameter to the given <code>java.sql.Time</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1749
     * The driver converts this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1750
     * to an SQL <code>TIME</code> value when it sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1751
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1752
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1753
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1754
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1755
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1756
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1757
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1758
     * @see #getTime
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1759
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1760
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1761
    void setTime(String parameterName, java.sql.Time x)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1762
        throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1763
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1764
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1765
     * Sets the designated parameter to the given <code>java.sql.Time</code> value,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1766
     * using the given <code>Calendar</code> object.  The driver uses
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1767
     * the <code>Calendar</code> object to construct an SQL <code>TIME</code> value,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1768
     * which the driver then sends to the database.  With a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1769
     * a <code>Calendar</code> object, the driver can calculate the time
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1770
     * taking into account a custom timezone.  If no
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1771
     * <code>Calendar</code> object is specified, the driver uses the default
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1772
     * timezone, which is that of the virtual machine running the application.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1773
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1774
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1775
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1776
     * @param cal the <code>Calendar</code> object the driver will use
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1777
     *            to construct the time
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1778
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1779
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1780
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1781
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1782
     * @see #getTime
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1783
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1784
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1785
    void setTime(String parameterName, java.sql.Time x, Calendar cal)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1786
        throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1787
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1788
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1789
   * Sets the designated parameter in this <code>RowSet</code> object's command
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1790
   * with the given  <code>java.sql.Timestamp</code> value.  The driver will
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1791
   * convert this to an SQL <code>TIMESTAMP</code> value, using the given
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1792
   * <code>java.util.Calendar</code> object to calculate it, before sending it to the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1793
   * database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1794
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1795
   * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1796
   * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1797
   * @param cal the <code>java.util.Calendar</code> object to use for calculating the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1798
   *        timestamp
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1799
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1800
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1801
  void setTimestamp(int parameterIndex, java.sql.Timestamp x, Calendar cal)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1802
    throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1803
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1804
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1805
     * Sets the designated parameter to the given <code>java.sql.Timestamp</code> value,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1806
     * using the given <code>Calendar</code> object.  The driver uses
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1807
     * the <code>Calendar</code> object to construct an SQL <code>TIMESTAMP</code> value,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1808
     * which the driver then sends to the database.  With a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1809
     * a <code>Calendar</code> object, the driver can calculate the timestamp
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1810
     * taking into account a custom timezone.  If no
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1811
     * <code>Calendar</code> object is specified, the driver uses the default
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1812
     * timezone, which is that of the virtual machine running the application.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1813
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1814
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1815
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1816
     * @param cal the <code>Calendar</code> object the driver will use
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1817
     *            to construct the timestamp
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1818
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1819
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1820
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1821
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1822
     * @see #getTimestamp
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1823
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1824
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1825
    void setTimestamp(String parameterName, java.sql.Timestamp x, Calendar cal)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1826
        throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1827
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1828
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1829
   * Clears the parameters set for this <code>RowSet</code> object's command.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1830
   * <P>In general, parameter values remain in force for repeated use of a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1831
   * <code>RowSet</code> object. Setting a parameter value automatically clears its
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1832
   * previous value.  However, in some cases it is useful to immediately
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1833
   * release the resources used by the current parameter values, which can
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1834
   * be done by calling the method <code>clearParameters</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1835
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1836
   * @exception SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1837
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1838
  void clearParameters() throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1839
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1840
  //---------------------------------------------------------------------
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1841
  // Reading and writing data
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1842
  //---------------------------------------------------------------------
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1843
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1844
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1845
   * Fills this <code>RowSet</code> object with data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1846
   * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1847
   * The <code>execute</code> method may use the following properties
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1848
   * to create a connection for reading data: url, data source name,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1849
   * user name, password, transaction isolation, and type map.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1850
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1851
   * The <code>execute</code> method  may use the following properties
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1852
   * to create a statement to execute a command:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1853
   * command, read only, maximum field size,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1854
   * maximum rows, escape processing, and query timeout.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1855
   * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1856
   * If the required properties have not been set, an exception is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1857
   * thrown.  If this method is successful, the current contents of the rowset are
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1858
   * discarded and the rowset's metadata is also (re)set.  If there are
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1859
   * outstanding updates, they are ignored.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1860
   * <P>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1861
   * If this <code>RowSet</code> object does not maintain a continuous connection
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1862
   * with its source of data, it may use a reader (a <code>RowSetReader</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1863
   * object) to fill itself with data.  In this case, a reader will have been
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1864
   * registered with this <code>RowSet</code> object, and the method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1865
   * <code>execute</code> will call on the reader's <code>readData</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1866
   * method as part of its implementation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1867
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1868
   * @exception SQLException if a database access error occurs or any of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1869
   *            properties necessary for making a connection and creating
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1870
   *            a statement have not been set
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1871
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1872
  void execute() throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1873
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1874
  //--------------------------------------------------------------------
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1875
  // Events
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1876
  //--------------------------------------------------------------------
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1877
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1878
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1879
   * Registers the given listener so that it will be notified of events
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1880
   * that occur on this <code>RowSet</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1881
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1882
   * @param listener a component that has implemented the <code>RowSetListener</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1883
   *        interface and wants to be notified when events occur on this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1884
   *        <code>RowSet</code> object
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1885
   * @see #removeRowSetListener
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1886
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1887
  void addRowSetListener(RowSetListener listener);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1888
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1889
  /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1890
   * Removes the specified listener from the list of components that will be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1891
   * notified when an event occurs on this <code>RowSet</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1892
   *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1893
   * @param listener a component that has been registered as a listener for this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1894
   *        <code>RowSet</code> object
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1895
   * @see #addRowSetListener
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1896
   */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1897
  void removeRowSetListener(RowSetListener listener);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1898
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1899
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1900
      * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1901
      * SQL <code>XML</code> value when it sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1902
      * @param parameterIndex index of the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1903
      * @param xmlObject a <code>SQLXML</code> object that maps an SQL <code>XML</code> value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1904
      * @throws SQLException if a database access error occurs, this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1905
      *  is called on a closed result set,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1906
      * the <code>java.xml.transform.Result</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1907
      *  <code>Writer</code> or <code>OutputStream</code> has not been closed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1908
      * for the <code>SQLXML</code> object  or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1909
      *  if there is an error processing the XML value.  The <code>getCause</code> method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1910
      *  of the exception may provide a more detailed exception, for example, if the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1911
      *  stream does not contain valid XML.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1912
      * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1913
      */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1914
     void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1915
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1916
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1917
     * Sets the designated parameter to the given <code>java.sql.SQLXML</code> object. The driver converts this to an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1918
     * <code>SQL XML</code> value when it sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1919
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1920
     * @param xmlObject a <code>SQLXML</code> object that maps an <code>SQL XML</code> value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1921
     * @throws SQLException if a database access error occurs, this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1922
     *  is called on a closed result set,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1923
     * the <code>java.xml.transform.Result</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1924
     *  <code>Writer</code> or <code>OutputStream</code> has not been closed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1925
     * for the <code>SQLXML</code> object  or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1926
     *  if there is an error processing the XML value.  The <code>getCause</code> method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1927
     *  of the exception may provide a more detailed exception, for example, if the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1928
     *  stream does not contain valid XML.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1929
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1930
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1931
    void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1932
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1933
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1934
     * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1935
     * driver converts this to a SQL <code>ROWID</code> value when it sends it
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1936
     * to the database
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1937
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1938
     * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1939
     * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1940
     * @throws SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1941
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1942
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1943
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1944
    void setRowId(int parameterIndex, RowId x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1945
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1946
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1947
    * Sets the designated parameter to the given <code>java.sql.RowId</code> object. The
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1948
    * driver converts this to a SQL <code>ROWID</code> when it sends it to the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1949
    * database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1950
    *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1951
    * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1952
    * @param x the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1953
    * @throws SQLException if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1954
    * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1955
    */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1956
   void setRowId(String parameterName, RowId x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1957
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1958
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1959
     * Sets the designated paramter to the given <code>String</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1960
     * The driver converts this to a SQL <code>NCHAR</code> or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1961
     * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code> value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1962
     * (depending on the argument's
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1963
     * size relative to the driver's limits on <code>NVARCHAR</code> values)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1964
     * when it sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1965
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1966
     * @param parameterIndex of the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1967
     * @param value the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1968
     * @throws SQLException if the driver does not support national
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1969
     *         character sets;  if the driver can detect that a data conversion
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1970
     *  error could occur ; or if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1971
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1972
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1973
     void setNString(int parameterIndex, String value) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1974
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1975
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1976
     * Sets the designated paramter to the given <code>String</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1977
     * The driver converts this to a SQL <code>NCHAR</code> or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1978
     * <code>NVARCHAR</code> or <code>LONGNVARCHAR</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1979
     * @param parameterName the name of the column to be set
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1980
     * @param value the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1981
     * @throws SQLException if the driver does not support national
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1982
     *         character sets;  if the driver can detect that a data conversion
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1983
     *  error could occur; or if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1984
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1985
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1986
    public void setNString(String parameterName, String value)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1987
            throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1988
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1989
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1990
     * Sets the designated parameter to a <code>Reader</code> object. The
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1991
     * <code>Reader</code> reads the data till end-of-file is reached. The
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1992
     * driver does the necessary conversion from Java character format to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1993
     * the national character set in the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1994
     * @param parameterIndex of the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1995
     * @param value the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1996
     * @param length the number of characters in the parameter data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1997
     * @throws SQLException if the driver does not support national
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1998
     *         character sets;  if the driver can detect that a data conversion
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1999
     *  error could occur ; or if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2000
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2001
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2002
     void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2003
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2004
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2005
     * Sets the designated parameter to a <code>Reader</code> object. The
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2006
     * <code>Reader</code> reads the data till end-of-file is reached. The
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2007
     * driver does the necessary conversion from Java character format to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2008
     * the national character set in the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2009
     * @param parameterName the name of the column to be set
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2010
     * @param value the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2011
     * @param length the number of characters in the parameter data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2012
     * @throws SQLException if the driver does not support national
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2013
     *         character sets;  if the driver can detect that a data conversion
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2014
     *  error could occur; or if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2015
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2016
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2017
    public void setNCharacterStream(String parameterName, Reader value, long length)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2018
            throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2019
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2020
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2021
     * Sets the designated parameter to a <code>Reader</code> object. The
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2022
     * <code>Reader</code> reads the data till end-of-file is reached. The
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2023
     * driver does the necessary conversion from Java character format to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2024
     * the national character set in the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2025
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2026
     * <P><B>Note:</B> This stream object can either be a standard
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2027
     * Java stream object or your own subclass that implements the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2028
     * standard interface.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2029
     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2030
     * it might be more efficient to use a version of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2031
     * <code>setNCharacterStream</code> which takes a length parameter.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2032
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2033
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2034
     * @param value the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2035
     * @throws SQLException if the driver does not support national
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2036
     *         character sets;  if the driver can detect that a data conversion
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2037
     *  error could occur ; if a database access error occurs; or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2038
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2039
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2040
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2041
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2042
     void setNCharacterStream(String parameterName, Reader value) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2043
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2044
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2045
    * Sets the designated parameter to a <code>java.sql.NClob</code> object. The object
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2046
    * implements the <code>java.sql.NClob</code> interface. This <code>NClob</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2047
    * object maps to a SQL <code>NCLOB</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2048
    * @param parameterName the name of the column to be set
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2049
    * @param value the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2050
    * @throws SQLException if the driver does not support national
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2051
    *         character sets;  if the driver can detect that a data conversion
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2052
    *  error could occur; or if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2053
    * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2054
    */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2055
    void setNClob(String parameterName, NClob value) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2056
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2057
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2058
     * Sets the designated parameter to a <code>Reader</code> object.  The <code>reader</code> must contain  the number
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2059
     * of characters specified by length otherwise a <code>SQLException</code> will be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2060
     * generated when the <code>CallableStatement</code> is executed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2061
     * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2062
     * because it informs the driver that the parameter value should be sent to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2063
     * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2064
     * driver may have to do extra work to determine whether the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2065
     * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2066
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2067
     * @param parameterName the name of the parameter to be set
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2068
     * @param reader An object that contains the data to set the parameter value to.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2069
     * @param length the number of characters in the parameter data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2070
     * @throws SQLException if parameterIndex does not correspond to a parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2071
     * marker in the SQL statement; if the length specified is less than zero;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2072
     * if the driver does not support national
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2073
     *         character sets;  if the driver can detect that a data conversion
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2074
     *  error could occur; if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2075
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2076
     * @exception SQLFeatureNotSupportedException if the JDBC driver does not support
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2077
     * this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2078
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2079
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2080
     void setNClob(String parameterName, Reader reader, long length)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2081
       throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2082
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2083
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2084
     * Sets the designated parameter to a <code>Reader</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2085
     * This method differs from the <code>setCharacterStream (int, Reader)</code> method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2086
     * because it informs the driver that the parameter value should be sent to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2087
     * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2088
     * driver may have to do extra work to determine whether the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2089
     * data should be send to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2090
     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2091
     * it might be more efficient to use a version of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2092
     * <code>setNClob</code> which takes a length parameter.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2093
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2094
     * @param parameterName the name of the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2095
     * @param reader An object that contains the data to set the parameter value to.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2096
     * @throws SQLException if the driver does not support national character sets;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2097
     * if the driver can detect that a data conversion
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2098
     *  error could occur;  if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2099
     * this method is called on a closed <code>CallableStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2100
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2101
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2102
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2103
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2104
     void setNClob(String parameterName, Reader reader)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2105
       throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2106
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2107
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2108
     * Sets the designated parameter to a <code>Reader</code> object.  The reader must contain  the number
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2109
     * of characters specified by length otherwise a <code>SQLException</code> will be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2110
     * generated when the <code>PreparedStatement</code> is executed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2111
     * This method differs from the <code>setCharacterStream (int, Reader, int)</code> method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2112
     * because it informs the driver that the parameter value should be sent to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2113
     * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2114
     * driver may have to do extra work to determine whether the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2115
     * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2116
     * @param parameterIndex index of the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2117
     * @param reader An object that contains the data to set the parameter value to.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2118
     * @param length the number of characters in the parameter data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2119
     * @throws SQLException if parameterIndex does not correspond to a parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2120
     * marker in the SQL statement; if the length specified is less than zero;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2121
     * if the driver does not support national character sets;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2122
     * if the driver can detect that a data conversion
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2123
     *  error could occur;  if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2124
     * this method is called on a closed <code>PreparedStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2125
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2126
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2127
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2128
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2129
     void setNClob(int parameterIndex, Reader reader, long length)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2130
       throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2131
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2132
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2133
     * Sets the designated parameter to a <code>java.sql.NClob</code> object. The driver converts this to a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2134
     * SQL <code>NCLOB</code> value when it sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2135
     * @param parameterIndex of the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2136
     * @param value the parameter value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2137
     * @throws SQLException if the driver does not support national
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2138
     *         character sets;  if the driver can detect that a data conversion
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2139
     *  error could occur ; or if a database access error occurs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2140
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2141
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2142
     void setNClob(int parameterIndex, NClob value) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2143
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2144
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2145
     * Sets the designated parameter to a <code>Reader</code> object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2146
     * This method differs from the <code>setCharacterStream (int, Reader)</code> method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2147
     * because it informs the driver that the parameter value should be sent to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2148
     * the server as a <code>NCLOB</code>.  When the <code>setCharacterStream</code> method is used, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2149
     * driver may have to do extra work to determine whether the parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2150
     * data should be sent to the server as a <code>LONGNVARCHAR</code> or a <code>NCLOB</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2151
     * <P><B>Note:</B> Consult your JDBC driver documentation to determine if
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2152
     * it might be more efficient to use a version of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2153
     * <code>setNClob</code> which takes a length parameter.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2154
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2155
     * @param parameterIndex index of the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2156
     * @param reader An object that contains the data to set the parameter value to.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2157
     * @throws SQLException if parameterIndex does not correspond to a parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2158
     * marker in the SQL statement;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2159
     * if the driver does not support national character sets;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2160
     * if the driver can detect that a data conversion
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2161
     *  error could occur;  if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2162
     * this method is called on a closed <code>PreparedStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2163
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2164
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2165
     * @since 1.6
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2166
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2167
     void setNClob(int parameterIndex, Reader reader)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2168
       throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2169
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2170
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2171
     * Sets the designated parameter to the given <code>java.net.URL</code> value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2172
     * The driver converts this to an SQL <code>DATALINK</code> value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2173
     * when it sends it to the database.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2174
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2175
     * @param parameterIndex the first parameter is 1, the second is 2, ...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2176
     * @param x the <code>java.net.URL</code> object to be set
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2177
     * @exception SQLException if a database access error occurs or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2178
     * this method is called on a closed <code>PreparedStatement</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2179
     * @throws SQLFeatureNotSupportedException  if the JDBC driver does not support this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2180
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2181
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2182
    void setURL(int parameterIndex, java.net.URL x) throws SQLException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2183
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2184
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2185
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2186
}