User: mulder
Date: 00/10/19 13:01:20
Modified: src/main/org/jboss/minerva/jdbc ResultSetInPool.java
Log:
- Errors in the XA wrapper after the user called close (i.e. during
ejbStore at transaction end) will now propogate and cause the
connection to be dropped if the pool is configured for it.
- If a connection is dropped due to an error, and the pool falls
below the minimum size, a new instance will be created to compensate.
- Oracle DB mapping changed to "Oracle 7". A new "Oracle 8" mapping is
forthcoming. With Oracle 7, you can only have one serialized Java
object per table.
- Pool minimum size cannot be greater than maximum size (unless max is
0 = unlimited).
- Result set wrapper now propogates errors appropriately.
Revision Changes Path
1.3 +772 -130 jboss/src/main/org/jboss/minerva/jdbc/ResultSetInPool.java
Index: ResultSetInPool.java
===================================================================
RCS file:
/products/cvs/ejboss/jboss/src/main/org/jboss/minerva/jdbc/ResultSetInPool.java,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- ResultSetInPool.java 2000/08/30 16:17:05 1.2
+++ ResultSetInPool.java 2000/10/19 20:01:19 1.3
@@ -23,7 +23,7 @@
* Wraps a result set to track the last used time for the owning connection.
* That time is updated every time a navigation action is performed on the
* result set (next, previous, etc.).
- * @version $Revision: 1.2 $
+ * @version $Revision: 1.3 $
* @author Aaron Mulder ([EMAIL PROTECTED])
*/
public class ResultSetInPool implements ResultSet {
@@ -69,34 +69,61 @@
public boolean absolute(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
setLastUsed();
- return impl.absolute(arg0);
+ try {
+ return impl.absolute(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void afterLast() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
setLastUsed();
- impl.afterLast();
+ try {
+ impl.afterLast();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void beforeFirst() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
setLastUsed();
- impl.beforeFirst();
+ try {
+ impl.beforeFirst();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void cancelRowUpdates() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.cancelRowUpdates();
+ try {
+ impl.cancelRowUpdates();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void clearWarnings() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.clearWarnings();
+ try {
+ impl.clearWarnings();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void close() throws SQLException {
if(impl != null) {
- impl.close();
+ try {
+ impl.close();
+ } catch(SQLException e) {}
impl = null;
}
st = null;
@@ -105,627 +132,1242 @@
public void deleteRow() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
setLastUsed();
- impl.deleteRow();
+ try {
+ impl.deleteRow();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public int findColumn(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.findColumn(arg0);
+ try {
+ return impl.findColumn(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public boolean first() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
setLastUsed();
- return impl.first();
+ try {
+ return impl.first();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Array getArray(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getArray(arg0);
+ try {
+ return impl.getArray(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Array getArray(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getArray(arg0);
+ try {
+ return impl.getArray(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public java.io.InputStream getAsciiStream(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getAsciiStream(arg0);
+ try {
+ return impl.getAsciiStream(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public java.io.InputStream getAsciiStream(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getAsciiStream(arg0);
+ try {
+ return impl.getAsciiStream(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public java.math.BigDecimal getBigDecimal(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getBigDecimal(arg0);
+ try {
+ return impl.getBigDecimal(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public java.math.BigDecimal getBigDecimal(int arg0, int arg1) throws
SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getBigDecimal(arg0, arg1);
+ try {
+ return impl.getBigDecimal(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public java.math.BigDecimal getBigDecimal(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getBigDecimal(arg0);
+ try {
+ return impl.getBigDecimal(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public java.math.BigDecimal getBigDecimal(String arg0, int arg1) throws
SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getBigDecimal(arg0, arg1);
+ try {
+ return impl.getBigDecimal(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public java.io.InputStream getBinaryStream(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getBinaryStream(arg0);
+ try {
+ return impl.getBinaryStream(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public java.io.InputStream getBinaryStream(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getBinaryStream(arg0);
+ try {
+ return impl.getBinaryStream(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Blob getBlob(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getBlob(arg0);
+ try {
+ return impl.getBlob(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Blob getBlob(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getBlob(arg0);
+ try {
+ return impl.getBlob(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public boolean getBoolean(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getBoolean(arg0);
+ try {
+ return impl.getBoolean(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public boolean getBoolean(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getBoolean(arg0);
+ try {
+ return impl.getBoolean(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public byte getByte(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getByte(arg0);
+ try {
+ return impl.getByte(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public byte getByte(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getByte(arg0);
+ try {
+ return impl.getByte(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public byte[] getBytes(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getBytes(arg0);
+ try {
+ return impl.getBytes(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public byte[] getBytes(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getBytes(arg0);
+ try {
+ return impl.getBytes(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public java.io.Reader getCharacterStream(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getCharacterStream(arg0);
+ try {
+ return impl.getCharacterStream(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public java.io.Reader getCharacterStream(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getCharacterStream(arg0);
+ try {
+ return impl.getCharacterStream(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Clob getClob(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getClob(arg0);
+ try {
+ return impl.getClob(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Clob getClob(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getClob(arg0);
+ try {
+ return impl.getClob(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public int getConcurrency() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getConcurrency();
+ try {
+ return impl.getConcurrency();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public String getCursorName() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getCursorName();
+ try {
+ return impl.getCursorName();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Date getDate(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getDate(arg0);
+ try {
+ return impl.getDate(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Date getDate(int arg0, java.util.Calendar arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getDate(arg0, arg1);
+ try {
+ return impl.getDate(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Date getDate(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getDate(arg0);
+ try {
+ return impl.getDate(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Date getDate(String arg0, java.util.Calendar arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getDate(arg0, arg1);
+ try {
+ return impl.getDate(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public double getDouble(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getDouble(arg0);
+ try {
+ return impl.getDouble(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public double getDouble(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getDouble(arg0);
+ try {
+ return impl.getDouble(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public int getFetchDirection() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getFetchDirection();
+ try {
+ return impl.getFetchDirection();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public int getFetchSize() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getFetchSize();
+ try {
+ return impl.getFetchSize();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public float getFloat(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getFloat(arg0);
+ try {
+ return impl.getFloat(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public float getFloat(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getFloat(arg0);
+ try {
+ return impl.getFloat(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public int getInt(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getInt(arg0);
+ try {
+ return impl.getInt(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public int getInt(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getInt(arg0);
+ try {
+ return impl.getInt(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public long getLong(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getLong(arg0);
+ try {
+ return impl.getLong(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public long getLong(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getLong(arg0);
+ try {
+ return impl.getLong(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public ResultSetMetaData getMetaData() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getMetaData();
+ try {
+ return impl.getMetaData();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Object getObject(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getObject(arg0);
+ try {
+ return impl.getObject(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Object getObject(int arg0, java.util.Map arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getObject(arg0, arg1);
+ try {
+ return impl.getObject(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Object getObject(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getObject(arg0);
+ try {
+ return impl.getObject(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Object getObject(String arg0, java.util.Map arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getObject(arg0, arg1);
+ try {
+ return impl.getObject(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Ref getRef(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getRef(arg0);
+ try {
+ return impl.getRef(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Ref getRef(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getRef(arg0);
+ try {
+ return impl.getRef(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public int getRow() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getRow();
+ try {
+ return impl.getRow();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public short getShort(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getShort(arg0);
+ try {
+ return impl.getShort(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public short getShort(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getShort(arg0);
+ try {
+ return impl.getShort(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Statement getStatement() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getStatement();
+ try {
+ return impl.getStatement();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public String getString(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getString(arg0);
+ try {
+ return impl.getString(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public String getString(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getString(arg0);
+ try {
+ return impl.getString(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Time getTime(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getTime(arg0);
+ try {
+ return impl.getTime(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Time getTime(int arg0, java.util.Calendar arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getTime(arg0, arg1);
+ try {
+ return impl.getTime(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Time getTime(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getTime(arg0);
+ try {
+ return impl.getTime(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Time getTime(String arg0, java.util.Calendar arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getTime(arg0, arg1);
+ try {
+ return impl.getTime(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Timestamp getTimestamp(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getTimestamp(arg0);
+ try {
+ return impl.getTimestamp(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Timestamp getTimestamp(int arg0, java.util.Calendar arg1) throws
SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getTimestamp(arg0, arg1);
+ try {
+ return impl.getTimestamp(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Timestamp getTimestamp(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getTimestamp(arg0);
+ try {
+ return impl.getTimestamp(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public Timestamp getTimestamp(String arg0, java.util.Calendar arg1) throws
SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getTimestamp(arg0, arg1);
+ try {
+ return impl.getTimestamp(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public int getType() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getType();
+ try {
+ return impl.getType();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public java.io.InputStream getUnicodeStream(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getUnicodeStream(arg0);
+ try {
+ return impl.getUnicodeStream(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public java.io.InputStream getUnicodeStream(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getUnicodeStream(arg0);
+ try {
+ return impl.getUnicodeStream(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public SQLWarning getWarnings() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.getWarnings();
+ try {
+ return impl.getWarnings();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void insertRow() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
setLastUsed();
- impl.insertRow();
+ try {
+ impl.insertRow();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public boolean isAfterLast() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.isAfterLast();
+ try {
+ return impl.isAfterLast();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public boolean isBeforeFirst() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.isBeforeFirst();
+ try {
+ return impl.isBeforeFirst();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public boolean isFirst() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.isFirst();
+ try {
+ return impl.isFirst();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public boolean isLast() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.isLast();
+ try {
+ return impl.isLast();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public boolean last() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
setLastUsed();
- return impl.last();
+ try {
+ return impl.last();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void moveToCurrentRow() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
setLastUsed();
- impl.moveToCurrentRow();
+ try {
+ impl.moveToCurrentRow();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void moveToInsertRow() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
setLastUsed();
- impl.moveToInsertRow();
+ try {
+ impl.moveToInsertRow();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public boolean next() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
setLastUsed();
- return impl.next();
+ try {
+ return impl.next();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public boolean previous() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
setLastUsed();
- return impl.previous();
+ try {
+ return impl.previous();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void refreshRow() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
setLastUsed();
- impl.refreshRow();
+ try {
+ impl.refreshRow();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public boolean relative(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
setLastUsed();
- return impl.relative(arg0);
+ try {
+ return impl.relative(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public boolean rowDeleted() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.rowDeleted();
+ try {
+ return impl.rowDeleted();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public boolean rowInserted() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.rowInserted();
+ try {
+ return impl.rowInserted();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public boolean rowUpdated() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.rowUpdated();
+ try {
+ return impl.rowUpdated();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void setFetchDirection(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.setFetchDirection(arg0);
+ try {
+ impl.setFetchDirection(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void setFetchSize(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.setFetchSize(arg0);
+ try {
+ impl.setFetchSize(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateAsciiStream(int arg0, java.io.InputStream arg1, int arg2)
throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateAsciiStream(arg0, arg1, arg2);
+ try {
+ impl.updateAsciiStream(arg0, arg1, arg2);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateAsciiStream(String arg0, java.io.InputStream arg1, int arg2)
throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateAsciiStream(arg0, arg1, arg2);
+ try {
+ impl.updateAsciiStream(arg0, arg1, arg2);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateBigDecimal(int arg0, java.math.BigDecimal arg1) throws
SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateBigDecimal(arg0, arg1);
+ try {
+ impl.updateBigDecimal(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateBigDecimal(String arg0, java.math.BigDecimal arg1) throws
SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateBigDecimal(arg0, arg1);
+ try {
+ impl.updateBigDecimal(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateBinaryStream(int arg0, java.io.InputStream arg1, int arg2)
throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateBinaryStream(arg0, arg1, arg2);
+ try {
+ impl.updateBinaryStream(arg0, arg1, arg2);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateBinaryStream(String arg0, java.io.InputStream arg1, int arg2)
throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateBinaryStream(arg0, arg1, arg2);
+ try {
+ impl.updateBinaryStream(arg0, arg1, arg2);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateBoolean(int arg0, boolean arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateBoolean(arg0, arg1);
+ try {
+ impl.updateBoolean(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateBoolean(String arg0, boolean arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateBoolean(arg0, arg1);
+ try {
+ impl.updateBoolean(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateByte(int arg0, byte arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateByte(arg0, arg1);
+ try {
+ impl.updateByte(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateByte(String arg0, byte arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateByte(arg0, arg1);
+ try {
+ impl.updateByte(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateBytes(int arg0, byte[] arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateBytes(arg0, arg1);
+ try {
+ impl.updateBytes(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateBytes(String arg0, byte[] arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateBytes(arg0, arg1);
+ try {
+ impl.updateBytes(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateCharacterStream(int arg0, java.io.Reader arg1, int arg2)
throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateCharacterStream(arg0, arg1, arg2);
+ try {
+ impl.updateCharacterStream(arg0, arg1, arg2);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateCharacterStream(String arg0, java.io.Reader arg1, int arg2)
throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateCharacterStream(arg0, arg1, arg2);
+ try {
+ impl.updateCharacterStream(arg0, arg1, arg2);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateDate(int arg0, Date arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateDate(arg0, arg1);
+ try {
+ impl.updateDate(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateDate(String arg0, Date arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateDate(arg0, arg1);
+ try {
+ impl.updateDate(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateDouble(int arg0, double arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateDouble(arg0, arg1);
+ try {
+ impl.updateDouble(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateDouble(String arg0, double arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateDouble(arg0, arg1);
+ try {
+ impl.updateDouble(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateFloat(int arg0, float arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateFloat(arg0, arg1);
+ try {
+ impl.updateFloat(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateFloat(String arg0, float arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateFloat(arg0, arg1);
+ try {
+ impl.updateFloat(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateInt(int arg0, int arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateInt(arg0, arg1);
+ try {
+ impl.updateInt(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateInt(String arg0, int arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateInt(arg0, arg1);
+ try {
+ impl.updateInt(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateLong(int arg0, long arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateLong(arg0, arg1);
+ try {
+ impl.updateLong(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateLong(String arg0, long arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateLong(arg0, arg1);
+ try {
+ impl.updateLong(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateNull(int arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateNull(arg0);
+ try {
+ impl.updateNull(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateNull(String arg0) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateNull(arg0);
+ try {
+ impl.updateNull(arg0);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateObject(int arg0, Object arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateObject(arg0, arg1);
+ try {
+ impl.updateObject(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateObject(int arg0, Object arg1, int arg2) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateObject(arg0, arg1, arg2);
+ try {
+ impl.updateObject(arg0, arg1, arg2);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateObject(String arg0, Object arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateObject(arg0, arg1);
+ try {
+ impl.updateObject(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateObject(String arg0, Object arg1, int arg2) throws
SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateObject(arg0, arg1, arg2);
+ try {
+ impl.updateObject(arg0, arg1, arg2);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateRow() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
setLastUsed();
- impl.updateRow();
+ try {
+ impl.updateRow();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateShort(int arg0, short arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateShort(arg0, arg1);
+ try {
+ impl.updateShort(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateShort(String arg0, short arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateShort(arg0, arg1);
+ try {
+ impl.updateShort(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateString(int arg0, String arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateString(arg0, arg1);
+ try {
+ impl.updateString(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateString(String arg0, String arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateString(arg0, arg1);
+ try {
+ impl.updateString(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateTime(int arg0, Time arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateTime(arg0, arg1);
+ try {
+ impl.updateTime(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateTime(String arg0, Time arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateTime(arg0, arg1);
+ try {
+ impl.updateTime(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateTimestamp(int arg0, Timestamp arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateTimestamp(arg0, arg1);
+ try {
+ impl.updateTimestamp(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public void updateTimestamp(String arg0, Timestamp arg1) throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- impl.updateTimestamp(arg0, arg1);
+ try {
+ impl.updateTimestamp(arg0, arg1);
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
public boolean wasNull() throws SQLException {
if(impl == null) throw new SQLException(CLOSED);
- return impl.wasNull();
+ try {
+ return impl.wasNull();
+ } catch(SQLException e) {
+ setError(e);
+ throw e;
+ }
}
// ---- End Implementation of ResultSet ----
