package org.apache.struts.util;
import java.sql.PreparedStatement;
import java.sql.Time;
import java.util.Calendar;
import java.sql.Date;
import java.io.Reader;
import java.math.BigDecimal;
import java.sql.SQLException;
import java.io.InputStream;
import java.sql.Timestamp;

/**
 * Insert the type's description here.
 * Creation date: (3-2-2001 15:19:57)
 * @author: 
 */
public class GenericPreparedStatement implements java.sql.PreparedStatement 
{
	private final static String SQLEXCEPTION_CLOSED = "PreparedStatement was closed.";
	
	protected boolean _bClosed;
	protected String _sSqlString;
	protected GenericConnection _connection;
	protected java.sql.PreparedStatement _ps;


	PreparedStatement getPreparedStatement()
	{
		return _ps;
	}



	/**
	 * GenericPreparedStatement constructor comment.
	 */
	public GenericPreparedStatement(GenericConnection connection, String sqlString, PreparedStatement ps)
	{
		super();
		_connection = connection;
		_sSqlString = sqlString;
		_ps = ps;
		_bClosed = true;
	}




	/**
	 * JDBC 2.0
	 *
	 * Adds a set of parameters to the batch.
	 * 
	 * @exception SQLException if a database access error occurs
	 * @see Statement#addBatch
	 */
	public void addBatch() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.addBatch();
	}




	/**
	 * JDBC 2.0
	 *
	 * Adds a SQL command to the current batch of commmands for the statement.
	 * This method is optional.
	 *
	 * @param sql typically this is a static SQL INSERT or UPDATE statement
	 * @exception SQLException if a database access error occurs, or the
	 * driver does not support batch statements
	 */
	public void addBatch(String sql) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.addBatch(sql);
	}




	/**
	 * Cancels this <code>Statement</code> object if both the DBMS and
	 * driver support aborting an SQL statement.
	 * This method can be used by one thread to cancel a statement that
	 * is being executed by another thread.
	 *
	 * @exception SQLException if a database access error occurs
	 */
	public void cancel() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.cancel();
	}




	/**
	 * JDBC 2.0
	 *
	 * Makes the set of commands in the current batch empty.
	 * This method is optional.
	 *
	 * @exception SQLException if a database access error occurs or the
	 * driver does not support batch statements
	 */
	public void clearBatch() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.clearBatch();
		
	}




	/**
	 * Clears the current parameter values immediately.
	 * <P>In general, parameter values remain in force for repeated use of a
	 * Statement. Setting a parameter value automatically clears its
	 * previous value.  However, in some cases it is useful to immediately
	 * release the resources used by the current parameter values; this can
	 * be done by calling clearParameters.
	 *
	 * @exception SQLException if a database access error occurs
	 */
	public void clearParameters() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.clearParameters();
		
	}




	/**
	 * Clears all the warnings reported on this <code>Statement</code>
	 * object. After a call to this method,
	 * the method <code>getWarnings</code> will return 
	 * null until a new warning is reported for this Statement.  
	 *
	 * @exception SQLException if a database access error occurs
	 */
	public void clearWarnings() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.clearWarnings();
		
	}




	/**
	 * Releases this <code>Statement</code> object's database 
	 * and JDBC resources immediately instead of waiting for
	 * this to happen when it is automatically closed.
	 * It is generally good practice to release resources as soon as
	 * you are finished with them to avoid tying up database
	 * resources.
	 * <P><B>Note:</B> A Statement is automatically closed when it is
	 * garbage collected. When a Statement is closed, its current
	 * ResultSet, if one exists, is also closed.  
	 *
	 * @exception SQLException if a database access error occurs
	 */
	public void close() throws java.sql.SQLException 
	{
		if (_bClosed)
			throw new SQLException(SQLEXCEPTION_CLOSED);
		
		try 
		{
			java.sql.ResultSet rs = _ps.getResultSet();
			if(rs != null)
			{
				rs.close();
			}
		} 
		catch (SQLException e) { }
		try 
		{
			clearBatch();
		} 
		catch (SQLException sqlE) { }
		catch (UnsupportedOperationException uoe){}
		try 
		{
			clearParameters();
		} 
		catch (Exception e) { e.printStackTrace();}
		try 
		{
			clearWarnings();
		} 
		catch (SQLException e) { }
		_bClosed = true;
	
		// adding to the pool of the connection
	
		_connection.returnPreparedStatement(this);
	}




	/**
	 * Executes any kind of SQL statement.
	 * Some prepared statements return multiple results; the execute
	 * method handles these complex statements as well as the simpler
	 * form of statements handled by executeQuery and executeUpdate.
	 *
	 * @exception SQLException if a database access error occurs
	 * @see Statement#execute
	 */
	public boolean execute() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.execute();
	}




	/**
	 * Executes a SQL statement that may return multiple results.
	 * Under some (uncommon) situations a single SQL statement may return
	 * multiple result sets and/or update counts.  Normally you can ignore
	 * this unless you are (1) executing a stored procedure that you know may
	 * return multiple results or (2) you are dynamically executing an
	 * unknown SQL string.  The  methods <code>execute</code>,
	 * <code>getMoreResults</code>, <code>getResultSet</code>,
	 * and <code>getUpdateCount</code> let you navigate through multiple results.
	 *
	 * The <code>execute</code> method executes a SQL statement and indicates the
	 * form of the first result.  You can then use getResultSet or
	 * getUpdateCount to retrieve the result, and getMoreResults to
	 * move to any subsequent result(s).
	 *
	 * @param sql any SQL statement
	 * @return true if the next result is a ResultSet; false if it is
	 * an update count or there are no more results
	 * @exception SQLException if a database access error occurs
	 * @see #getResultSet
	 * @see #getUpdateCount
	 * @see #getMoreResults 
	 */
	public boolean execute(String sql) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.execute(sql);
	}




	/**
	 * JDBC 2.0
	 * 
	 * Submits a batch of commands to the database for execution.
	 * This method is optional.
	 *
	 * @return an array of update counts containing one element for each
	 * command in the batch.  The array is ordered according 
	 * to the order in which commands were inserted into the batch.
	 * @exception SQLException if a database access error occurs or the
	 * driver does not support batch statements
	 */
	public int[] executeBatch() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.executeBatch();
	}




	/**
	 * Executes the SQL query in this <code>PreparedStatement</code> object
	 * and returns the result set generated by the query.
	 *
	 * @return a ResultSet that contains the data produced by the
	 * query; never null
	 * @exception SQLException if a database access error occurs
	 */
	public java.sql.ResultSet executeQuery() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.executeQuery();
	}




	/**
	 * Executes a SQL statement that returns a single ResultSet.
	 *
	 * @param sql typically this is a static SQL SELECT statement
	 * @return a ResultSet that contains the data produced by the
	 * query; never null 
	 * @exception SQLException if a database access error occurs
	 */
	public java.sql.ResultSet executeQuery(String sql) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.executeQuery(sql);
	}




	/**
	 * Executes the SQL INSERT, UPDATE or DELETE statement
	 * in this <code>PreparedStatement</code> object.
	 * In addition,
	 * SQL statements that return nothing, such as SQL DDL statements,
	 * can be executed.
	 *
	 * @return either the row count for INSERT, UPDATE or DELETE statements;
	 * or 0 for SQL statements that return nothing
	 * @exception SQLException if a database access error occurs
	 */
	public int executeUpdate() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.executeUpdate();
	}




	/**
	 * Executes an SQL INSERT, UPDATE or DELETE statement. In addition,
	 * SQL statements that return nothing, such as SQL DDL statements,
	 * can be executed.
	 *
	 * @param sql a SQL INSERT, UPDATE or DELETE statement or a SQL
	 * statement that returns nothing
	 * @return either the row count for INSERT, UPDATE or DELETE or 0
	 * for SQL statements that return nothing
	 * @exception SQLException if a database access error occurs
	 */
	public int executeUpdate(String sql) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.executeUpdate(sql);
	}




	/**
	 * JDBC 2.0
	 * 
	 * Returns the <code>Connection</code> object
	 * that produced this <code>Statement</code> object.
	 * @return the connection that produced this statement
	 * @exception SQLException if a database access error occurs
	 */
	public java.sql.Connection getConnection() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.getConnection();
	}




	/**
	 * JDBC 2.0
	 *
	 * Retrieves the direction for fetching rows from
	 * database tables that is the default for result sets
	 * generated from this <code>Statement</code> object.
	 * If this <code>Statement</code> object has not set
	 * a fetch direction by calling the method <code>setFetchDirection</code>,
	 * the return value is implementation-specific.
	 *
	 * @return the default fetch direction for result sets generated
	 *          from this <code>Statement</code> object
	 * @exception SQLException if a database access error occurs
	 */
	public int getFetchDirection() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.getFetchDirection();
	}




	/**
	 * JDBC 2.0
	 *
	 * Retrieves the number of result set rows that is the default 
	 * fetch size for result sets
	 * generated from this <code>Statement</code> object.
	 * If this <code>Statement</code> object has not set
	 * a fetch size by calling the method <code>setFetchSize</code>,
	 * the return value is implementation-specific.
	 * @return the default fetch size for result sets generated
	 *          from this <code>Statement</code> object
	 * @exception SQLException if a database access error occurs
	 */
	public int getFetchSize() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.getFetchSize();
	}




	/**
	 * Returns the maximum number of bytes allowed
	 * for any column value. 
	 * This limit is the maximum number of bytes that can be
	 * returned for any column value.
	 * The limit applies only to BINARY,
	 * VARBINARY, LONGVARBINARY, CHAR, VARCHAR, and LONGVARCHAR
	 * columns.  If the limit is exceeded, the excess data is silently
	 * discarded.
	 *
	 * @return the current max column size limit; zero means unlimited 
	 * @exception SQLException if a database access error occurs
	 */
	public int getMaxFieldSize() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.getMaxFieldSize();
	}




	/**
	 * Retrieves the maximum number of rows that a
	 * ResultSet can contain.  If the limit is exceeded, the excess
	 * rows are silently dropped.
	 *
	 * @return the current max row limit; zero means unlimited
	 * @exception SQLException if a database access error occurs
	 */
	public int getMaxRows() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.getMaxRows();
	}




	/**
	 * JDBC 2.0
	 *
	 * Gets the number, types and properties of a ResultSet's columns.
	 *
	 * @return the description of a ResultSet's columns
	 * @exception SQLException if a database access error occurs
	 */
	public java.sql.ResultSetMetaData getMetaData() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.getMetaData();
	}




	/**
	 * Moves to a Statement's next result.  It returns true if 
	 * this result is a ResultSet.  This method also implicitly
	 * closes any current ResultSet obtained with getResultSet.
	 *
	 * There are no more results when (!getMoreResults() &&
	 * (getUpdateCount() == -1)
	 *
	 * @return true if the next result is a ResultSet; false if it is
	 * an update count or there are no more results
	 * @exception SQLException if a database access error occurs
	 * @see #execute 
	 */
	public boolean getMoreResults() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.getMoreResults();
	}




	/**
	 * Retrieves the number of seconds the driver will
	 * wait for a Statement to execute. If the limit is exceeded, a
	 * SQLException is thrown.
	 *
	 * @return the current query timeout limit in seconds; zero means unlimited 
	 * @exception SQLException if a database access error occurs
	 */
	public int getQueryTimeout() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.getQueryTimeout();
	}




	/**
	 *  Returns the current result as a <code>ResultSet</code> object. 
	 *  This method should be called only once per result.
	 *
	 * @return the current result as a ResultSet; null if the result
	 * is an update count or there are no more results
	 * @exception SQLException if a database access error occurs
	 * @see #execute 
	 */
	public java.sql.ResultSet getResultSet() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.getResultSet();
	}




	/**
	 * JDBC 2.0
	 *
	 * Retrieves the result set concurrency.
	 */
	public int getResultSetConcurrency() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.getResultSetConcurrency();
	}




	/**
	 * JDBC 2.0
	 *
	 * Determine the result set type.
	 */
	public int getResultSetType() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.getResultSetType();
	}




	public String getSqlString()
	{
		return _sSqlString;
	}




	/**
	 *  Returns the current result as an update count;
	 *  if the result is a ResultSet or there are no more results, -1
	 *  is returned. 
	 *  This method should be called only once per result.
	 * 
	 * @return the current result as an update count; -1 if it is a
	 * ResultSet or there are no more results
	 * @exception SQLException if a database access error occurs
	 * @see #execute 
	 */
	public int getUpdateCount() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.getUpdateCount();
	}




	/**
	 * Retrieves the first warning reported by calls on this Statement.
	 * Subsequent Statement warnings will be chained to this
	 * SQLWarning.
	 *
	 * <p>The warning chain is automatically cleared each time
	 * a statement is (re)executed.
	 *
	 * <P><B>Note:</B> If you are processing a ResultSet, any
	 * warnings associated with ResultSet reads will be chained on the
	 * ResultSet object.
	 *
	 * @return the first SQLWarning or null 
	 * @exception SQLException if a database access error occurs
	 */
	public java.sql.SQLWarning getWarnings() throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		return _ps.getWarnings();
	}




	/**
	 * JDBC 2.0
	 *
	 * Sets an Array parameter.
	 *
	 * @param i the first parameter is 1, the second is 2, ...
	 * @param x an object representing an SQL array
	 * @exception SQLException if a database access error occurs
	 */
	public void setArray(int i, java.sql.Array x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setArray(i,x);
	}




	/**
	 * Sets the designated parameter to the given input stream, which will have 
	 * the specified number of bytes.
	 * When a very large ASCII value is input to a LONGVARCHAR
	 * parameter, it may be more practical to send it via a
	 * java.io.InputStream. JDBC will read the data from the stream
	 * as needed, until it reaches end-of-file.  The JDBC driver will
	 * do any necessary conversion from ASCII to the database char format.
	 * 
	 * <P><B>Note:</B> This stream object can either be a standard
	 * Java stream object or your own subclass that implements the
	 * standard interface.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the Java input stream that contains the ASCII parameter value
	 * @param length the number of bytes in the stream 
	 * @exception SQLException if a database access error occurs
	 */
	public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setAsciiStream(parameterIndex,x,length);
	}




	/**
	 * Sets the designated parameter to a java.lang.BigDecimal value.  
	 * The driver converts this to an SQL NUMERIC value when
	 * it sends it to the database.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the parameter value
	 * @exception SQLException if a database access error occurs
	 */
	public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setBigDecimal(parameterIndex,x);
	}




	/**
	 * Sets the designated parameter to the given input stream, which will have 
	 * the specified number of bytes.
	 * When a very large binary value is input to a LONGVARBINARY
	 * parameter, it may be more practical to send it via a
	 * java.io.InputStream. JDBC will read the data from the stream
	 * as needed, until it reaches end-of-file.
	 * 
	 * <P><B>Note:</B> This stream object can either be a standard
	 * Java stream object or your own subclass that implements the
	 * standard interface.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the java input stream which contains the binary parameter value
	 * @param length the number of bytes in the stream 
	 * @exception SQLException if a database access error occurs
	 */
	public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setBinaryStream(parameterIndex,x,length);
		
	}




	/**
	 * JDBC 2.0
	 *
	 * Sets a BLOB parameter.
	 *
	 * @param i the first parameter is 1, the second is 2, ...
	 * @param x an object representing a BLOB
	 * @exception SQLException if a database access error occurs
	 */
	public void setBlob(int i, java.sql.Blob x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setBlob(i,x);
		
	}




	/**
	 * Sets the designated parameter to a Java boolean value.  The driver converts this
	 * to an SQL BIT value when it sends it to the database.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the parameter value
	 * @exception SQLException if a database access error occurs
	 */
	public void setBoolean(int parameterIndex, boolean x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setBoolean(parameterIndex,x);
		
	}




	/**
	 * Sets the designated parameter to a Java byte value.  The driver converts this
	 * to an SQL TINYINT value when it sends it to the database.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the parameter value
	 * @exception SQLException if a database access error occurs
	 */
	public void setByte(int parameterIndex, byte x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setByte(parameterIndex,x);
	}




	/**
	 * Sets the designated parameter to a Java array of bytes.  The driver converts
	 * this to an SQL VARBINARY or LONGVARBINARY (depending on the
	 * argument's size relative to the driver's limits on VARBINARYs)
	 * when it sends it to the database.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the parameter value 
	 * @exception SQLException if a database access error occurs
	 */
	public void setBytes(int parameterIndex, byte[] x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setBytes(parameterIndex,x);
	}




	/**
	 * JDBC 2.0
	 *
	 * Sets the designated parameter to the given <code>Reader</code>
	 * object, which is the given number of characters long.
	 * When a very large UNICODE value is input to a LONGVARCHAR
	 * parameter, it may be more practical to send it via a
	 * java.io.Reader. JDBC will read the data from the stream
	 * as needed, until it reaches end-of-file.  The JDBC driver will
	 * do any necessary conversion from UNICODE to the database char format.
	 * 
	 * <P><B>Note:</B> This stream object can either be a standard
	 * Java stream object or your own subclass that implements the
	 * standard interface.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the java reader which contains the UNICODE data
	 * @param length the number of characters in the stream 
	 * @exception SQLException if a database access error occurs
	 */
	public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setCharacterStream(parameterIndex,reader,length);
		
	}




	/**
	 * JDBC 2.0
	 *
	 * Sets a CLOB parameter.
	 *
	 * @param i the first parameter is 1, the second is 2, ...
	 * @param x an object representing a CLOB
	 * @exception SQLException if a database access error occurs
	 */
	public void setClob(int i, java.sql.Clob x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setClob(i,x);
		
	}




	void setClosed(boolean closed)
	{
		_bClosed = closed;
	}




	/**
	 * Defines the SQL cursor name that will be used by
	 * subsequent Statement <code>execute</code> methods. This name can then be
	 * used in SQL positioned update/delete statements to identify the
	 * current row in the ResultSet generated by this statement.  If
	 * the database doesn't support positioned update/delete, this
	 * method is a noop.  To insure that a cursor has the proper isolation
	 * level to support updates, the cursor's SELECT statement should be
	 * of the form 'select for update ...'. If the 'for update' phrase is 
	 * omitted, positioned updates may fail.
	 *
	 * <P><B>Note:</B> By definition, positioned update/delete
	 * execution must be done by a different Statement than the one
	 * which generated the ResultSet being used for positioning. Also,
	 * cursor names must be unique within a connection.
	 *
	 * @param name the new cursor name, which must be unique within
	 *             a connection
	 * @exception SQLException if a database access error occurs
	 */
	public void setCursorName(String name) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setCursorName(name);
		
	}




	/**
	 * Sets the designated parameter to a java.sql.Date value.  The driver converts this
	 * to an SQL DATE value when it sends it to the database.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the parameter value
	 * @exception SQLException if a database access error occurs
	 */
	public void setDate(int parameterIndex, java.sql.Date x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setDate(parameterIndex,x);
		
	}




	/**
	 * JDBC 2.0
	 *
	 * Sets the designated parameter to a java.sql.Date value,
	 * using the given <code>Calendar</code> object.  The driver uses
	 * the <code>Calendar</code> object to construct an SQL DATE,
	 * which the driver then sends to the database.  With a
	 * a <code>Calendar</code> object, the driver can calculate the date
	 * taking into account a custom timezone and locale.  If no
	 * <code>Calendar</code> object is specified, the driver uses the default
	 * timezone and locale.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the parameter value
	 * @param cal the <code>Calendar</code> object the driver will use
	 *            to construct the date
	 * @exception SQLException if a database access error occurs
	 */
	public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setDate(parameterIndex,x,cal);
	}




	/**
	 * Sets the designated parameter to a Java double value.  The driver converts this
	 * to an SQL DOUBLE value when it sends it to the database.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the parameter value
	 * @exception SQLException if a database access error occurs
	 */
	public void setDouble(int parameterIndex, double x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setDouble(parameterIndex,x);
		
	}




	/**
	 * Sets escape processing on or off.
	 * If escape scanning is on (the default), the driver will do
	 * escape substitution before sending the SQL to the database.
	 *
	 * Note: Since prepared statements have usually been parsed prior
	 * to making this call, disabling escape processing for prepared
	 * statements will have no effect.
	 *
	 * @param enable true to enable; false to disable
	 * @exception SQLException if a database access error occurs
	 */
	public void setEscapeProcessing(boolean enable) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setEscapeProcessing(enable);
		
	}




	/**
	 * JDBC 2.0
	 *
	 * Gives the driver a hint as to the direction in which
	 * the rows in a result set
	 * will be processed. The hint applies only to result sets created 
	 * using this Statement object.  The default value is 
	 * ResultSet.FETCH_FORWARD.
	 * <p>Note that this method sets the default fetch direction for 
	 * result sets generated by this <code>Statement</code> object.
	 * Each result set has its own methods for getting and setting
	 * its own fetch direction.
	 * @param direction the initial direction for processing rows
	 * @exception SQLException if a database access error occurs
	 * or the given direction
	 * is not one of ResultSet.FETCH_FORWARD, ResultSet.FETCH_REVERSE, or
	 * ResultSet.FETCH_UNKNOWN
	 */
	public void setFetchDirection(int direction) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setFetchDirection(direction);
		
	}




	/**
	 * JDBC 2.0
	 *
	 * Gives the JDBC driver a hint as to the number of rows that should 
	 * be fetched from the database when more rows are needed.  The number 
	 * of rows specified affects only result sets created using this 
	 * statement. If the value specified is zero, then the hint is ignored.
	 * The default value is zero.
	 *
	 * @param rows the number of rows to fetch
	 * @exception SQLException if a database access error occurs, or the
	 * condition 0 <= rows <= this.getMaxRows() is not satisfied.
	 */
	public void setFetchSize(int rows) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setFetchSize(rows);
		
	}




	/**
	 * Sets the designated parameter to a Java float value.  The driver converts this
	 * to an SQL FLOAT value when it sends it to the database.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the parameter value
	 * @exception SQLException if a database access error occurs
	 */
	public void setFloat(int parameterIndex, float x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setFloat(parameterIndex,x);
		
	}




	/**
	 * Sets the designated parameter to a Java int value.  The driver converts this
	 * to an SQL INTEGER value when it sends it to the database.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the parameter value
	 * @exception SQLException if a database access error occurs
	 */
	public void setInt(int parameterIndex, int x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setInt(parameterIndex,x);
		
	}




	/**
	 * Sets the designated parameter to a Java long value.  The driver converts this
	 * to an SQL BIGINT value when it sends it to the database.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the parameter value
	 * @exception SQLException if a database access error occurs
	 */
	public void setLong(int parameterIndex, long x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setLong(parameterIndex,x);
		
	}




	/**
	 * Sets the limit for the maximum number of bytes in a column to
	 * the given number of bytes.  This is the maximum number of bytes 
	 * that can be returned for any column value.  This limit applies
	 * only to BINARY, VARBINARY, LONGVARBINARY, CHAR, VARCHAR, and
	 * LONGVARCHAR fields.  If the limit is exceeded, the excess data
	 * is silently discarded. For maximum portability, use values
	 * greater than 256.
	 *
	 * @param max the new max column size limit; zero means unlimited 
	 * @exception SQLException if a database access error occurs
	 */
	public void setMaxFieldSize(int max) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setMaxFieldSize(max);
		
	}




	/**
	 * Sets the limit for the maximum number of rows that any
	 * ResultSet can contain to the given number.
	 * If the limit is exceeded, the excess
	 * rows are silently dropped.
	 *
	 * @param max the new max rows limit; zero means unlimited 
	 * @exception SQLException if a database access error occurs
	 */
	public void setMaxRows(int max) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setMaxRows(max);
		
	}




	/**
	 * Sets the designated parameter to SQL NULL.
	 *
	 * <P><B>Note:</B> You must specify the parameter's SQL type.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param sqlType the SQL type code defined in java.sql.Types
	 * @exception SQLException if a database access error occurs
	 */
	public void setNull(int parameterIndex, int sqlType) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setNull(parameterIndex,sqlType);
		
	}




	/**
	 * JDBC 2.0
	 *
	 * Sets the designated parameter to SQL NULL.  This version of setNull should
	 * be used for user-named types and REF type parameters.  Examples
	 * of user-named types include: STRUCT, DISTINCT, JAVA_OBJECT, and 
	 * named array types.
	 *
	 * <P><B>Note:</B> To be portable, applications must give the
	 * SQL type code and the fully-qualified SQL type name when specifying
	 * a NULL user-defined or REF parameter.  In the case of a user-named type 
	 * the name is the type name of the parameter itself.  For a REF 
	 * parameter the name is the type name of the referenced type.  If 
	 * a JDBC driver does not need the type code or type name information, 
	 * it may ignore it.     
	 *
	 * Although it is intended for user-named and Ref parameters,
	 * this method may be used to set a null parameter of any JDBC type.
	 * If the parameter does not have a user-named or REF type, the given
	 * typeName is ignored.
	 *
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param sqlType a value from java.sql.Types
	 * @param typeName the fully-qualified name of an SQL user-named type,
	 *  ignored if the parameter is not a user-named type or REF 
	 * @exception SQLException if a database access error occurs
	 */
	public void setNull(int paramIndex, int sqlType, String typeName) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setNull(paramIndex,sqlType,typeName);
		
	}




	/**
	 * <p>Sets the value of a parameter using an object; use the
	 * java.lang equivalent objects for integral values.
	 *
	 * <p>The JDBC specification specifies a standard mapping from
	 * Java Object types to SQL types.  The given argument java object
	 * will be converted to the corresponding SQL type before being
	 * sent to the database.
	 *
	 * <p>Note that this method may be used to pass datatabase-
	 * specific abstract data types, by using a Driver-specific Java
	 * type.
	 *
	 * If the object is of a class implementing SQLData,
	 * the JDBC driver should call its method <code>writeSQL</code> to write it 
	 * to the SQL data stream.
	 * If, on the other hand, the object is of a class implementing
	 * Ref, Blob, Clob, Struct, 
	 * or Array, then the driver should pass it to the database as a value of the 
	 * corresponding SQL type.
	 *
	 * This method throws an exception if there is an ambiguity, for example, if the
	 * object is of a class implementing more than one of those interfaces.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the object containing the input parameter value 
	 * @exception SQLException if a database access error occurs
	 */
	public void setObject(int parameterIndex, Object x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setObject(parameterIndex,x);
		
	}




	/**
	 * Sets the value of the designated parameter with the given object.
	 * This method is like setObject above, except that it assumes a scale of zero.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the object containing the input parameter value
	 * @param targetSqlType the SQL type (as defined in java.sql.Types) to be 
	 *                      sent to the database
	 * @exception SQLException if a database access error occurs
	 */
	public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setObject(parameterIndex,x,targetSqlType);
		
	}




	/**
	 * <p>Sets the value of a parameter using an object. The second
	 * argument must be an object type; for integral values, the
	 * java.lang equivalent objects should be used.
	 *
	 * <p>The given Java object will be converted to the targetSqlType
	 * before being sent to the database.
	 *
	 * If the object has a custom mapping (is of a class implementing SQLData),
	 * the JDBC driver should call its method <code>writeSQL</code> to write it 
	 * to the SQL data stream.
	 * If, on the other hand, the object is of a class implementing
	 * Ref, Blob, Clob, Struct, 
	 * or Array, the driver should pass it to the database as a value of the 
	 * corresponding SQL type.
	 *
	 * <p>Note that this method may be used to pass datatabase-
	 * specific abstract data types. 
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the object containing the input parameter value
	 * @param targetSqlType the SQL type (as defined in java.sql.Types) to be 
	 * sent to the database. The scale argument may further qualify this type.
	 * @param scale for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types,
	 *          this is the number of digits after the decimal point.  For all other
	 *          types, this value will be ignored.
	 * @exception SQLException if a database access error occurs
	 * @see Types 
	 */
	public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setObject(parameterIndex,x,targetSqlType,scale);
		
	}




	/**
	 * Sets the number of seconds the driver will
	 * wait for a Statement to execute to the given number of seconds.
	 * If the limit is exceeded, a SQLException is thrown.
	 *
	 * @param seconds the new query timeout limit in seconds; zero means 
	 * unlimited 
	 * @exception SQLException if a database access error occurs
	 */
	public void setQueryTimeout(int seconds) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setQueryTimeout(seconds);
		
	}




	/**
	 * JDBC 2.0
	 *
	 * Sets a REF(&lt;structured-type&gt;) parameter.
	 *
	 * @param i the first parameter is 1, the second is 2, ...
	 * @param x an object representing data of an SQL REF Type
	 * @exception SQLException if a database access error occurs
	 */
	public void setRef(int i, java.sql.Ref x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setRef(i,x);
		
	}




	/**
	 * Sets the designated parameter to a Java short value.  The driver converts this
	 * to an SQL SMALLINT value when it sends it to the database.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the parameter value
	 * @exception SQLException if a database access error occurs
	 */
	public void setShort(int parameterIndex, short x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setShort(parameterIndex,x);
		
	}




	/**
	 * Sets the designated parameter to a Java String value.  The driver converts this
	 * to an SQL VARCHAR or LONGVARCHAR value (depending on the argument's
	 * size relative to the driver's limits on VARCHARs) when it sends
	 * it to the database.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the parameter value
	 * @exception SQLException if a database access error occurs
	 */
	public void setString(int parameterIndex, String x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setString(parameterIndex,x);
		
	}




	/**
	 * Sets the designated parameter to a java.sql.Time value.  The driver converts this
	 * to an SQL TIME value when it sends it to the database.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the parameter value
	 * @exception SQLException if a database access error occurs
	 */
	public void setTime(int parameterIndex, java.sql.Time x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setTime(parameterIndex,x);
		
	}




	/**
	 * JDBC 2.0
	 *
	 * Sets the designated parameter to a java.sql.Time value,
	 * using the given <code>Calendar</code> object.  The driver uses
	 * the <code>Calendar</code> object to construct an SQL TIME,
	 * which the driver then sends to the database.  With a
	 * a <code>Calendar</code> object, the driver can calculate the time
	 * taking into account a custom timezone and locale.  If no
	 * <code>Calendar</code> object is specified, the driver uses the default
	 * timezone and locale.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the parameter value
	 * @param cal the <code>Calendar</code> object the driver will use
	 *            to construct the time
	 * @exception SQLException if a database access error occurs
	 */
	public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setTime(parameterIndex,x,cal);
		
	}




	/**
	 * Sets the designated parameter to a java.sql.Timestamp value.  The driver
	 * converts this to an SQL TIMESTAMP value when it sends it to the
	 * database.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the parameter value 
	 * @exception SQLException if a database access error occurs
	 */
	public void setTimestamp(int parameterIndex, java.sql.Timestamp x) throws java.sql.SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setTimestamp(parameterIndex,x);
		
	}




	/**
	 * JDBC 2.0
	 *
	 * Sets the designated parameter to a java.sql.Timestamp value,
	 * using the given <code>Calendar</code> object.  The driver uses
	 * the <code>Calendar</code> object to construct an SQL TIMESTAMP,
	 * which the driver then sends to the database.  With a
	 * a <code>Calendar</code> object, the driver can calculate the timestamp
	 * taking into account a custom timezone and locale.  If no
	 * <code>Calendar</code> object is specified, the driver uses the default
	 * timezone and locale.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...
	 * @param x the parameter value 
	 * @param cal the <code>Calendar</code> object the driver will use
	 *            to construct the timestamp
	 * @exception SQLException if a database access error occurs
	 */
	public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setTimestamp(parameterIndex,x,cal);
		
	}




	/**
	 * Sets the designated parameter to the given input stream, which will have 
	 * the specified number of bytes.
	 * When a very large UNICODE value is input to a LONGVARCHAR
	 * parameter, it may be more practical to send it via a
	 * java.io.InputStream. JDBC will read the data from the stream
	 * as needed, until it reaches end-of-file.  The JDBC driver will
	 * do any necessary conversion from UNICODE to the database char format.
	 * The byte format of the Unicode stream must be Java UTF-8, as
	 * defined in the Java Virtual Machine Specification.
	 * 
	 * <P><B>Note:</B> This stream object can either be a standard
	 * Java stream object or your own subclass that implements the
	 * standard interface.
	 *
	 * @param parameterIndex the first parameter is 1, the second is 2, ...  
	 * @param x the java input stream which contains the
	 * UNICODE parameter value 
	 * @param length the number of bytes in the stream 
	 * @exception SQLException if a database access error occurs
	 * @deprecated
	 */
	public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException 
	{
		if(_bClosed)
		{
			throw new java.sql.SQLException(SQLEXCEPTION_CLOSED);
		}
		_ps.setUnicodeStream(parameterIndex,x,length);
		
	}
}