/*
Copyright (c) 2003-2009 ITerative Consulting Pty Ltd. All Rights Reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted
provided that the following conditions are met:
o Redistributions of source code must retain the above copyright notice, this list of conditions and
the following disclaimer.
o Redistributions in binary form must reproduce the above copyright notice, this list of conditions
and the following disclaimer in the documentation and/or other materials provided with the distribution.
o This jcTOOL Helper Class software, whether in binary or source form may not be used within,
or to derive, any other product without the specific prior written permission of the copyright holder
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package net.helipilot50.stocktrade.genericdbms;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Connection;
import java.sql.Date;
import java.sql.NClob;
import java.sql.ParameterMetaData;
import java.sql.PreparedStatement;
import java.sql.Ref;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.RowId;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.SQLXML;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Calendar;
import java.util.List;
import javax.sql.rowset.CachedRowSet;
import net.helipilot50.stocktrade.framework.BooleanData;
import net.helipilot50.stocktrade.framework.Constants;
import net.helipilot50.stocktrade.framework.DynamicArray;
import net.helipilot50.stocktrade.framework.LogMgr;
import net.helipilot50.stocktrade.framework.ParameterHolder;
import com.sun.rowset.CachedRowSetImpl;
/**
* Note that this class only supports statements, not callable objects. In particular, it assumes that there will
* only be one result set, and it needs to prepare the statement via prepareStatement, not via prepareCall
* @author Tim
*
*/
public class OfflineStatement implements PreparedStatement {
private abstract class Parameter {
int index;
protected Parameter(int index) {
this.index = index;
}
public abstract void set(PreparedStatement stmnt) throws SQLException;
}
protected static interface StatementWorker {
public void doWork(PreparedStatement statement)throws SQLException;
}
protected static StatementWorker noWorker = new StatementWorker() {
public void doWork(PreparedStatement arg0) throws SQLException {
}
};
private List<Parameter> parameters = new DynamicArray<Parameter>();
private int resultSetType = ResultSet.TYPE_FORWARD_ONLY;
private int resultSetConcurrency = ResultSet.CONCUR_READ_ONLY;
private int resultSetHoldability = ResultSet.HOLD_CURSORS_OVER_COMMIT;
private int fetchDirection = ResultSet.FETCH_FORWARD;
private int fetchSize = 0;
private int maxRows = 0;
private int maxFieldSize = 0;
private int queryTimeout = 0;
private int updateCount = 0;
private boolean escapeProcessing = true;
private String sql;
private String cursorName = null;
private final DBConnectionManager connection;
private ResultSet resultSet;
// JVM 1.6 This field is needed for java 1.6 and above, but is fine to leave there in other JVMs
private boolean isPoolable = false;
/**
* Construct a new offline statement with the passed connection manager to the database
* and the passed SQL.
* <p>
* By default, constructing this class will connect to the database and prepare the
* statement and then discard the prepared statement and release the connection. This
* enables the sql syntax to be verified and if it's invalid a spring database exception
* will be thrown. This functionality can be disabled by setting the prf:db:4:50 flag.
* @param pSQL
* @param pConnMgr
*/
public OfflineStatement(String pSQL, DBConnectionManager pConnMgr) {
this.sql = pSQL;
this.connection = pConnMgr;
// Forte would actually prepare the statement at this point to syntax check it.
// Hence we must do the same and throw an exception if it's invalid.
// To disable this check, set the prf:db:4:50 flag
if (!LogMgr.getInstance().test(Constants.SP_MT_PERFORMANCE,Constants.SP_ST_DB, 4, 50)) {
try {
// To prepare the statement and do nothing, just pass an empty worker
useRealStatement(noWorker);
}
catch (SQLException e) {
throw DBUtilities.translateSQLException(e);
}
}
}
/**
* Connect to the database, prepare the statement and set it up identically to how we should have
* been set up. The return this statement.
* @return
*/
protected void useRealStatement(StatementWorker worker) throws SQLException {
Connection conn = connection.getConnection();
PreparedStatement ps = conn.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
for (Parameter thisParam : parameters) {
if (thisParam != null) {
thisParam.set(ps);
}
}
ps.setFetchDirection(fetchDirection);
ps.setFetchSize(fetchSize);
ps.setMaxRows(maxRows);
ps.setMaxFieldSize(maxFieldSize);
ps.setQueryTimeout(queryTimeout);
if (cursorName != null) {
ps.setCursorName(cursorName);
}
if (!escapeProcessing) {
ps.setEscapeProcessing(false);
}
// JVM 1.6 ps.setPoolable(isPoolable);
try {
worker.doWork(ps);
}
finally {
ps.close();
connection.releaseConnection(conn);
}
}
private void populateResults(PreparedStatement ps, ResultSet rs) throws SQLException {
if (rs == null) {
resultSet = null;
}
else {
CachedRowSet rowSet = new CachedRowSetImpl();
final ResultSetMetaData md = new DelegatingResultSetMetaData(rs.getMetaData()) {
@Override
public int getScale(int column) throws SQLException {
int result = super.getScale(column);
if (result < 0) {
result = 0;
}
return result;
}
};
ResultSet rsNew = new DelegatingResultSet(rs) {
@Override
public ResultSetMetaData getMetaData() throws SQLException {
return md;
}
};
rowSet.populate(rsNew);
resultSet = rowSet;
this.resultSetType = rs.getType();
this.resultSetConcurrency = rs.getConcurrency();
}
}
private void populateResults(PreparedStatement ps, boolean pResultIsResultSet) throws SQLException {
if (pResultIsResultSet) {
ResultSet rs = ps.getResultSet();
this.populateResults(ps, rs);
}
else {
this.updateCount = ps.getUpdateCount();
}
}
public void addBatch() throws SQLException {
throw new UnsupportedOperationException("Unsupported operation addBatch()");
}
public void addBatch(String sql) throws SQLException {
throw new UnsupportedOperationException("Unsupported operation addBatch()");
}
public void cancel() throws SQLException {
// Unsupported, do nothing
}
public void clearBatch() throws SQLException {
throw new UnsupportedOperationException("Unsupported operation addBatch()");
}
public void clearWarnings() throws SQLException {
// Unsupported, statement is already closed so do nothing
}
public Connection getConnection() throws SQLException {
// We have no connection, and we're certainly not going to go and get one just to return it...
return null;
}
public int getFetchDirection() throws SQLException {
return this.fetchDirection;
}
public int getFetchSize() throws SQLException {
return fetchSize;
}
public ResultSet getGeneratedKeys() throws SQLException {
// Unsupported, return null
return null;
}
public boolean isPoolable() throws SQLException {
return isPoolable;
}
public int getMaxFieldSize() throws SQLException {
return maxFieldSize;
}
public int getMaxRows() throws SQLException {
return maxRows;
}
public boolean getMoreResults() throws SQLException {
// Unsupported operation, return false
return false;
}
public boolean getMoreResults(int current) throws SQLException {
// Unsupported operation, return false
return false;
}
public int getQueryTimeout() throws SQLException {
return queryTimeout;
}
public ResultSet getResultSet() throws SQLException {
return this.resultSet;
}
public int getResultSetConcurrency() throws SQLException {
return resultSetConcurrency;
}
public int getResultSetHoldability() throws SQLException {
return resultSetHoldability;
}
public int getResultSetType() throws SQLException {
return resultSetType;
}
public int getUpdateCount() throws SQLException {
return updateCount;
}
public SQLWarning getWarnings() throws SQLException {
// Unsupported operation, return null
return null;
}
public void setCursorName(String name) throws SQLException {
this.cursorName = name;
}
public void setEscapeProcessing(boolean enable) throws SQLException {
this.escapeProcessing = enable;
}
public void setFetchDirection(int direction) throws SQLException {
this.fetchDirection = direction;
}
public void setFetchSize(int rows) throws SQLException {
this.fetchSize = rows;
}
public void setPoolable(boolean poolable) throws SQLException {
this.isPoolable = poolable;
}
public void setMaxFieldSize(int max) throws SQLException {
this.maxFieldSize = max;
}
public void setMaxRows(int max) throws SQLException {
this.maxRows = max;
}
public void setQueryTimeout(int seconds) throws SQLException {
this.queryTimeout = seconds;
}
public void clearParameters() throws SQLException {
parameters.clear();
}
public void close() throws SQLException {
// We're already closed, just discard the result set if any
resultSet = null;
}
public boolean execute() throws SQLException {
final BooleanData result = new BooleanData();
useRealStatement(new StatementWorker() {
public void doWork(PreparedStatement ps) throws SQLException {
result.setValue(ps.execute());
// Now get the results sets and remember them
populateResults(ps, result.getValue());
}
});
return result.getValue();
}
public ResultSet executeQuery() throws SQLException {
useRealStatement(new StatementWorker() {
public void doWork(PreparedStatement ps) throws SQLException {
ResultSet rs = ps.executeQuery();
// Now get the results sets and remember them
populateResults(ps, rs);
}
});
return resultSet;
}
public int executeUpdate() throws SQLException {
useRealStatement(new StatementWorker() {
public void doWork(PreparedStatement ps) throws SQLException {
updateCount = ps.executeUpdate();
}
});
return updateCount;
}
public boolean execute(final String sql) throws SQLException {
final BooleanData result = new BooleanData();
useRealStatement(new StatementWorker() {
public void doWork(PreparedStatement ps) throws SQLException {
result.setValue(ps.execute(sql));
// Now get the results sets and remember them
populateResults(ps, result.getValue());
}
});
return result.getValue();
}
public boolean execute(final String sql, final int autoGeneratedKeys) throws SQLException {
final BooleanData result = new BooleanData();
useRealStatement(new StatementWorker() {
public void doWork(PreparedStatement ps) throws SQLException {
result.setValue(ps.execute(sql, autoGeneratedKeys));
// Now get the results sets and remember them
populateResults(ps, result.getValue());
}
});
return result.getValue();
}
public boolean execute(final String sql, final int[] columnIndexes) throws SQLException {
final BooleanData result = new BooleanData();
useRealStatement(new StatementWorker() {
public void doWork(PreparedStatement ps) throws SQLException {
result.setValue(ps.execute(sql, columnIndexes));
// Now get the results sets and remember them
populateResults(ps, result.getValue());
}
});
return result.getValue();
}
public boolean execute(final String sql, final String[] columnNames) throws SQLException {
final BooleanData result = new BooleanData();
useRealStatement(new StatementWorker() {
public void doWork(PreparedStatement ps) throws SQLException {
result.setValue(ps.execute(sql, columnNames));
// Now get the results sets and remember them
populateResults(ps, result.getValue());
}
});
return result.getValue();
}
public int[] executeBatch() throws SQLException {
throw new UnsupportedOperationException("Unsupported operation executeBatch()");
}
public ResultSet executeQuery(String sql) throws SQLException {
useRealStatement(new StatementWorker() {
public void doWork(PreparedStatement ps) throws SQLException {
ResultSet rs = ps.executeQuery();
// Now get the results sets and remember them
populateResults(ps, rs);
}
});
return resultSet;
}
public int executeUpdate(final String sql) throws SQLException {
useRealStatement(new StatementWorker() {
public void doWork(PreparedStatement ps) throws SQLException {
updateCount = ps.executeUpdate(sql);
}
});
return updateCount;
}
public int executeUpdate(final String sql, final int autoGeneratedKeys) throws SQLException {
useRealStatement(new StatementWorker() {
public void doWork(PreparedStatement ps) throws SQLException {
updateCount = ps.executeUpdate(sql, autoGeneratedKeys);
}
});
return updateCount;
}
public int executeUpdate(final String sql, final int[] columnIndexes) throws SQLException {
useRealStatement(new StatementWorker() {
public void doWork(PreparedStatement ps) throws SQLException {
updateCount = ps.executeUpdate(sql, columnIndexes);
}
});
return updateCount;
}
public int executeUpdate(final String sql, final String[] columnNames) throws SQLException {
useRealStatement(new StatementWorker() {
public void doWork(PreparedStatement ps) throws SQLException {
updateCount = ps.executeUpdate(sql, columnNames);
}
});
return updateCount;
}
public ResultSetMetaData getMetaData() throws SQLException {
if (this.resultSet != null) {
this.resultSet.getMetaData();
}
return null;
}
public ParameterMetaData getParameterMetaData() throws SQLException {
final ParameterHolder result = new ParameterHolder();
useRealStatement(new StatementWorker() {
public void doWork(PreparedStatement ps) throws SQLException {
result.setObject(ps.getParameterMetaData());
}
});
return (ParameterMetaData)result.getObject();
}
public void setArray(int i, Array x) throws SQLException {
class ArrayParameter extends Parameter {
private Array value;
public ArrayParameter(int index, Array b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setArray(index, value); }
}
parameters.set(i, new ArrayParameter(i, x));
}
public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
class AsciiStreamParameter extends Parameter {
private InputStream value;
private int length;
public AsciiStreamParameter(int index, InputStream x, int length) { super(index); this.value = x; this.length = length; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setAsciiStream(index, value, length); }
}
parameters.set(parameterIndex, new AsciiStreamParameter(parameterIndex, x, length));
}
public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
class BigDecimalParameter extends Parameter {
private BigDecimal value;
public BigDecimalParameter(int index, BigDecimal b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setBigDecimal(index, value); }
}
parameters.set(parameterIndex, new BigDecimalParameter(parameterIndex, x));
}
public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
class BinaryStreamParameter extends Parameter {
private InputStream value;
private int length;
public BinaryStreamParameter(int index, InputStream x, int length) { super(index); this.value = x; this.length = length; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setBinaryStream(index, value, length); }
}
parameters.set(parameterIndex, new BinaryStreamParameter(parameterIndex, x, length));
}
public void setBlob(int i, Blob x) throws SQLException {
class BlobParameter extends Parameter {
private Blob value;
public BlobParameter(int index, Blob b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setBlob(index, value); }
}
parameters.set(i, new BlobParameter(i, x));
}
public void setBoolean(int parameterIndex, boolean x) throws SQLException {
class BooleanParameter extends Parameter {
private boolean value;
public BooleanParameter(int index, boolean b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setBoolean(index, value); }
}
parameters.set(parameterIndex, new BooleanParameter(parameterIndex, x));
}
public void setByte(int parameterIndex, byte x) throws SQLException {
class ByteParameter extends Parameter {
private byte value;
public ByteParameter(int index, byte b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setByte(index, value); }
}
parameters.set(parameterIndex, new ByteParameter(parameterIndex, x));
}
public void setBytes(int parameterIndex, byte[] x) throws SQLException {
class BytesParameter extends Parameter {
private byte[] value;
public BytesParameter(int index, byte[] b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setBytes(index, value); }
}
parameters.set(parameterIndex, new BytesParameter(parameterIndex, x));
}
public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
class CharacterStreamParameter extends Parameter {
private Reader value;
private int length;
public CharacterStreamParameter(int index, Reader x, int length) { super(index); this.value = x; this.length = length; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setCharacterStream(index, value, length); }
}
parameters.set(parameterIndex, new CharacterStreamParameter(parameterIndex, reader, length));
}
public void setClob(int i, Clob x) throws SQLException {
class ClobParameter extends Parameter {
private Clob value;
public ClobParameter(int index, Clob b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setClob(index, value); }
}
parameters.set(i, new ClobParameter(i, x));
}
public void setDate(int parameterIndex, Date x) throws SQLException {
class DateParameter extends Parameter {
private Date value;
public DateParameter(int index, Date b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setDate(index, value); }
}
parameters.set(parameterIndex, new DateParameter(parameterIndex, x));
}
public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
class DateParameter extends Parameter {
private Date value;
private Calendar cal;
public DateParameter(int index, Date b, Calendar call) { super(index); this.value = b; this.cal = call; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setDate(index, value, cal); }
}
parameters.set(parameterIndex, new DateParameter(parameterIndex, x, cal));
}
public void setDouble(int parameterIndex, double x) throws SQLException {
class DoubleParameter extends Parameter {
private double value;
public DoubleParameter(int index, double b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setDouble(index, value); }
}
parameters.set(parameterIndex, new DoubleParameter(parameterIndex, x));
}
public void setFloat(int parameterIndex, float x) throws SQLException {
class FloatParameter extends Parameter {
private float value;
public FloatParameter(int index, float b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setFloat(index, value); }
}
parameters.set(parameterIndex, new FloatParameter(parameterIndex, x));
}
public void setInt(int parameterIndex, int x) throws SQLException {
class IntParameter extends Parameter {
private int value;
public IntParameter(int index, int b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setInt(index, value); }
}
parameters.set(parameterIndex, new IntParameter(parameterIndex, x));
}
public void setLong(int parameterIndex, long x) throws SQLException {
class LongParameter extends Parameter {
private long value;
public LongParameter(int index, long b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setLong(index, value); }
}
parameters.set(parameterIndex, new LongParameter(parameterIndex, x));
}
public void setNull(int parameterIndex, int sqlType) throws SQLException {
class NullParameter extends Parameter {
private int value;
public NullParameter(int index, int b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setNull(index, value); }
}
parameters.set(parameterIndex, new NullParameter(parameterIndex, sqlType));
}
public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException {
class NullParameter extends Parameter {
private int value;
private String typeName;
public NullParameter(int index, int b, String typeName) { super(index); this.value = b; this.typeName = typeName;}
public void set(PreparedStatement stmt) throws SQLException { stmt.setNull(index, value, typeName); }
}
parameters.set(paramIndex, new NullParameter(paramIndex, sqlType, typeName));
}
public void setObject(int parameterIndex, Object x) throws SQLException {
class ObjectParameter extends Parameter {
private Object value;
public ObjectParameter(int index, Object b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setObject(index, value); }
}
parameters.set(parameterIndex, new ObjectParameter(parameterIndex, x));
}
public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
class ObjectParameter extends Parameter {
private Object value;
private int targetSqlType;
public ObjectParameter(int index, Object b, int targetSqlType) { super(index); this.value = b; this.targetSqlType = targetSqlType;}
public void set(PreparedStatement stmt) throws SQLException { stmt.setObject(index, value, targetSqlType); }
}
parameters.set(parameterIndex, new ObjectParameter(parameterIndex, x, targetSqlType));
}
public void setObject(int parameterIndex, Object x, int targetSqlType, int scale) throws SQLException {
class ObjectParameter extends Parameter {
private Object value;
private int targetSqlType;
private int scale;
public ObjectParameter(int index, Object b, int targetSqlType, int scale) { super(index); this.value = b; this.targetSqlType = targetSqlType; this.scale = scale;}
public void set(PreparedStatement stmt) throws SQLException { stmt.setObject(index, value, targetSqlType, scale); }
}
parameters.set(parameterIndex, new ObjectParameter(parameterIndex, x, targetSqlType, scale));
}
public void setRef(int i, Ref x) throws SQLException {
class RefParameter extends Parameter {
private Ref value;
public RefParameter(int index, Ref b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setRef(index, value); }
}
parameters.set(i, new RefParameter(i, x));
}
public void setShort(int parameterIndex, short x) throws SQLException {
class ShortParameter extends Parameter {
private short value;
public ShortParameter(int index, short b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setShort(index, value); }
}
parameters.set(parameterIndex, new ShortParameter(parameterIndex, x));
}
public void setString(int parameterIndex, String x) throws SQLException {
class StringParameter extends Parameter {
private String value;
public StringParameter(int index, String b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setString(index, value); }
}
parameters.set(parameterIndex, new StringParameter(parameterIndex, x));
}
public void setTime(int parameterIndex, Time x) throws SQLException {
class TimeParameter extends Parameter {
private Time value;
public TimeParameter(int index, Time b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setTime(index, value); }
}
parameters.set(parameterIndex, new TimeParameter(parameterIndex, x));
}
public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
class TimeParameter extends Parameter {
private Time value;
Calendar cal;
public TimeParameter(int index, Time b, Calendar cal) { super(index); this.value = b; this.cal = cal;}
public void set(PreparedStatement stmt) throws SQLException { stmt.setTime(index, value, cal); }
}
parameters.set(parameterIndex, new TimeParameter(parameterIndex, x, cal));
}
public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
class TimestampParameter extends Parameter {
private Timestamp value;
public TimestampParameter(int index, Timestamp b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setTimestamp(index, value); }
}
parameters.set(parameterIndex, new TimestampParameter(parameterIndex, x));
}
public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
class TimestampParameter extends Parameter {
private Timestamp value;
private Calendar cal;
public TimestampParameter(int index, Timestamp b, Calendar cal) { super(index); this.value = b; this.cal = cal; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setTimestamp(index, value, cal); }
}
parameters.set(parameterIndex, new TimestampParameter(parameterIndex, x, cal));
}
public void setURL(int parameterIndex, URL x) throws SQLException {
class URLParameter extends Parameter {
private URL value;
public URLParameter(int index, URL b) { super(index); this.value = b; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setURL(index, value); }
}
parameters.set(parameterIndex, new URLParameter(parameterIndex, x));
}
public void setUnicodeStream(int parameterIndex, InputStream x, int length) throws SQLException {
class UnicodeStreamParameter extends Parameter {
private InputStream value;
private int length;
public UnicodeStreamParameter(int index, InputStream x, int length) { super(index); this.value = x; this.length = length; }
@SuppressWarnings("deprecation")
public void set(PreparedStatement stmt) throws SQLException { stmt.setUnicodeStream(index, value, length); }
}
parameters.set(parameterIndex, new UnicodeStreamParameter(parameterIndex, x, length));
}
/********** JVM 1.6 Methods *************/
public boolean isClosed() throws SQLException {
return true;
}
public void setAsciiStream(int parameterIndex, InputStream x)
throws SQLException {
class AsciiStreamParameter extends Parameter {
private InputStream value;
public AsciiStreamParameter(int index, InputStream x) { super(index); this.value = x; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setAsciiStream(index, value); }
}
parameters.set(parameterIndex, new AsciiStreamParameter(parameterIndex, x));
}
public void setAsciiStream(int parameterIndex, InputStream x, long length)
throws SQLException {
class AsciiStreamParameter extends Parameter {
private InputStream value;
private long length;
public AsciiStreamParameter(int index, InputStream x, long length) { super(index); this.value = x; this.length = length; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setAsciiStream(index, value, length); }
}
parameters.set(parameterIndex, new AsciiStreamParameter(parameterIndex, x, length));
}
public void setBinaryStream(int parameterIndex, InputStream x)
throws SQLException {
class BinaryStreamParameter extends Parameter {
private InputStream value;
public BinaryStreamParameter(int index, InputStream x) { super(index); this.value = x; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setBinaryStream(index, value); }
}
parameters.set(parameterIndex, new BinaryStreamParameter(parameterIndex, x));
}
public void setBinaryStream(int parameterIndex, InputStream x, long length)
throws SQLException {
class BinaryStreamParameter extends Parameter {
private InputStream value;
private long length;
public BinaryStreamParameter(int index, InputStream x, long length) { super(index); this.value = x; this.length = length; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setBinaryStream(index, value, length); }
}
parameters.set(parameterIndex, new BinaryStreamParameter(parameterIndex, x, length));
}
public void setBlob(int parameterIndex, InputStream inputStream)
throws SQLException {
class BlobParameter extends Parameter {
private InputStream value;
public BlobParameter(int index, InputStream x) { super(index); this.value = x; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setBlob(index, value); }
}
parameters.set(parameterIndex, new BlobParameter(parameterIndex, inputStream));
}
public void setBlob(int parameterIndex, InputStream inputStream, long length)
throws SQLException {
class BlobParameter extends Parameter {
private InputStream value;
private long length;
public BlobParameter(int index, InputStream x, long length) { super(index); this.value = x; this.length = length; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setBlob(index, value, length); }
}
parameters.set(parameterIndex, new BlobParameter(parameterIndex, inputStream, length));
}
public void setCharacterStream(int parameterIndex, Reader reader)
throws SQLException {
class CharacterStreamParameter extends Parameter {
private Reader value;
public CharacterStreamParameter(int index, Reader x) { super(index); this.value = x; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setCharacterStream(index, value); }
}
parameters.set(parameterIndex, new CharacterStreamParameter(parameterIndex, reader));
}
public void setCharacterStream(int parameterIndex, Reader reader,
long length) throws SQLException {
class CharacterStreamParameter extends Parameter {
private Reader value;
private long length;
public CharacterStreamParameter(int index, Reader x, long length) { super(index); this.value = x; this.length = length; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setCharacterStream(index, value, length); }
}
parameters.set(parameterIndex, new CharacterStreamParameter(parameterIndex, reader, length));
}
public void setClob(int parameterIndex, Reader reader) throws SQLException {
class ClobParameter extends Parameter {
private Reader value;
public ClobParameter(int index, Reader x) { super(index); this.value = x; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setClob(index, value); }
}
parameters.set(parameterIndex, new ClobParameter(parameterIndex, reader));
}
public void setClob(int parameterIndex, Reader reader, long length)
throws SQLException {
class ClobParameter extends Parameter {
private Reader value;
private long length;
public ClobParameter(int index, Reader x, long length) { super(index); this.value = x; this.length = length; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setClob(index, value, length); }
}
parameters.set(parameterIndex, new ClobParameter(parameterIndex, reader, length));
}
public void setNCharacterStream(int parameterIndex, Reader value)
throws SQLException {
class NCharacterStreamParameter extends Parameter {
private Reader value;
public NCharacterStreamParameter(int index, Reader x) { super(index); this.value = x; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setNCharacterStream(index, value); }
}
parameters.set(parameterIndex, new NCharacterStreamParameter(parameterIndex, value));
}
public void setNCharacterStream(int parameterIndex, Reader value,
long length) throws SQLException {
class NCharacterStreamParameter extends Parameter {
private Reader value;
private long length;
public NCharacterStreamParameter(int index, Reader x, long length) { super(index); this.value = x; this.length = length; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setCharacterStream(index, value, length); }
}
parameters.set(parameterIndex, new NCharacterStreamParameter(parameterIndex, value, length));
}
public void setNClob(int parameterIndex, Reader reader) throws SQLException {
class NClobParameter extends Parameter {
private Reader value;
public NClobParameter(int index, Reader x) { super(index); this.value = x; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setNClob(index, value); }
}
parameters.set(parameterIndex, new NClobParameter(parameterIndex, reader));
}
public void setNClob(int parameterIndex, Reader reader, long length)
throws SQLException {
class NClobParameter extends Parameter {
private Reader value;
private long length;
public NClobParameter(int index, Reader x, long length) { super(index); this.value = x; this.length = length; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setNClob(index, value, length); }
}
parameters.set(parameterIndex, new NClobParameter(parameterIndex, reader, length));
}
public void setNClob(int parameterIndex, NClob value) throws SQLException {
class NClobParameter extends Parameter {
private NClob value;
public NClobParameter(int index, NClob x) { super(index); this.value = x; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setNClob(index, value); }
}
parameters.set(parameterIndex, new NClobParameter(parameterIndex, value));
}
public void setNString(int parameterIndex, String value)
throws SQLException {
class NStringParameter extends Parameter {
private String value;
public NStringParameter(int index, String x) { super(index); this.value = x; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setNString(index, value); }
}
parameters.set(parameterIndex, new NStringParameter(parameterIndex, value));
}
public void setRowId(int parameterIndex, RowId x) throws SQLException {
class RowIdParameter extends Parameter {
private RowId value;
public RowIdParameter(int index, RowId x) { super(index); this.value = x; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setRowId(index, value); }
}
parameters.set(parameterIndex, new RowIdParameter(parameterIndex, x));
}
public void setSQLXML(int parameterIndex, SQLXML xmlObject)
throws SQLException {
class SQLXMLParameter extends Parameter {
private SQLXML value;
public SQLXMLParameter(int index, SQLXML x) { super(index); this.value = x; }
public void set(PreparedStatement stmt) throws SQLException { stmt.setSQLXML(index, value); }
}
parameters.set(parameterIndex, new SQLXMLParameter(parameterIndex, xmlObject));
}
public boolean isWrapperFor(final Class<?> iface) throws SQLException {
final ParameterHolder isWrapperHolder = new ParameterHolder();
useRealStatement(new StatementWorker() {
public void doWork(PreparedStatement arg0) throws SQLException {
isWrapperHolder.setBoolean(arg0.isWrapperFor(iface));
}
});
return isWrapperHolder.getBoolean();
}
@SuppressWarnings("unchecked")
public <T> T unwrap(final Class<T> iface) throws SQLException {
final ParameterHolder THolder = new ParameterHolder();
useRealStatement(new StatementWorker() {
public void doWork(PreparedStatement arg0) throws SQLException {
THolder.setObject(arg0.unwrap(iface));
}
});
return (T)THolder.getObject();
}
}