http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/87266fdb/src/main/java/org/apache/commons/dbcp2/DelegatingResultSet.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/dbcp2/DelegatingResultSet.java
b/src/main/java/org/apache/commons/dbcp2/DelegatingResultSet.java
index 4d90a17..9fdb548 100644
--- a/src/main/java/org/apache/commons/dbcp2/DelegatingResultSet.java
+++ b/src/main/java/org/apache/commons/dbcp2/DelegatingResultSet.java
@@ -59,13 +59,13 @@ import java.util.Map;
public final class DelegatingResultSet extends AbandonedTrace implements
ResultSet {
/** My delegate. **/
- private final ResultSet _res;
+ private final ResultSet resultSet;
/** The Statement that created me, if any. **/
- private Statement _stmt;
+ private Statement statement;
/** The Connection that created me, if any. **/
- private Connection _conn;
+ private Connection connection;
/**
* Create a wrapper for the ResultSet which traces this
@@ -80,8 +80,8 @@ public final class DelegatingResultSet extends AbandonedTrace
implements ResultS
*/
private DelegatingResultSet(final Statement stmt, final ResultSet res) {
super((AbandonedTrace)stmt);
- this._stmt = stmt;
- this._res = res;
+ this.statement = stmt;
+ this.resultSet = res;
}
/**
@@ -97,8 +97,8 @@ public final class DelegatingResultSet extends AbandonedTrace
implements ResultS
*/
private DelegatingResultSet(final Connection conn, final ResultSet res) {
super((AbandonedTrace)conn);
- this._conn = conn;
- this._res = res;
+ this.connection = conn;
+ this.resultSet = res;
}
public static ResultSet wrapResultSet(final Statement stmt, final
ResultSet rset) {
@@ -116,7 +116,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
}
public ResultSet getDelegate() {
- return _res;
+ return resultSet;
}
/**
@@ -135,7 +135,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
* sure to obtain a "genuine" {@link ResultSet}.
*/
public ResultSet getInnermostDelegate() {
- ResultSet r = _res;
+ ResultSet r = resultSet;
while(r != null && r instanceof DelegatingResultSet) {
r = ((DelegatingResultSet)r).getDelegate();
if(this == r) {
@@ -147,7 +147,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public Statement getStatement() throws SQLException {
- return _stmt;
+ return statement;
}
/**
@@ -158,15 +158,15 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void close() throws SQLException {
try {
- if(_stmt != null) {
- ((AbandonedTrace)_stmt).removeTrace(this);
- _stmt = null;
+ if(statement != null) {
+ ((AbandonedTrace)statement).removeTrace(this);
+ statement = null;
}
- if(_conn != null) {
- ((AbandonedTrace)_conn).removeTrace(this);
- _conn = null;
+ if(connection != null) {
+ ((AbandonedTrace)connection).removeTrace(this);
+ connection = null;
}
- _res.close();
+ resultSet.close();
}
catch (final SQLException e) {
handleException(e);
@@ -174,11 +174,11 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
}
protected void handleException(final SQLException e) throws SQLException {
- if (_stmt != null && _stmt instanceof DelegatingStatement) {
- ((DelegatingStatement)_stmt).handleException(e);
+ if (statement != null && statement instanceof DelegatingStatement) {
+ ((DelegatingStatement)statement).handleException(e);
}
- else if (_conn != null && _conn instanceof DelegatingConnection) {
- ((DelegatingConnection<?>)_conn).handleException(e);
+ else if (connection != null && connection instanceof
DelegatingConnection) {
+ ((DelegatingConnection<?>)connection).handleException(e);
}
else {
throw e;
@@ -187,570 +187,570 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public boolean next() throws SQLException
- { try { return _res.next(); } catch (final SQLException e) {
handleException(e); return false; } }
+ { try { return resultSet.next(); } catch (final SQLException e) {
handleException(e); return false; } }
@Override
public boolean wasNull() throws SQLException
- { try { return _res.wasNull(); } catch (final SQLException e) {
handleException(e); return false; } }
+ { try { return resultSet.wasNull(); } catch (final SQLException e) {
handleException(e); return false; } }
@Override
public String getString(final int columnIndex) throws SQLException
- { try { return _res.getString(columnIndex); } catch (final SQLException e)
{ handleException(e); return null; } }
+ { try { return resultSet.getString(columnIndex); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public boolean getBoolean(final int columnIndex) throws SQLException
- { try { return _res.getBoolean(columnIndex); } catch (final SQLException
e) { handleException(e); return false; } }
+ { try { return resultSet.getBoolean(columnIndex); } catch (final
SQLException e) { handleException(e); return false; } }
@Override
public byte getByte(final int columnIndex) throws SQLException
- { try { return _res.getByte(columnIndex); } catch (final SQLException e) {
handleException(e); return 0; } }
+ { try { return resultSet.getByte(columnIndex); } catch (final SQLException
e) { handleException(e); return 0; } }
@Override
public short getShort(final int columnIndex) throws SQLException
- { try { return _res.getShort(columnIndex); } catch (final SQLException e)
{ handleException(e); return 0; } }
+ { try { return resultSet.getShort(columnIndex); } catch (final
SQLException e) { handleException(e); return 0; } }
@Override
public int getInt(final int columnIndex) throws SQLException
- { try { return _res.getInt(columnIndex); } catch (final SQLException e) {
handleException(e); return 0; } }
+ { try { return resultSet.getInt(columnIndex); } catch (final SQLException
e) { handleException(e); return 0; } }
@Override
public long getLong(final int columnIndex) throws SQLException
- { try { return _res.getLong(columnIndex); } catch (final SQLException e) {
handleException(e); return 0; } }
+ { try { return resultSet.getLong(columnIndex); } catch (final SQLException
e) { handleException(e); return 0; } }
@Override
public float getFloat(final int columnIndex) throws SQLException
- { try { return _res.getFloat(columnIndex); } catch (final SQLException e)
{ handleException(e); return 0; } }
+ { try { return resultSet.getFloat(columnIndex); } catch (final
SQLException e) { handleException(e); return 0; } }
@Override
public double getDouble(final int columnIndex) throws SQLException
- { try { return _res.getDouble(columnIndex); } catch (final SQLException e)
{ handleException(e); return 0; } }
+ { try { return resultSet.getDouble(columnIndex); } catch (final
SQLException e) { handleException(e); return 0; } }
/** @deprecated Use {@link #getBigDecimal(int)} */
@Deprecated
@Override
public BigDecimal getBigDecimal(final int columnIndex, final int scale)
throws SQLException
- { try { return _res.getBigDecimal(columnIndex); } catch (final
SQLException e) { handleException(e); return null; } }
+ { try { return resultSet.getBigDecimal(columnIndex); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public byte[] getBytes(final int columnIndex) throws SQLException
- { try { return _res.getBytes(columnIndex); } catch (final SQLException e)
{ handleException(e); return null; } }
+ { try { return resultSet.getBytes(columnIndex); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public Date getDate(final int columnIndex) throws SQLException
- { try { return _res.getDate(columnIndex); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getDate(columnIndex); } catch (final SQLException
e) { handleException(e); return null; } }
@Override
public Time getTime(final int columnIndex) throws SQLException
- { try { return _res.getTime(columnIndex); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getTime(columnIndex); } catch (final SQLException
e) { handleException(e); return null; } }
@Override
public Timestamp getTimestamp(final int columnIndex) throws SQLException
- { try { return _res.getTimestamp(columnIndex); } catch (final SQLException
e) { handleException(e); return null; } }
+ { try { return resultSet.getTimestamp(columnIndex); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public InputStream getAsciiStream(final int columnIndex) throws
SQLException
- { try { return _res.getAsciiStream(columnIndex); } catch (final
SQLException e) { handleException(e); return null; } }
+ { try { return resultSet.getAsciiStream(columnIndex); } catch (final
SQLException e) { handleException(e); return null; } }
/** @deprecated Use {@link #getCharacterStream(int)} */
@Deprecated
@Override
public InputStream getUnicodeStream(final int columnIndex) throws
SQLException
- { try { return _res.getUnicodeStream(columnIndex); } catch (final
SQLException e) { handleException(e); return null; } }
+ { try { return resultSet.getUnicodeStream(columnIndex); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public InputStream getBinaryStream(final int columnIndex) throws
SQLException
- { try { return _res.getBinaryStream(columnIndex); } catch (final
SQLException e) { handleException(e); return null; } }
+ { try { return resultSet.getBinaryStream(columnIndex); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public String getString(final String columnName) throws SQLException
- { try { return _res.getString(columnName); } catch (final SQLException e)
{ handleException(e); return null; } }
+ { try { return resultSet.getString(columnName); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public boolean getBoolean(final String columnName) throws SQLException
- { try { return _res.getBoolean(columnName); } catch (final SQLException e)
{ handleException(e); return false; } }
+ { try { return resultSet.getBoolean(columnName); } catch (final
SQLException e) { handleException(e); return false; } }
@Override
public byte getByte(final String columnName) throws SQLException
- { try { return _res.getByte(columnName); } catch (final SQLException e) {
handleException(e); return 0; } }
+ { try { return resultSet.getByte(columnName); } catch (final SQLException
e) { handleException(e); return 0; } }
@Override
public short getShort(final String columnName) throws SQLException
- { try { return _res.getShort(columnName); } catch (final SQLException e) {
handleException(e); return 0; } }
+ { try { return resultSet.getShort(columnName); } catch (final SQLException
e) { handleException(e); return 0; } }
@Override
public int getInt(final String columnName) throws SQLException
- { try { return _res.getInt(columnName); } catch (final SQLException e) {
handleException(e); return 0; } }
+ { try { return resultSet.getInt(columnName); } catch (final SQLException
e) { handleException(e); return 0; } }
@Override
public long getLong(final String columnName) throws SQLException
- { try { return _res.getLong(columnName); } catch (final SQLException e) {
handleException(e); return 0; } }
+ { try { return resultSet.getLong(columnName); } catch (final SQLException
e) { handleException(e); return 0; } }
@Override
public float getFloat(final String columnName) throws SQLException
- { try { return _res.getFloat(columnName); } catch (final SQLException e) {
handleException(e); return 0; } }
+ { try { return resultSet.getFloat(columnName); } catch (final SQLException
e) { handleException(e); return 0; } }
@Override
public double getDouble(final String columnName) throws SQLException
- { try { return _res.getDouble(columnName); } catch (final SQLException e)
{ handleException(e); return 0; } }
+ { try { return resultSet.getDouble(columnName); } catch (final
SQLException e) { handleException(e); return 0; } }
/** @deprecated Use {@link #getBigDecimal(String)} */
@Deprecated
@Override
public BigDecimal getBigDecimal(final String columnName, final int scale)
throws SQLException
- { try { return _res.getBigDecimal(columnName); } catch (final SQLException
e) { handleException(e); return null; } }
+ { try { return resultSet.getBigDecimal(columnName); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public byte[] getBytes(final String columnName) throws SQLException
- { try { return _res.getBytes(columnName); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getBytes(columnName); } catch (final SQLException
e) { handleException(e); return null; } }
@Override
public Date getDate(final String columnName) throws SQLException
- { try { return _res.getDate(columnName); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getDate(columnName); } catch (final SQLException
e) { handleException(e); return null; } }
@Override
public Time getTime(final String columnName) throws SQLException
- { try { return _res.getTime(columnName); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getTime(columnName); } catch (final SQLException
e) { handleException(e); return null; } }
@Override
public Timestamp getTimestamp(final String columnName) throws SQLException
- { try { return _res.getTimestamp(columnName); } catch (final SQLException
e) { handleException(e); return null; } }
+ { try { return resultSet.getTimestamp(columnName); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public InputStream getAsciiStream(final String columnName) throws
SQLException
- { try { return _res.getAsciiStream(columnName); } catch (final
SQLException e) { handleException(e); return null; } }
+ { try { return resultSet.getAsciiStream(columnName); } catch (final
SQLException e) { handleException(e); return null; } }
/** @deprecated Use {@link #getCharacterStream(String)} */
@Deprecated
@Override
public InputStream getUnicodeStream(final String columnName) throws
SQLException
- { try { return _res.getUnicodeStream(columnName); } catch (final
SQLException e) { handleException(e); return null; } }
+ { try { return resultSet.getUnicodeStream(columnName); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public InputStream getBinaryStream(final String columnName) throws
SQLException
- { try { return _res.getBinaryStream(columnName); } catch (final
SQLException e) { handleException(e); return null; } }
+ { try { return resultSet.getBinaryStream(columnName); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public SQLWarning getWarnings() throws SQLException
- { try { return _res.getWarnings(); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getWarnings(); } catch (final SQLException e) {
handleException(e); return null; } }
@Override
public void clearWarnings() throws SQLException
- { try { _res.clearWarnings(); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.clearWarnings(); } catch (final SQLException e) {
handleException(e); } }
@Override
public String getCursorName() throws SQLException
- { try { return _res.getCursorName(); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getCursorName(); } catch (final SQLException e) {
handleException(e); return null; } }
@Override
public ResultSetMetaData getMetaData() throws SQLException
- { try { return _res.getMetaData(); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getMetaData(); } catch (final SQLException e) {
handleException(e); return null; } }
@Override
public Object getObject(final int columnIndex) throws SQLException
- { try { return _res.getObject(columnIndex); } catch (final SQLException e)
{ handleException(e); return null; } }
+ { try { return resultSet.getObject(columnIndex); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public Object getObject(final String columnName) throws SQLException
- { try { return _res.getObject(columnName); } catch (final SQLException e)
{ handleException(e); return null; } }
+ { try { return resultSet.getObject(columnName); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public int findColumn(final String columnName) throws SQLException
- { try { return _res.findColumn(columnName); } catch (final SQLException e)
{ handleException(e); return 0; } }
+ { try { return resultSet.findColumn(columnName); } catch (final
SQLException e) { handleException(e); return 0; } }
@Override
public Reader getCharacterStream(final int columnIndex) throws SQLException
- { try { return _res.getCharacterStream(columnIndex); } catch (final
SQLException e) { handleException(e); return null; } }
+ { try { return resultSet.getCharacterStream(columnIndex); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public Reader getCharacterStream(final String columnName) throws
SQLException
- { try { return _res.getCharacterStream(columnName); } catch (final
SQLException e) { handleException(e); return null; } }
+ { try { return resultSet.getCharacterStream(columnName); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public BigDecimal getBigDecimal(final int columnIndex) throws SQLException
- { try { return _res.getBigDecimal(columnIndex); } catch (final
SQLException e) { handleException(e); return null; } }
+ { try { return resultSet.getBigDecimal(columnIndex); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public BigDecimal getBigDecimal(final String columnName) throws
SQLException
- { try { return _res.getBigDecimal(columnName); } catch (final SQLException
e) { handleException(e); return null; } }
+ { try { return resultSet.getBigDecimal(columnName); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public boolean isBeforeFirst() throws SQLException
- { try { return _res.isBeforeFirst(); } catch (final SQLException e) {
handleException(e); return false; } }
+ { try { return resultSet.isBeforeFirst(); } catch (final SQLException e) {
handleException(e); return false; } }
@Override
public boolean isAfterLast() throws SQLException
- { try { return _res.isAfterLast(); } catch (final SQLException e) {
handleException(e); return false; } }
+ { try { return resultSet.isAfterLast(); } catch (final SQLException e) {
handleException(e); return false; } }
@Override
public boolean isFirst() throws SQLException
- { try { return _res.isFirst(); } catch (final SQLException e) {
handleException(e); return false; } }
+ { try { return resultSet.isFirst(); } catch (final SQLException e) {
handleException(e); return false; } }
@Override
public boolean isLast() throws SQLException
- { try { return _res.isLast(); } catch (final SQLException e) {
handleException(e); return false; } }
+ { try { return resultSet.isLast(); } catch (final SQLException e) {
handleException(e); return false; } }
@Override
public void beforeFirst() throws SQLException
- { try { _res.beforeFirst(); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.beforeFirst(); } catch (final SQLException e) {
handleException(e); } }
@Override
public void afterLast() throws SQLException
- { try { _res.afterLast(); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.afterLast(); } catch (final SQLException e) {
handleException(e); } }
@Override
public boolean first() throws SQLException
- { try { return _res.first(); } catch (final SQLException e) {
handleException(e); return false; } }
+ { try { return resultSet.first(); } catch (final SQLException e) {
handleException(e); return false; } }
@Override
public boolean last() throws SQLException
- { try { return _res.last(); } catch (final SQLException e) {
handleException(e); return false; } }
+ { try { return resultSet.last(); } catch (final SQLException e) {
handleException(e); return false; } }
@Override
public int getRow() throws SQLException
- { try { return _res.getRow(); } catch (final SQLException e) {
handleException(e); return 0; } }
+ { try { return resultSet.getRow(); } catch (final SQLException e) {
handleException(e); return 0; } }
@Override
public boolean absolute(final int row) throws SQLException
- { try { return _res.absolute(row); } catch (final SQLException e) {
handleException(e); return false; } }
+ { try { return resultSet.absolute(row); } catch (final SQLException e) {
handleException(e); return false; } }
@Override
public boolean relative(final int rows) throws SQLException
- { try { return _res.relative(rows); } catch (final SQLException e) {
handleException(e); return false; } }
+ { try { return resultSet.relative(rows); } catch (final SQLException e) {
handleException(e); return false; } }
@Override
public boolean previous() throws SQLException
- { try { return _res.previous(); } catch (final SQLException e) {
handleException(e); return false; } }
+ { try { return resultSet.previous(); } catch (final SQLException e) {
handleException(e); return false; } }
@Override
public void setFetchDirection(final int direction) throws SQLException
- { try { _res.setFetchDirection(direction); } catch (final SQLException e)
{ handleException(e); } }
+ { try { resultSet.setFetchDirection(direction); } catch (final
SQLException e) { handleException(e); } }
@Override
public int getFetchDirection() throws SQLException
- { try { return _res.getFetchDirection(); } catch (final SQLException e) {
handleException(e); return 0; } }
+ { try { return resultSet.getFetchDirection(); } catch (final SQLException
e) { handleException(e); return 0; } }
@Override
public void setFetchSize(final int rows) throws SQLException
- { try { _res.setFetchSize(rows); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.setFetchSize(rows); } catch (final SQLException e) {
handleException(e); } }
@Override
public int getFetchSize() throws SQLException
- { try { return _res.getFetchSize(); } catch (final SQLException e) {
handleException(e); return 0; } }
+ { try { return resultSet.getFetchSize(); } catch (final SQLException e) {
handleException(e); return 0; } }
@Override
public int getType() throws SQLException
- { try { return _res.getType(); } catch (final SQLException e) {
handleException(e); return 0; } }
+ { try { return resultSet.getType(); } catch (final SQLException e) {
handleException(e); return 0; } }
@Override
public int getConcurrency() throws SQLException
- { try { return _res.getConcurrency(); } catch (final SQLException e) {
handleException(e); return 0; } }
+ { try { return resultSet.getConcurrency(); } catch (final SQLException e)
{ handleException(e); return 0; } }
@Override
public boolean rowUpdated() throws SQLException
- { try { return _res.rowUpdated(); } catch (final SQLException e) {
handleException(e); return false; } }
+ { try { return resultSet.rowUpdated(); } catch (final SQLException e) {
handleException(e); return false; } }
@Override
public boolean rowInserted() throws SQLException
- { try { return _res.rowInserted(); } catch (final SQLException e) {
handleException(e); return false; } }
+ { try { return resultSet.rowInserted(); } catch (final SQLException e) {
handleException(e); return false; } }
@Override
public boolean rowDeleted() throws SQLException
- { try { return _res.rowDeleted(); } catch (final SQLException e) {
handleException(e); return false; } }
+ { try { return resultSet.rowDeleted(); } catch (final SQLException e) {
handleException(e); return false; } }
@Override
public void updateNull(final int columnIndex) throws SQLException
- { try { _res.updateNull(columnIndex); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateNull(columnIndex); } catch (final SQLException e)
{ handleException(e); } }
@Override
public void updateBoolean(final int columnIndex, final boolean x) throws
SQLException
- { try { _res.updateBoolean(columnIndex, x); } catch (final SQLException e)
{ handleException(e); } }
+ { try { resultSet.updateBoolean(columnIndex, x); } catch (final
SQLException e) { handleException(e); } }
@Override
public void updateByte(final int columnIndex, final byte x) throws
SQLException
- { try { _res.updateByte(columnIndex, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateByte(columnIndex, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateShort(final int columnIndex, final short x) throws
SQLException
- { try { _res.updateShort(columnIndex, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateShort(columnIndex, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateInt(final int columnIndex, final int x) throws
SQLException
- { try { _res.updateInt(columnIndex, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateInt(columnIndex, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateLong(final int columnIndex, final long x) throws
SQLException
- { try { _res.updateLong(columnIndex, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateLong(columnIndex, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateFloat(final int columnIndex, final float x) throws
SQLException
- { try { _res.updateFloat(columnIndex, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateFloat(columnIndex, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateDouble(final int columnIndex, final double x) throws
SQLException
- { try { _res.updateDouble(columnIndex, x); } catch (final SQLException e)
{ handleException(e); } }
+ { try { resultSet.updateDouble(columnIndex, x); } catch (final
SQLException e) { handleException(e); } }
@Override
public void updateBigDecimal(final int columnIndex, final BigDecimal x)
throws SQLException
- { try { _res.updateBigDecimal(columnIndex, x); } catch (final SQLException
e) { handleException(e); } }
+ { try { resultSet.updateBigDecimal(columnIndex, x); } catch (final
SQLException e) { handleException(e); } }
@Override
public void updateString(final int columnIndex, final String x) throws
SQLException
- { try { _res.updateString(columnIndex, x); } catch (final SQLException e)
{ handleException(e); } }
+ { try { resultSet.updateString(columnIndex, x); } catch (final
SQLException e) { handleException(e); } }
@Override
public void updateBytes(final int columnIndex, final byte[] x) throws
SQLException
- { try { _res.updateBytes(columnIndex, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateBytes(columnIndex, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateDate(final int columnIndex, final Date x) throws
SQLException
- { try { _res.updateDate(columnIndex, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateDate(columnIndex, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateTime(final int columnIndex, final Time x) throws
SQLException
- { try { _res.updateTime(columnIndex, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateTime(columnIndex, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateTimestamp(final int columnIndex, final Timestamp x)
throws SQLException
- { try { _res.updateTimestamp(columnIndex, x); } catch (final SQLException
e) { handleException(e); } }
+ { try { resultSet.updateTimestamp(columnIndex, x); } catch (final
SQLException e) { handleException(e); } }
@Override
public void updateAsciiStream(final int columnIndex, final InputStream x,
final int length) throws SQLException
- { try { _res.updateAsciiStream(columnIndex, x, length); } catch (final
SQLException e) { handleException(e); } }
+ { try { resultSet.updateAsciiStream(columnIndex, x, length); } catch
(final SQLException e) { handleException(e); } }
@Override
public void updateBinaryStream(final int columnIndex, final InputStream x,
final int length) throws SQLException
- { try { _res.updateBinaryStream(columnIndex, x, length); } catch (final
SQLException e) { handleException(e); } }
+ { try { resultSet.updateBinaryStream(columnIndex, x, length); } catch
(final SQLException e) { handleException(e); } }
@Override
public void updateCharacterStream(final int columnIndex, final Reader x,
final int length) throws SQLException
- { try { _res.updateCharacterStream(columnIndex, x, length); } catch (final
SQLException e) { handleException(e); } }
+ { try { resultSet.updateCharacterStream(columnIndex, x, length); } catch
(final SQLException e) { handleException(e); } }
@Override
public void updateObject(final int columnIndex, final Object x, final int
scale) throws SQLException
- { try { _res.updateObject(columnIndex, x); } catch (final SQLException e)
{ handleException(e); } }
+ { try { resultSet.updateObject(columnIndex, x); } catch (final
SQLException e) { handleException(e); } }
@Override
public void updateObject(final int columnIndex, final Object x) throws
SQLException
- { try { _res.updateObject(columnIndex, x); } catch (final SQLException e)
{ handleException(e); } }
+ { try { resultSet.updateObject(columnIndex, x); } catch (final
SQLException e) { handleException(e); } }
@Override
public void updateNull(final String columnName) throws SQLException
- { try { _res.updateNull(columnName); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateNull(columnName); } catch (final SQLException e) {
handleException(e); } }
@Override
public void updateBoolean(final String columnName, final boolean x) throws
SQLException
- { try { _res.updateBoolean(columnName, x); } catch (final SQLException e)
{ handleException(e); } }
+ { try { resultSet.updateBoolean(columnName, x); } catch (final
SQLException e) { handleException(e); } }
@Override
public void updateByte(final String columnName, final byte x) throws
SQLException
- { try { _res.updateByte(columnName, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateByte(columnName, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateShort(final String columnName, final short x) throws
SQLException
- { try { _res.updateShort(columnName, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateShort(columnName, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateInt(final String columnName, final int x) throws
SQLException
- { try { _res.updateInt(columnName, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateInt(columnName, x); } catch (final SQLException e)
{ handleException(e); } }
@Override
public void updateLong(final String columnName, final long x) throws
SQLException
- { try { _res.updateLong(columnName, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateLong(columnName, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateFloat(final String columnName, final float x) throws
SQLException
- { try { _res.updateFloat(columnName, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateFloat(columnName, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateDouble(final String columnName, final double x) throws
SQLException
- { try { _res.updateDouble(columnName, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateDouble(columnName, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateBigDecimal(final String columnName, final BigDecimal x)
throws SQLException
- { try { _res.updateBigDecimal(columnName, x); } catch (final SQLException
e) { handleException(e); } }
+ { try { resultSet.updateBigDecimal(columnName, x); } catch (final
SQLException e) { handleException(e); } }
@Override
public void updateString(final String columnName, final String x) throws
SQLException
- { try { _res.updateString(columnName, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateString(columnName, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateBytes(final String columnName, final byte[] x) throws
SQLException
- { try { _res.updateBytes(columnName, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateBytes(columnName, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateDate(final String columnName, final Date x) throws
SQLException
- { try { _res.updateDate(columnName, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateDate(columnName, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateTime(final String columnName, final Time x) throws
SQLException
- { try { _res.updateTime(columnName, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateTime(columnName, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateTimestamp(final String columnName, final Timestamp x)
throws SQLException
- { try { _res.updateTimestamp(columnName, x); } catch (final SQLException
e) { handleException(e); } }
+ { try { resultSet.updateTimestamp(columnName, x); } catch (final
SQLException e) { handleException(e); } }
@Override
public void updateAsciiStream(final String columnName, final InputStream
x, final int length) throws SQLException
- { try { _res.updateAsciiStream(columnName, x, length); } catch (final
SQLException e) { handleException(e); } }
+ { try { resultSet.updateAsciiStream(columnName, x, length); } catch (final
SQLException e) { handleException(e); } }
@Override
public void updateBinaryStream(final String columnName, final InputStream
x, final int length) throws SQLException
- { try { _res.updateBinaryStream(columnName, x, length); } catch (final
SQLException e) { handleException(e); } }
+ { try { resultSet.updateBinaryStream(columnName, x, length); } catch
(final SQLException e) { handleException(e); } }
@Override
public void updateCharacterStream(final String columnName, final Reader
reader, final int length) throws SQLException
- { try { _res.updateCharacterStream(columnName, reader, length); } catch
(final SQLException e) { handleException(e); } }
+ { try { resultSet.updateCharacterStream(columnName, reader, length); }
catch (final SQLException e) { handleException(e); } }
@Override
public void updateObject(final String columnName, final Object x, final
int scale) throws SQLException
- { try { _res.updateObject(columnName, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateObject(columnName, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateObject(final String columnName, final Object x) throws
SQLException
- { try { _res.updateObject(columnName, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateObject(columnName, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void insertRow() throws SQLException
- { try { _res.insertRow(); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.insertRow(); } catch (final SQLException e) {
handleException(e); } }
@Override
public void updateRow() throws SQLException
- { try { _res.updateRow(); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateRow(); } catch (final SQLException e) {
handleException(e); } }
@Override
public void deleteRow() throws SQLException
- { try { _res.deleteRow(); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.deleteRow(); } catch (final SQLException e) {
handleException(e); } }
@Override
public void refreshRow() throws SQLException
- { try { _res.refreshRow(); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.refreshRow(); } catch (final SQLException e) {
handleException(e); } }
@Override
public void cancelRowUpdates() throws SQLException
- { try { _res.cancelRowUpdates(); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.cancelRowUpdates(); } catch (final SQLException e) {
handleException(e); } }
@Override
public void moveToInsertRow() throws SQLException
- { try { _res.moveToInsertRow(); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.moveToInsertRow(); } catch (final SQLException e) {
handleException(e); } }
@Override
public void moveToCurrentRow() throws SQLException
- { try { _res.moveToCurrentRow(); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.moveToCurrentRow(); } catch (final SQLException e) {
handleException(e); } }
@Override
public Object getObject(final int i, final Map<String,Class<?>> map)
throws SQLException
- { try { return _res.getObject(i, map); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getObject(i, map); } catch (final SQLException e)
{ handleException(e); return null; } }
@Override
public Ref getRef(final int i) throws SQLException
- { try { return _res.getRef(i); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getRef(i); } catch (final SQLException e) {
handleException(e); return null; } }
@Override
public Blob getBlob(final int i) throws SQLException
- { try { return _res.getBlob(i); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getBlob(i); } catch (final SQLException e) {
handleException(e); return null; } }
@Override
public Clob getClob(final int i) throws SQLException
- { try { return _res.getClob(i); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getClob(i); } catch (final SQLException e) {
handleException(e); return null; } }
@Override
public Array getArray(final int i) throws SQLException
- { try { return _res.getArray(i); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getArray(i); } catch (final SQLException e) {
handleException(e); return null; } }
@Override
public Object getObject(final String colName, final Map<String,Class<?>>
map) throws SQLException
- { try { return _res.getObject(colName, map); } catch (final SQLException
e) { handleException(e); return null; } }
+ { try { return resultSet.getObject(colName, map); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public Ref getRef(final String colName) throws SQLException
- { try { return _res.getRef(colName); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getRef(colName); } catch (final SQLException e) {
handleException(e); return null; } }
@Override
public Blob getBlob(final String colName) throws SQLException
- { try { return _res.getBlob(colName); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getBlob(colName); } catch (final SQLException e)
{ handleException(e); return null; } }
@Override
public Clob getClob(final String colName) throws SQLException
- { try { return _res.getClob(colName); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getClob(colName); } catch (final SQLException e)
{ handleException(e); return null; } }
@Override
public Array getArray(final String colName) throws SQLException
- { try { return _res.getArray(colName); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getArray(colName); } catch (final SQLException e)
{ handleException(e); return null; } }
@Override
public Date getDate(final int columnIndex, final Calendar cal) throws
SQLException
- { try { return _res.getDate(columnIndex, cal); } catch (final SQLException
e) { handleException(e); return null; } }
+ { try { return resultSet.getDate(columnIndex, cal); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public Date getDate(final String columnName, final Calendar cal) throws
SQLException
- { try { return _res.getDate(columnName, cal); } catch (final SQLException
e) { handleException(e); return null; } }
+ { try { return resultSet.getDate(columnName, cal); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public Time getTime(final int columnIndex, final Calendar cal) throws
SQLException
- { try { return _res.getTime(columnIndex, cal); } catch (final SQLException
e) { handleException(e); return null; } }
+ { try { return resultSet.getTime(columnIndex, cal); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public Time getTime(final String columnName, final Calendar cal) throws
SQLException
- { try { return _res.getTime(columnName, cal); } catch (final SQLException
e) { handleException(e); return null; } }
+ { try { return resultSet.getTime(columnName, cal); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public Timestamp getTimestamp(final int columnIndex, final Calendar cal)
throws SQLException
- { try { return _res.getTimestamp(columnIndex, cal); } catch (final
SQLException e) { handleException(e); return null; } }
+ { try { return resultSet.getTimestamp(columnIndex, cal); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public Timestamp getTimestamp(final String columnName, final Calendar cal)
throws SQLException
- { try { return _res.getTimestamp(columnName, cal); } catch (final
SQLException e) { handleException(e); return null; } }
+ { try { return resultSet.getTimestamp(columnName, cal); } catch (final
SQLException e) { handleException(e); return null; } }
@Override
public java.net.URL getURL(final int columnIndex) throws SQLException
- { try { return _res.getURL(columnIndex); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getURL(columnIndex); } catch (final SQLException
e) { handleException(e); return null; } }
@Override
public java.net.URL getURL(final String columnName) throws SQLException
- { try { return _res.getURL(columnName); } catch (final SQLException e) {
handleException(e); return null; } }
+ { try { return resultSet.getURL(columnName); } catch (final SQLException
e) { handleException(e); return null; } }
@Override
public void updateRef(final int columnIndex, final Ref x) throws
SQLException
- { try { _res.updateRef(columnIndex, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateRef(columnIndex, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateRef(final String columnName, final Ref x) throws
SQLException
- { try { _res.updateRef(columnName, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateRef(columnName, x); } catch (final SQLException e)
{ handleException(e); } }
@Override
public void updateBlob(final int columnIndex, final Blob x) throws
SQLException
- { try { _res.updateBlob(columnIndex, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateBlob(columnIndex, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateBlob(final String columnName, final Blob x) throws
SQLException
- { try { _res.updateBlob(columnName, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateBlob(columnName, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateClob(final int columnIndex, final Clob x) throws
SQLException
- { try { _res.updateClob(columnIndex, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateClob(columnIndex, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateClob(final String columnName, final Clob x) throws
SQLException
- { try { _res.updateClob(columnName, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateClob(columnName, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateArray(final int columnIndex, final Array x) throws
SQLException
- { try { _res.updateArray(columnIndex, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateArray(columnIndex, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public void updateArray(final String columnName, final Array x) throws
SQLException
- { try { _res.updateArray(columnName, x); } catch (final SQLException e) {
handleException(e); } }
+ { try { resultSet.updateArray(columnName, x); } catch (final SQLException
e) { handleException(e); } }
@Override
public boolean isWrapperFor(final Class<?> iface) throws SQLException {
if (iface.isAssignableFrom(getClass())) {
return true;
- } else if (iface.isAssignableFrom(_res.getClass())) {
+ } else if (iface.isAssignableFrom(resultSet.getClass())) {
return true;
} else {
- return _res.isWrapperFor(iface);
+ return resultSet.isWrapperFor(iface);
}
}
@@ -758,17 +758,17 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
public <T> T unwrap(final Class<T> iface) throws SQLException {
if (iface.isAssignableFrom(getClass())) {
return iface.cast(this);
- } else if (iface.isAssignableFrom(_res.getClass())) {
- return iface.cast(_res);
+ } else if (iface.isAssignableFrom(resultSet.getClass())) {
+ return iface.cast(resultSet);
} else {
- return _res.unwrap(iface);
+ return resultSet.unwrap(iface);
}
}
@Override
public RowId getRowId(final int columnIndex) throws SQLException {
try {
- return _res.getRowId(columnIndex);
+ return resultSet.getRowId(columnIndex);
}
catch (final SQLException e) {
handleException(e);
@@ -779,7 +779,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public RowId getRowId(final String columnLabel) throws SQLException {
try {
- return _res.getRowId(columnLabel);
+ return resultSet.getRowId(columnLabel);
}
catch (final SQLException e) {
handleException(e);
@@ -790,7 +790,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateRowId(final int columnIndex, final RowId value) throws
SQLException {
try {
- _res.updateRowId(columnIndex, value);
+ resultSet.updateRowId(columnIndex, value);
}
catch (final SQLException e) {
handleException(e);
@@ -800,7 +800,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateRowId(final String columnLabel, final RowId value)
throws SQLException {
try {
- _res.updateRowId(columnLabel, value);
+ resultSet.updateRowId(columnLabel, value);
}
catch (final SQLException e) {
handleException(e);
@@ -810,7 +810,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public int getHoldability() throws SQLException {
try {
- return _res.getHoldability();
+ return resultSet.getHoldability();
}
catch (final SQLException e) {
handleException(e);
@@ -821,7 +821,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public boolean isClosed() throws SQLException {
try {
- return _res.isClosed();
+ return resultSet.isClosed();
}
catch (final SQLException e) {
handleException(e);
@@ -832,7 +832,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateNString(final int columnIndex, final String value)
throws SQLException {
try {
- _res.updateNString(columnIndex, value);
+ resultSet.updateNString(columnIndex, value);
}
catch (final SQLException e) {
handleException(e);
@@ -842,7 +842,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateNString(final String columnLabel, final String value)
throws SQLException {
try {
- _res.updateNString(columnLabel, value);
+ resultSet.updateNString(columnLabel, value);
}
catch (final SQLException e) {
handleException(e);
@@ -852,7 +852,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateNClob(final int columnIndex, final NClob value) throws
SQLException {
try {
- _res.updateNClob(columnIndex, value);
+ resultSet.updateNClob(columnIndex, value);
}
catch (final SQLException e) {
handleException(e);
@@ -862,7 +862,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateNClob(final String columnLabel, final NClob value)
throws SQLException {
try {
- _res.updateNClob(columnLabel, value);
+ resultSet.updateNClob(columnLabel, value);
}
catch (final SQLException e) {
handleException(e);
@@ -872,7 +872,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public NClob getNClob(final int columnIndex) throws SQLException {
try {
- return _res.getNClob(columnIndex);
+ return resultSet.getNClob(columnIndex);
}
catch (final SQLException e) {
handleException(e);
@@ -883,7 +883,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public NClob getNClob(final String columnLabel) throws SQLException {
try {
- return _res.getNClob(columnLabel);
+ return resultSet.getNClob(columnLabel);
}
catch (final SQLException e) {
handleException(e);
@@ -894,7 +894,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public SQLXML getSQLXML(final int columnIndex) throws SQLException {
try {
- return _res.getSQLXML(columnIndex);
+ return resultSet.getSQLXML(columnIndex);
}
catch (final SQLException e) {
handleException(e);
@@ -905,7 +905,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public SQLXML getSQLXML(final String columnLabel) throws SQLException {
try {
- return _res.getSQLXML(columnLabel);
+ return resultSet.getSQLXML(columnLabel);
}
catch (final SQLException e) {
handleException(e);
@@ -916,7 +916,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateSQLXML(final int columnIndex, final SQLXML value) throws
SQLException {
try {
- _res.updateSQLXML(columnIndex, value);
+ resultSet.updateSQLXML(columnIndex, value);
}
catch (final SQLException e) {
handleException(e);
@@ -926,7 +926,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateSQLXML(final String columnLabel, final SQLXML value)
throws SQLException {
try {
- _res.updateSQLXML(columnLabel, value);
+ resultSet.updateSQLXML(columnLabel, value);
}
catch (final SQLException e) {
handleException(e);
@@ -936,7 +936,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public String getNString(final int columnIndex) throws SQLException {
try {
- return _res.getNString(columnIndex);
+ return resultSet.getNString(columnIndex);
}
catch (final SQLException e) {
handleException(e);
@@ -947,7 +947,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public String getNString(final String columnLabel) throws SQLException {
try {
- return _res.getNString(columnLabel);
+ return resultSet.getNString(columnLabel);
}
catch (final SQLException e) {
handleException(e);
@@ -958,7 +958,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public Reader getNCharacterStream(final int columnIndex) throws
SQLException {
try {
- return _res.getNCharacterStream(columnIndex);
+ return resultSet.getNCharacterStream(columnIndex);
}
catch (final SQLException e) {
handleException(e);
@@ -969,7 +969,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public Reader getNCharacterStream(final String columnLabel) throws
SQLException {
try {
- return _res.getNCharacterStream(columnLabel);
+ return resultSet.getNCharacterStream(columnLabel);
}
catch (final SQLException e) {
handleException(e);
@@ -980,7 +980,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateNCharacterStream(final int columnIndex, final Reader
reader, final long length) throws SQLException {
try {
- _res.updateNCharacterStream(columnIndex, reader, length);
+ resultSet.updateNCharacterStream(columnIndex, reader, length);
}
catch (final SQLException e) {
handleException(e);
@@ -990,7 +990,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateNCharacterStream(final String columnLabel, final Reader
reader, final long length) throws SQLException {
try {
- _res.updateNCharacterStream(columnLabel, reader, length);
+ resultSet.updateNCharacterStream(columnLabel, reader, length);
}
catch (final SQLException e) {
handleException(e);
@@ -1000,7 +1000,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateAsciiStream(final int columnIndex, final InputStream
inputStream, final long length) throws SQLException {
try {
- _res.updateAsciiStream(columnIndex, inputStream, length);
+ resultSet.updateAsciiStream(columnIndex, inputStream, length);
}
catch (final SQLException e) {
handleException(e);
@@ -1010,7 +1010,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateBinaryStream(final int columnIndex, final InputStream
inputStream, final long length) throws SQLException {
try {
- _res.updateBinaryStream(columnIndex, inputStream, length);
+ resultSet.updateBinaryStream(columnIndex, inputStream, length);
}
catch (final SQLException e) {
handleException(e);
@@ -1020,7 +1020,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateCharacterStream(final int columnIndex, final Reader
reader, final long length) throws SQLException {
try {
- _res.updateCharacterStream(columnIndex, reader, length);
+ resultSet.updateCharacterStream(columnIndex, reader, length);
}
catch (final SQLException e) {
handleException(e);
@@ -1030,7 +1030,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateAsciiStream(final String columnLabel, final InputStream
inputStream, final long length) throws SQLException {
try {
- _res.updateAsciiStream(columnLabel, inputStream, length);
+ resultSet.updateAsciiStream(columnLabel, inputStream, length);
}
catch (final SQLException e) {
handleException(e);
@@ -1040,7 +1040,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateBinaryStream(final String columnLabel, final InputStream
inputStream, final long length) throws SQLException {
try {
- _res.updateBinaryStream(columnLabel, inputStream, length);
+ resultSet.updateBinaryStream(columnLabel, inputStream, length);
}
catch (final SQLException e) {
handleException(e);
@@ -1050,7 +1050,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateCharacterStream(final String columnLabel, final Reader
reader, final long length) throws SQLException {
try {
- _res.updateCharacterStream(columnLabel, reader, length);
+ resultSet.updateCharacterStream(columnLabel, reader, length);
}
catch (final SQLException e) {
handleException(e);
@@ -1060,7 +1060,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateBlob(final int columnIndex, final InputStream
inputStream, final long length) throws SQLException {
try {
- _res.updateBlob(columnIndex, inputStream, length);
+ resultSet.updateBlob(columnIndex, inputStream, length);
}
catch (final SQLException e) {
handleException(e);
@@ -1070,7 +1070,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateBlob(final String columnLabel, final InputStream
inputStream, final long length) throws SQLException {
try {
- _res.updateBlob(columnLabel, inputStream, length);
+ resultSet.updateBlob(columnLabel, inputStream, length);
}
catch (final SQLException e) {
handleException(e);
@@ -1080,7 +1080,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateClob(final int columnIndex, final Reader reader, final
long length) throws SQLException {
try {
- _res.updateClob(columnIndex, reader, length);
+ resultSet.updateClob(columnIndex, reader, length);
}
catch (final SQLException e) {
handleException(e);
@@ -1090,7 +1090,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateClob(final String columnLabel, final Reader reader,
final long length) throws SQLException {
try {
- _res.updateClob(columnLabel, reader, length);
+ resultSet.updateClob(columnLabel, reader, length);
}
catch (final SQLException e) {
handleException(e);
@@ -1100,7 +1100,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateNClob(final int columnIndex, final Reader reader, final
long length) throws SQLException {
try {
- _res.updateNClob(columnIndex, reader, length);
+ resultSet.updateNClob(columnIndex, reader, length);
}
catch (final SQLException e) {
handleException(e);
@@ -1110,7 +1110,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateNClob(final String columnLabel, final Reader reader,
final long length) throws SQLException {
try {
- _res.updateNClob(columnLabel, reader, length);
+ resultSet.updateNClob(columnLabel, reader, length);
}
catch (final SQLException e) {
handleException(e);
@@ -1120,7 +1120,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateNCharacterStream(final int columnIndex, final Reader
reader) throws SQLException {
try {
- _res.updateNCharacterStream(columnIndex, reader);
+ resultSet.updateNCharacterStream(columnIndex, reader);
}
catch (final SQLException e) {
handleException(e);
@@ -1130,7 +1130,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateNCharacterStream(final String columnLabel, final Reader
reader) throws SQLException {
try {
- _res.updateNCharacterStream(columnLabel, reader);
+ resultSet.updateNCharacterStream(columnLabel, reader);
}
catch (final SQLException e) {
handleException(e);
@@ -1140,7 +1140,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateAsciiStream(final int columnIndex, final InputStream
inputStream) throws SQLException {
try {
- _res.updateAsciiStream(columnIndex, inputStream);
+ resultSet.updateAsciiStream(columnIndex, inputStream);
}
catch (final SQLException e) {
handleException(e);
@@ -1150,7 +1150,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateBinaryStream(final int columnIndex, final InputStream
inputStream) throws SQLException {
try {
- _res.updateBinaryStream(columnIndex, inputStream);
+ resultSet.updateBinaryStream(columnIndex, inputStream);
}
catch (final SQLException e) {
handleException(e);
@@ -1160,7 +1160,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateCharacterStream(final int columnIndex, final Reader
reader) throws SQLException {
try {
- _res.updateCharacterStream(columnIndex, reader);
+ resultSet.updateCharacterStream(columnIndex, reader);
}
catch (final SQLException e) {
handleException(e);
@@ -1170,7 +1170,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateAsciiStream(final String columnLabel, final InputStream
inputStream) throws SQLException {
try {
- _res.updateAsciiStream(columnLabel, inputStream);
+ resultSet.updateAsciiStream(columnLabel, inputStream);
}
catch (final SQLException e) {
handleException(e);
@@ -1180,7 +1180,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateBinaryStream(final String columnLabel, final InputStream
inputStream) throws SQLException {
try {
- _res.updateBinaryStream(columnLabel, inputStream);
+ resultSet.updateBinaryStream(columnLabel, inputStream);
}
catch (final SQLException e) {
handleException(e);
@@ -1190,7 +1190,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateCharacterStream(final String columnLabel, final Reader
reader) throws SQLException {
try {
- _res.updateCharacterStream(columnLabel, reader);
+ resultSet.updateCharacterStream(columnLabel, reader);
}
catch (final SQLException e) {
handleException(e);
@@ -1200,7 +1200,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateBlob(final int columnIndex, final InputStream
inputStream) throws SQLException {
try {
- _res.updateBlob(columnIndex, inputStream);
+ resultSet.updateBlob(columnIndex, inputStream);
}
catch (final SQLException e) {
handleException(e);
@@ -1210,7 +1210,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateBlob(final String columnLabel, final InputStream
inputStream) throws SQLException {
try {
- _res.updateBlob(columnLabel, inputStream);
+ resultSet.updateBlob(columnLabel, inputStream);
}
catch (final SQLException e) {
handleException(e);
@@ -1220,7 +1220,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateClob(final int columnIndex, final Reader reader) throws
SQLException {
try {
- _res.updateClob(columnIndex, reader);
+ resultSet.updateClob(columnIndex, reader);
}
catch (final SQLException e) {
handleException(e);
@@ -1230,7 +1230,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateClob(final String columnLabel, final Reader reader)
throws SQLException {
try {
- _res.updateClob(columnLabel, reader);
+ resultSet.updateClob(columnLabel, reader);
}
catch (final SQLException e) {
handleException(e);
@@ -1240,7 +1240,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateNClob(final int columnIndex, final Reader reader) throws
SQLException {
try {
- _res.updateNClob(columnIndex, reader);
+ resultSet.updateNClob(columnIndex, reader);
}
catch (final SQLException e) {
handleException(e);
@@ -1250,7 +1250,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public void updateNClob(final String columnLabel, final Reader reader)
throws SQLException {
try {
- _res.updateNClob(columnLabel, reader);
+ resultSet.updateNClob(columnLabel, reader);
}
catch (final SQLException e) {
handleException(e);
@@ -1260,7 +1260,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public <T> T getObject(final int columnIndex, final Class<T> type) throws
SQLException {
try {
- return _res.getObject(columnIndex, type);
+ return resultSet.getObject(columnIndex, type);
}
catch (final SQLException e) {
handleException(e);
@@ -1272,7 +1272,7 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
public <T> T getObject(final String columnLabel, final Class<T> type)
throws SQLException {
try {
- return _res.getObject(columnLabel, type);
+ return resultSet.getObject(columnLabel, type);
}
catch (final SQLException e) {
handleException(e);
@@ -1282,6 +1282,6 @@ public final class DelegatingResultSet extends
AbandonedTrace implements ResultS
@Override
public String toString() {
- return super.toString() + "[_res=" + _res + ", _stmt=" + _stmt + ",
_conn=" + _conn + "]";
+ return super.toString() + "[_res=" + resultSet + ", _stmt=" +
statement + ", _conn=" + connection + "]";
}
}
