You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2018/06/12 14:14:22 UTC
[2/4] commons-dbcp git commit: Line length 120.
http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/d5a24430/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 fbfef78..ce44833 100644
--- a/src/main/java/org/apache/commons/dbcp2/DelegatingResultSet.java
+++ b/src/main/java/org/apache/commons/dbcp2/DelegatingResultSet.java
@@ -42,15 +42,12 @@ import java.util.Map;
/**
* A base delegating implementation of {@link ResultSet}.
* <p>
- * All of the methods from the {@link ResultSet} interface
- * simply call the corresponding method on the "delegate"
+ * All of the methods from the {@link ResultSet} interface simply call the corresponding method on the "delegate"
* provided in my constructor.
* </p>
* <p>
- * Extends AbandonedTrace to implement result set tracking and
- * logging of code which created the ResultSet. Tracking the
- * ResultSet ensures that the Statement which created it can
- * close any open ResultSet's on Statement close.
+ * Extends AbandonedTrace to implement result set tracking and logging of code which created the ResultSet. Tracking the
+ * ResultSet ensures that the Statement which created it can close any open ResultSet's on Statement close.
* </p>
*
* @since 2.0
@@ -67,12 +64,10 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
private Connection connection;
/**
- * Creates a wrapper for the ResultSet which traces this
- * ResultSet to the Statement which created it and the
- * code which created it.
+ * Creates a wrapper for the ResultSet which traces this ResultSet to the Statement which created it and the code
+ * which created it.
* <p>
- * Private to ensure all construction is
- * {@link #wrapResultSet(Statement, ResultSet)}
+ * Private to ensure all construction is {@link #wrapResultSet(Statement, ResultSet)}
* </p>
*
* @param statement
@@ -81,25 +76,25 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
* The ResultSet to wrap.
*/
private DelegatingResultSet(final Statement statement, final ResultSet resultSet) {
- super((AbandonedTrace)statement);
+ super((AbandonedTrace) statement);
this.statement = statement;
this.resultSet = resultSet;
}
/**
- * Creates a wrapper for the ResultSet which traces this
- * ResultSet to the Connection which created it (via, for
+ * Creates a wrapper for the ResultSet which traces this ResultSet to the Connection which created it (via, for
* example DatabaseMetadata, and the code which created it.
* <p>
- * Private to ensure all construction is
- * {@link #wrapResultSet(Connection, ResultSet)}
+ * Private to ensure all construction is {@link #wrapResultSet(Connection, ResultSet)}
* </p>
*
- * @param conn Connection which created this ResultSet
- * @param res ResultSet to wrap
+ * @param conn
+ * Connection which created this ResultSet
+ * @param res
+ * ResultSet to wrap
*/
private DelegatingResultSet(final Connection conn, final ResultSet res) {
- super((AbandonedTrace)conn);
+ super((AbandonedTrace) conn);
this.connection = conn;
this.resultSet = res;
}
@@ -146,29 +141,24 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
}
/**
- * If my underlying {@link ResultSet} is not a
- * {@code DelegatingResultSet}, returns it,
- * otherwise recursively invokes this method on
- * my delegate.
+ * If my underlying {@link ResultSet} is not a {@code DelegatingResultSet}, returns it, otherwise recursively
+ * invokes this method on my delegate.
* <p>
- * Hence this method will return the first
- * delegate that is not a {@code DelegatingResultSet},
- * or {@code null} when no non-{@code DelegatingResultSet}
- * delegate can be found by traversing this chain.
+ * Hence this method will return the first delegate that is not a {@code DelegatingResultSet}, or {@code null} when
+ * no non-{@code DelegatingResultSet} delegate can be found by traversing this chain.
* </p>
* <p>
- * This method is useful when you may have nested
- * {@code DelegatingResultSet}s, and you want to make
- * sure to obtain a "genuine" {@link ResultSet}.
+ * This method is useful when you may have nested {@code DelegatingResultSet}s, and you want to make sure to obtain
+ * a "genuine" {@link ResultSet}.
* </p>
*
* @return the innermost delegate.
*/
public ResultSet getInnermostDelegate() {
ResultSet r = resultSet;
- while(r != null && r instanceof DelegatingResultSet) {
- r = ((DelegatingResultSet)r).getDelegate();
- if(this == r) {
+ while (r != null && r instanceof DelegatingResultSet) {
+ r = ((DelegatingResultSet) r).getDelegate();
+ if (this == r) {
return null;
}
}
@@ -181,597 +171,1356 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
}
/**
- * Wrapper for close of ResultSet which removes this
- * result set from being traced then calls close on
- * the original ResultSet.
+ * Wrapper for close of ResultSet which removes this result set from being traced then calls close on the original
+ * ResultSet.
*/
@Override
public void close() throws SQLException {
try {
- if(statement != null) {
- ((AbandonedTrace)statement).removeTrace(this);
+ if (statement != null) {
+ ((AbandonedTrace) statement).removeTrace(this);
statement = null;
}
- if(connection != null) {
- ((AbandonedTrace)connection).removeTrace(this);
+ if (connection != null) {
+ ((AbandonedTrace) connection).removeTrace(this);
connection = null;
}
resultSet.close();
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
protected void handleException(final SQLException e) throws SQLException {
if (statement != null && statement instanceof DelegatingStatement) {
- ((DelegatingStatement)statement).handleException(e);
- }
- else if (connection != null && connection instanceof DelegatingConnection) {
- ((DelegatingConnection<?>)connection).handleException(e);
- }
- else {
+ ((DelegatingStatement) statement).handleException(e);
+ } else if (connection != null && connection instanceof DelegatingConnection) {
+ ((DelegatingConnection<?>) connection).handleException(e);
+ } else {
throw e;
}
}
@Override
- public boolean next() throws SQLException
- { try { return resultSet.next(); } catch (final SQLException e) { handleException(e); return false; } }
+ public boolean next() throws SQLException {
+ try {
+ return resultSet.next();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
- public boolean wasNull() throws SQLException
- { try { return resultSet.wasNull(); } catch (final SQLException e) { handleException(e); return false; } }
+ public boolean wasNull() throws SQLException {
+ try {
+ return resultSet.wasNull();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
- public String getString(final int columnIndex) throws SQLException
- { try { return resultSet.getString(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
+ public String getString(final int columnIndex) throws SQLException {
+ try {
+ return resultSet.getString(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public boolean getBoolean(final int columnIndex) throws SQLException
- { try { return resultSet.getBoolean(columnIndex); } catch (final SQLException e) { handleException(e); return false; } }
+ public boolean getBoolean(final int columnIndex) throws SQLException {
+ try {
+ return resultSet.getBoolean(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
- public byte getByte(final int columnIndex) throws SQLException
- { try { return resultSet.getByte(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
+ public byte getByte(final int columnIndex) throws SQLException {
+ try {
+ return resultSet.getByte(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
+ }
@Override
- public short getShort(final int columnIndex) throws SQLException
- { try { return resultSet.getShort(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
+ public short getShort(final int columnIndex) throws SQLException {
+ try {
+ return resultSet.getShort(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
+ }
@Override
- public int getInt(final int columnIndex) throws SQLException
- { try { return resultSet.getInt(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
+ public int getInt(final int columnIndex) throws SQLException {
+ try {
+ return resultSet.getInt(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
+ }
@Override
- public long getLong(final int columnIndex) throws SQLException
- { try { return resultSet.getLong(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
+ public long getLong(final int columnIndex) throws SQLException {
+ try {
+ return resultSet.getLong(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
+ }
@Override
- public float getFloat(final int columnIndex) throws SQLException
- { try { return resultSet.getFloat(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
+ public float getFloat(final int columnIndex) throws SQLException {
+ try {
+ return resultSet.getFloat(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
+ }
@Override
- public double getDouble(final int columnIndex) throws SQLException
- { try { return resultSet.getDouble(columnIndex); } catch (final SQLException e) { handleException(e); return 0; } }
+ public double getDouble(final int columnIndex) throws SQLException {
+ 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 resultSet.getBigDecimal(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
+ public BigDecimal getBigDecimal(final int columnIndex, final int scale) throws SQLException {
+ try {
+ return resultSet.getBigDecimal(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public byte[] getBytes(final int columnIndex) throws SQLException
- { try { return resultSet.getBytes(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
+ public byte[] getBytes(final int columnIndex) throws SQLException {
+ try {
+ return resultSet.getBytes(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public Date getDate(final int columnIndex) throws SQLException
- { try { return resultSet.getDate(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
+ public Date getDate(final int columnIndex) throws SQLException {
+ try {
+ return resultSet.getDate(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public Time getTime(final int columnIndex) throws SQLException
- { try { return resultSet.getTime(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
+ public Time getTime(final int columnIndex) throws SQLException {
+ try {
+ return resultSet.getTime(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public Timestamp getTimestamp(final int columnIndex) throws SQLException
- { try { return resultSet.getTimestamp(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
+ public Timestamp getTimestamp(final int columnIndex) throws SQLException {
+ try {
+ return resultSet.getTimestamp(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public InputStream getAsciiStream(final int columnIndex) throws SQLException
- { try { return resultSet.getAsciiStream(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
+ public InputStream getAsciiStream(final int columnIndex) throws SQLException {
+ 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 resultSet.getUnicodeStream(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
+ public InputStream getUnicodeStream(final int columnIndex) throws SQLException {
+ try {
+ return resultSet.getUnicodeStream(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public InputStream getBinaryStream(final int columnIndex) throws SQLException
- { try { return resultSet.getBinaryStream(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
+ public InputStream getBinaryStream(final int columnIndex) throws SQLException {
+ try {
+ return resultSet.getBinaryStream(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public String getString(final String columnName) throws SQLException
- { try { return resultSet.getString(columnName); } catch (final SQLException e) { handleException(e); return null; } }
+ public String getString(final String columnName) throws SQLException {
+ try {
+ return resultSet.getString(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public boolean getBoolean(final String columnName) throws SQLException
- { try { return resultSet.getBoolean(columnName); } catch (final SQLException e) { handleException(e); return false; } }
+ public boolean getBoolean(final String columnName) throws SQLException {
+ try {
+ return resultSet.getBoolean(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
- public byte getByte(final String columnName) throws SQLException
- { try { return resultSet.getByte(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
+ public byte getByte(final String columnName) throws SQLException {
+ try {
+ return resultSet.getByte(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
+ }
@Override
- public short getShort(final String columnName) throws SQLException
- { try { return resultSet.getShort(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
+ public short getShort(final String columnName) throws SQLException {
+ try {
+ return resultSet.getShort(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
+ }
@Override
- public int getInt(final String columnName) throws SQLException
- { try { return resultSet.getInt(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
+ public int getInt(final String columnName) throws SQLException {
+ try {
+ return resultSet.getInt(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
+ }
@Override
- public long getLong(final String columnName) throws SQLException
- { try { return resultSet.getLong(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
+ public long getLong(final String columnName) throws SQLException {
+ try {
+ return resultSet.getLong(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
+ }
@Override
- public float getFloat(final String columnName) throws SQLException
- { try { return resultSet.getFloat(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
+ public float getFloat(final String columnName) throws SQLException {
+ try {
+ return resultSet.getFloat(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
+ }
@Override
- public double getDouble(final String columnName) throws SQLException
- { try { return resultSet.getDouble(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
+ public double getDouble(final String columnName) throws SQLException {
+ 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 resultSet.getBigDecimal(columnName); } catch (final SQLException e) { handleException(e); return null; } }
+ public BigDecimal getBigDecimal(final String columnName, final int scale) throws SQLException {
+ try {
+ return resultSet.getBigDecimal(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public byte[] getBytes(final String columnName) throws SQLException
- { try { return resultSet.getBytes(columnName); } catch (final SQLException e) { handleException(e); return null; } }
+ public byte[] getBytes(final String columnName) throws SQLException {
+ try {
+ return resultSet.getBytes(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public Date getDate(final String columnName) throws SQLException
- { try { return resultSet.getDate(columnName); } catch (final SQLException e) { handleException(e); return null; } }
+ public Date getDate(final String columnName) throws SQLException {
+ try {
+ return resultSet.getDate(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public Time getTime(final String columnName) throws SQLException
- { try { return resultSet.getTime(columnName); } catch (final SQLException e) { handleException(e); return null; } }
+ public Time getTime(final String columnName) throws SQLException {
+ try {
+ return resultSet.getTime(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public Timestamp getTimestamp(final String columnName) throws SQLException
- { try { return resultSet.getTimestamp(columnName); } catch (final SQLException e) { handleException(e); return null; } }
+ public Timestamp getTimestamp(final String columnName) throws SQLException {
+ try {
+ return resultSet.getTimestamp(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public InputStream getAsciiStream(final String columnName) throws SQLException
- { try { return resultSet.getAsciiStream(columnName); } catch (final SQLException e) { handleException(e); return null; } }
+ public InputStream getAsciiStream(final String columnName) throws SQLException {
+ 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 resultSet.getUnicodeStream(columnName); } catch (final SQLException e) { handleException(e); return null; } }
+ public InputStream getUnicodeStream(final String columnName) throws SQLException {
+ try {
+ return resultSet.getUnicodeStream(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public InputStream getBinaryStream(final String columnName) throws SQLException
- { try { return resultSet.getBinaryStream(columnName); } catch (final SQLException e) { handleException(e); return null; } }
+ public InputStream getBinaryStream(final String columnName) throws SQLException {
+ try {
+ return resultSet.getBinaryStream(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public SQLWarning getWarnings() throws SQLException
- { try { return resultSet.getWarnings(); } catch (final SQLException e) { handleException(e); return null; } }
+ public SQLWarning getWarnings() throws SQLException {
+ try {
+ return resultSet.getWarnings();
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public void clearWarnings() throws SQLException
- { try { resultSet.clearWarnings(); } catch (final SQLException e) { handleException(e); } }
+ public void clearWarnings() throws SQLException {
+ try {
+ resultSet.clearWarnings();
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public String getCursorName() throws SQLException
- { try { return resultSet.getCursorName(); } catch (final SQLException e) { handleException(e); return null; } }
+ public String getCursorName() throws SQLException {
+ try {
+ return resultSet.getCursorName();
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public ResultSetMetaData getMetaData() throws SQLException
- { try { return resultSet.getMetaData(); } catch (final SQLException e) { handleException(e); return null; } }
+ public ResultSetMetaData getMetaData() throws SQLException {
+ try {
+ return resultSet.getMetaData();
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public Object getObject(final int columnIndex) throws SQLException
- { try { return resultSet.getObject(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
+ public Object getObject(final int columnIndex) throws SQLException {
+ try {
+ return resultSet.getObject(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public Object getObject(final String columnName) throws SQLException
- { try { return resultSet.getObject(columnName); } catch (final SQLException e) { handleException(e); return null; } }
+ public Object getObject(final String columnName) throws SQLException {
+ try {
+ return resultSet.getObject(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public int findColumn(final String columnName) throws SQLException
- { try { return resultSet.findColumn(columnName); } catch (final SQLException e) { handleException(e); return 0; } }
+ public int findColumn(final String columnName) throws SQLException {
+ try {
+ return resultSet.findColumn(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
+ }
@Override
- public Reader getCharacterStream(final int columnIndex) throws SQLException
- { try { return resultSet.getCharacterStream(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
+ public Reader getCharacterStream(final int columnIndex) throws SQLException {
+ try {
+ return resultSet.getCharacterStream(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public Reader getCharacterStream(final String columnName) throws SQLException
- { try { return resultSet.getCharacterStream(columnName); } catch (final SQLException e) { handleException(e); return null; } }
+ public Reader getCharacterStream(final String columnName) throws SQLException {
+ try {
+ return resultSet.getCharacterStream(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public BigDecimal getBigDecimal(final int columnIndex) throws SQLException
- { try { return resultSet.getBigDecimal(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
+ public BigDecimal getBigDecimal(final int columnIndex) throws SQLException {
+ try {
+ return resultSet.getBigDecimal(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public BigDecimal getBigDecimal(final String columnName) throws SQLException
- { try { return resultSet.getBigDecimal(columnName); } catch (final SQLException e) { handleException(e); return null; } }
+ public BigDecimal getBigDecimal(final String columnName) throws SQLException {
+ try {
+ return resultSet.getBigDecimal(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public boolean isBeforeFirst() throws SQLException
- { try { return resultSet.isBeforeFirst(); } catch (final SQLException e) { handleException(e); return false; } }
+ public boolean isBeforeFirst() throws SQLException {
+ try {
+ return resultSet.isBeforeFirst();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
- public boolean isAfterLast() throws SQLException
- { try { return resultSet.isAfterLast(); } catch (final SQLException e) { handleException(e); return false; } }
+ public boolean isAfterLast() throws SQLException {
+ try {
+ return resultSet.isAfterLast();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
- public boolean isFirst() throws SQLException
- { try { return resultSet.isFirst(); } catch (final SQLException e) { handleException(e); return false; } }
+ public boolean isFirst() throws SQLException {
+ try {
+ return resultSet.isFirst();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
- public boolean isLast() throws SQLException
- { try { return resultSet.isLast(); } catch (final SQLException e) { handleException(e); return false; } }
+ public boolean isLast() throws SQLException {
+ try {
+ return resultSet.isLast();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
- public void beforeFirst() throws SQLException
- { try { resultSet.beforeFirst(); } catch (final SQLException e) { handleException(e); } }
+ public void beforeFirst() throws SQLException {
+ try {
+ resultSet.beforeFirst();
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void afterLast() throws SQLException
- { try { resultSet.afterLast(); } catch (final SQLException e) { handleException(e); } }
+ public void afterLast() throws SQLException {
+ try {
+ resultSet.afterLast();
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public boolean first() throws SQLException
- { try { return resultSet.first(); } catch (final SQLException e) { handleException(e); return false; } }
+ public boolean first() throws SQLException {
+ try {
+ return resultSet.first();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
- public boolean last() throws SQLException
- { try { return resultSet.last(); } catch (final SQLException e) { handleException(e); return false; } }
+ public boolean last() throws SQLException {
+ try {
+ return resultSet.last();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
- public int getRow() throws SQLException
- { try { return resultSet.getRow(); } catch (final SQLException e) { handleException(e); return 0; } }
+ public int getRow() throws SQLException {
+ try {
+ return resultSet.getRow();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
+ }
@Override
- public boolean absolute(final int row) throws SQLException
- { try { return resultSet.absolute(row); } catch (final SQLException e) { handleException(e); return false; } }
+ public boolean absolute(final int row) throws SQLException {
+ try {
+ return resultSet.absolute(row);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
- public boolean relative(final int rows) throws SQLException
- { try { return resultSet.relative(rows); } catch (final SQLException e) { handleException(e); return false; } }
+ public boolean relative(final int rows) throws SQLException {
+ try {
+ return resultSet.relative(rows);
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
- public boolean previous() throws SQLException
- { try { return resultSet.previous(); } catch (final SQLException e) { handleException(e); return false; } }
+ public boolean previous() throws SQLException {
+ try {
+ return resultSet.previous();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
- public void setFetchDirection(final int direction) throws SQLException
- { try { resultSet.setFetchDirection(direction); } catch (final SQLException e) { handleException(e); } }
+ public void setFetchDirection(final int direction) throws SQLException {
+ try {
+ resultSet.setFetchDirection(direction);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public int getFetchDirection() throws SQLException
- { try { return resultSet.getFetchDirection(); } catch (final SQLException e) { handleException(e); return 0; } }
+ public int getFetchDirection() throws SQLException {
+ try {
+ return resultSet.getFetchDirection();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
+ }
@Override
- public void setFetchSize(final int rows) throws SQLException
- { try { resultSet.setFetchSize(rows); } catch (final SQLException e) { handleException(e); } }
+ public void setFetchSize(final int rows) throws SQLException {
+ try {
+ resultSet.setFetchSize(rows);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public int getFetchSize() throws SQLException
- { try { return resultSet.getFetchSize(); } catch (final SQLException e) { handleException(e); return 0; } }
+ public int getFetchSize() throws SQLException {
+ try {
+ return resultSet.getFetchSize();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
+ }
@Override
- public int getType() throws SQLException
- { try { return resultSet.getType(); } catch (final SQLException e) { handleException(e); return 0; } }
+ public int getType() throws SQLException {
+ try {
+ return resultSet.getType();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
+ }
@Override
- public int getConcurrency() throws SQLException
- { try { return resultSet.getConcurrency(); } catch (final SQLException e) { handleException(e); return 0; } }
+ public int getConcurrency() throws SQLException {
+ try {
+ return resultSet.getConcurrency();
+ } catch (final SQLException e) {
+ handleException(e);
+ return 0;
+ }
+ }
@Override
- public boolean rowUpdated() throws SQLException
- { try { return resultSet.rowUpdated(); } catch (final SQLException e) { handleException(e); return false; } }
+ public boolean rowUpdated() throws SQLException {
+ try {
+ return resultSet.rowUpdated();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
- public boolean rowInserted() throws SQLException
- { try { return resultSet.rowInserted(); } catch (final SQLException e) { handleException(e); return false; } }
+ public boolean rowInserted() throws SQLException {
+ try {
+ return resultSet.rowInserted();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
- public boolean rowDeleted() throws SQLException
- { try { return resultSet.rowDeleted(); } catch (final SQLException e) { handleException(e); return false; } }
+ public boolean rowDeleted() throws SQLException {
+ try {
+ return resultSet.rowDeleted();
+ } catch (final SQLException e) {
+ handleException(e);
+ return false;
+ }
+ }
@Override
- public void updateNull(final int columnIndex) throws SQLException
- { try { resultSet.updateNull(columnIndex); } catch (final SQLException e) { handleException(e); } }
+ public void updateNull(final int columnIndex) throws SQLException {
+ try {
+ resultSet.updateNull(columnIndex);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateBoolean(final int columnIndex, final boolean x) throws SQLException
- { try { resultSet.updateBoolean(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateBoolean(final int columnIndex, final boolean x) throws SQLException {
+ try {
+ resultSet.updateBoolean(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateByte(final int columnIndex, final byte x) throws SQLException
- { try { resultSet.updateByte(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateByte(final int columnIndex, final byte x) throws SQLException {
+ try {
+ resultSet.updateByte(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateShort(final int columnIndex, final short x) throws SQLException
- { try { resultSet.updateShort(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateShort(final int columnIndex, final short x) throws SQLException {
+ try {
+ resultSet.updateShort(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateInt(final int columnIndex, final int x) throws SQLException
- { try { resultSet.updateInt(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateInt(final int columnIndex, final int x) throws SQLException {
+ try {
+ resultSet.updateInt(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateLong(final int columnIndex, final long x) throws SQLException
- { try { resultSet.updateLong(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateLong(final int columnIndex, final long x) throws SQLException {
+ try {
+ resultSet.updateLong(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateFloat(final int columnIndex, final float x) throws SQLException
- { try { resultSet.updateFloat(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateFloat(final int columnIndex, final float x) throws SQLException {
+ try {
+ resultSet.updateFloat(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateDouble(final int columnIndex, final double x) throws SQLException
- { try { resultSet.updateDouble(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateDouble(final int columnIndex, final double x) throws SQLException {
+ try {
+ resultSet.updateDouble(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateBigDecimal(final int columnIndex, final BigDecimal x) throws SQLException
- { try { resultSet.updateBigDecimal(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateBigDecimal(final int columnIndex, final BigDecimal x) throws SQLException {
+ try {
+ resultSet.updateBigDecimal(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateString(final int columnIndex, final String x) throws SQLException
- { try { resultSet.updateString(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateString(final int columnIndex, final String x) throws SQLException {
+ try {
+ resultSet.updateString(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateBytes(final int columnIndex, final byte[] x) throws SQLException
- { try { resultSet.updateBytes(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateBytes(final int columnIndex, final byte[] x) throws SQLException {
+ try {
+ resultSet.updateBytes(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateDate(final int columnIndex, final Date x) throws SQLException
- { try { resultSet.updateDate(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateDate(final int columnIndex, final Date x) throws SQLException {
+ try {
+ resultSet.updateDate(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateTime(final int columnIndex, final Time x) throws SQLException
- { try { resultSet.updateTime(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateTime(final int columnIndex, final Time x) throws SQLException {
+ try {
+ resultSet.updateTime(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateTimestamp(final int columnIndex, final Timestamp x) throws SQLException
- { try { resultSet.updateTimestamp(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateTimestamp(final int columnIndex, final Timestamp x) throws SQLException {
+ 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 { resultSet.updateAsciiStream(columnIndex, x, length); } catch (final SQLException e) { handleException(e); } }
+ public void updateAsciiStream(final int columnIndex, final InputStream x, final int length) throws SQLException {
+ 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 { resultSet.updateBinaryStream(columnIndex, x, length); } catch (final SQLException e) { handleException(e); } }
+ public void updateBinaryStream(final int columnIndex, final InputStream x, final int length) throws SQLException {
+ 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 { resultSet.updateCharacterStream(columnIndex, x, length); } catch (final SQLException e) { handleException(e); } }
+ public void updateCharacterStream(final int columnIndex, final Reader x, final int length) throws SQLException {
+ 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 { resultSet.updateObject(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateObject(final int columnIndex, final Object x, final int scale) throws SQLException {
+ try {
+ resultSet.updateObject(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateObject(final int columnIndex, final Object x) throws SQLException
- { try { resultSet.updateObject(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateObject(final int columnIndex, final Object x) throws SQLException {
+ try {
+ resultSet.updateObject(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateNull(final String columnName) throws SQLException
- { try { resultSet.updateNull(columnName); } catch (final SQLException e) { handleException(e); } }
+ public void updateNull(final String columnName) throws SQLException {
+ try {
+ resultSet.updateNull(columnName);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateBoolean(final String columnName, final boolean x) throws SQLException
- { try { resultSet.updateBoolean(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateBoolean(final String columnName, final boolean x) throws SQLException {
+ try {
+ resultSet.updateBoolean(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateByte(final String columnName, final byte x) throws SQLException
- { try { resultSet.updateByte(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateByte(final String columnName, final byte x) throws SQLException {
+ try {
+ resultSet.updateByte(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateShort(final String columnName, final short x) throws SQLException
- { try { resultSet.updateShort(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateShort(final String columnName, final short x) throws SQLException {
+ try {
+ resultSet.updateShort(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateInt(final String columnName, final int x) throws SQLException
- { try { resultSet.updateInt(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateInt(final String columnName, final int x) throws SQLException {
+ try {
+ resultSet.updateInt(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateLong(final String columnName, final long x) throws SQLException
- { try { resultSet.updateLong(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateLong(final String columnName, final long x) throws SQLException {
+ try {
+ resultSet.updateLong(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateFloat(final String columnName, final float x) throws SQLException
- { try { resultSet.updateFloat(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateFloat(final String columnName, final float x) throws SQLException {
+ try {
+ resultSet.updateFloat(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateDouble(final String columnName, final double x) throws SQLException
- { try { resultSet.updateDouble(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateDouble(final String columnName, final double x) throws SQLException {
+ try {
+ resultSet.updateDouble(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateBigDecimal(final String columnName, final BigDecimal x) throws SQLException
- { try { resultSet.updateBigDecimal(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateBigDecimal(final String columnName, final BigDecimal x) throws SQLException {
+ try {
+ resultSet.updateBigDecimal(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateString(final String columnName, final String x) throws SQLException
- { try { resultSet.updateString(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateString(final String columnName, final String x) throws SQLException {
+ try {
+ resultSet.updateString(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateBytes(final String columnName, final byte[] x) throws SQLException
- { try { resultSet.updateBytes(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateBytes(final String columnName, final byte[] x) throws SQLException {
+ try {
+ resultSet.updateBytes(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateDate(final String columnName, final Date x) throws SQLException
- { try { resultSet.updateDate(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateDate(final String columnName, final Date x) throws SQLException {
+ try {
+ resultSet.updateDate(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateTime(final String columnName, final Time x) throws SQLException
- { try { resultSet.updateTime(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateTime(final String columnName, final Time x) throws SQLException {
+ try {
+ resultSet.updateTime(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateTimestamp(final String columnName, final Timestamp x) throws SQLException
- { try { resultSet.updateTimestamp(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateTimestamp(final String columnName, final Timestamp x) throws SQLException {
+ 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 { resultSet.updateAsciiStream(columnName, x, length); } catch (final SQLException e) { handleException(e); } }
+ public void updateAsciiStream(final String columnName, final InputStream x, final int length) throws SQLException {
+ 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 { resultSet.updateBinaryStream(columnName, x, length); } catch (final SQLException e) { handleException(e); } }
+ public void updateBinaryStream(final String columnName, final InputStream x, final int length) throws SQLException {
+ 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 { resultSet.updateCharacterStream(columnName, reader, length); } catch (final SQLException e) { handleException(e); } }
+ public void updateCharacterStream(final String columnName, final Reader reader, final int length)
+ throws SQLException {
+ 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 { resultSet.updateObject(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateObject(final String columnName, final Object x, final int scale) throws SQLException {
+ try {
+ resultSet.updateObject(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateObject(final String columnName, final Object x) throws SQLException
- { try { resultSet.updateObject(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateObject(final String columnName, final Object x) throws SQLException {
+ try {
+ resultSet.updateObject(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void insertRow() throws SQLException
- { try { resultSet.insertRow(); } catch (final SQLException e) { handleException(e); } }
+ public void insertRow() throws SQLException {
+ try {
+ resultSet.insertRow();
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateRow() throws SQLException
- { try { resultSet.updateRow(); } catch (final SQLException e) { handleException(e); } }
+ public void updateRow() throws SQLException {
+ try {
+ resultSet.updateRow();
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void deleteRow() throws SQLException
- { try { resultSet.deleteRow(); } catch (final SQLException e) { handleException(e); } }
+ public void deleteRow() throws SQLException {
+ try {
+ resultSet.deleteRow();
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void refreshRow() throws SQLException
- { try { resultSet.refreshRow(); } catch (final SQLException e) { handleException(e); } }
+ public void refreshRow() throws SQLException {
+ try {
+ resultSet.refreshRow();
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void cancelRowUpdates() throws SQLException
- { try { resultSet.cancelRowUpdates(); } catch (final SQLException e) { handleException(e); } }
+ public void cancelRowUpdates() throws SQLException {
+ try {
+ resultSet.cancelRowUpdates();
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void moveToInsertRow() throws SQLException
- { try { resultSet.moveToInsertRow(); } catch (final SQLException e) { handleException(e); } }
+ public void moveToInsertRow() throws SQLException {
+ try {
+ resultSet.moveToInsertRow();
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void moveToCurrentRow() throws SQLException
- { try { resultSet.moveToCurrentRow(); } catch (final SQLException e) { handleException(e); } }
+ public void moveToCurrentRow() throws SQLException {
+ 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 resultSet.getObject(i, map); } catch (final SQLException e) { handleException(e); return null; } }
+ public Object getObject(final int i, final Map<String, Class<?>> map) throws SQLException {
+ 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 resultSet.getRef(i); } catch (final SQLException e) { handleException(e); return null; } }
+ public Ref getRef(final int i) throws SQLException {
+ try {
+ return resultSet.getRef(i);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public Blob getBlob(final int i) throws SQLException
- { try { return resultSet.getBlob(i); } catch (final SQLException e) { handleException(e); return null; } }
+ public Blob getBlob(final int i) throws SQLException {
+ try {
+ return resultSet.getBlob(i);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public Clob getClob(final int i) throws SQLException
- { try { return resultSet.getClob(i); } catch (final SQLException e) { handleException(e); return null; } }
+ public Clob getClob(final int i) throws SQLException {
+ try {
+ return resultSet.getClob(i);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public Array getArray(final int i) throws SQLException
- { try { return resultSet.getArray(i); } catch (final SQLException e) { handleException(e); return null; } }
+ public Array getArray(final int i) throws SQLException {
+ 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 resultSet.getObject(colName, map); } catch (final SQLException e) { handleException(e); return null; } }
+ public Object getObject(final String colName, final Map<String, Class<?>> map) throws SQLException {
+ 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 resultSet.getRef(colName); } catch (final SQLException e) { handleException(e); return null; } }
+ public Ref getRef(final String colName) throws SQLException {
+ try {
+ return resultSet.getRef(colName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public Blob getBlob(final String colName) throws SQLException
- { try { return resultSet.getBlob(colName); } catch (final SQLException e) { handleException(e); return null; } }
+ public Blob getBlob(final String colName) throws SQLException {
+ try {
+ return resultSet.getBlob(colName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public Clob getClob(final String colName) throws SQLException
- { try { return resultSet.getClob(colName); } catch (final SQLException e) { handleException(e); return null; } }
+ public Clob getClob(final String colName) throws SQLException {
+ try {
+ return resultSet.getClob(colName);
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
+ }
+ }
@Override
- public Array getArray(final String colName) throws SQLException
- { try { return resultSet.getArray(colName); } catch (final SQLException e) { handleException(e); return null; } }
+ public Array getArray(final String colName) throws SQLException {
+ 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 resultSet.getDate(columnIndex, cal); } catch (final SQLException e) { handleException(e); return null; } }
+ public Date getDate(final int columnIndex, final Calendar cal) throws SQLException {
+ 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 resultSet.getDate(columnName, cal); } catch (final SQLException e) { handleException(e); return null; } }
+ public Date getDate(final String columnName, final Calendar cal) throws SQLException {
+ 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 resultSet.getTime(columnIndex, cal); } catch (final SQLException e) { handleException(e); return null; } }
+ public Time getTime(final int columnIndex, final Calendar cal) throws SQLException {
+ 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 resultSet.getTime(columnName, cal); } catch (final SQLException e) { handleException(e); return null; } }
+ public Time getTime(final String columnName, final Calendar cal) throws SQLException {
+ 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 resultSet.getTimestamp(columnIndex, cal); } catch (final SQLException e) { handleException(e); return null; } }
+ public Timestamp getTimestamp(final int columnIndex, final Calendar cal) throws SQLException {
+ 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 resultSet.getTimestamp(columnName, cal); } catch (final SQLException e) { handleException(e); return null; } }
-
+ public Timestamp getTimestamp(final String columnName, final Calendar cal) throws SQLException {
+ 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 resultSet.getURL(columnIndex); } catch (final SQLException e) { handleException(e); return null; } }
+ public java.net.URL getURL(final int columnIndex) throws SQLException {
+ 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 resultSet.getURL(columnName); } catch (final SQLException e) { handleException(e); return null; } }
+ public java.net.URL getURL(final String columnName) throws SQLException {
+ 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 { resultSet.updateRef(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateRef(final int columnIndex, final Ref x) throws SQLException {
+ try {
+ resultSet.updateRef(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateRef(final String columnName, final Ref x) throws SQLException
- { try { resultSet.updateRef(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateRef(final String columnName, final Ref x) throws SQLException {
+ try {
+ resultSet.updateRef(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateBlob(final int columnIndex, final Blob x) throws SQLException
- { try { resultSet.updateBlob(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateBlob(final int columnIndex, final Blob x) throws SQLException {
+ try {
+ resultSet.updateBlob(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateBlob(final String columnName, final Blob x) throws SQLException
- { try { resultSet.updateBlob(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateBlob(final String columnName, final Blob x) throws SQLException {
+ try {
+ resultSet.updateBlob(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateClob(final int columnIndex, final Clob x) throws SQLException
- { try { resultSet.updateClob(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateClob(final int columnIndex, final Clob x) throws SQLException {
+ try {
+ resultSet.updateClob(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateClob(final String columnName, final Clob x) throws SQLException
- { try { resultSet.updateClob(columnName, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateClob(final String columnName, final Clob x) throws SQLException {
+ try {
+ resultSet.updateClob(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateArray(final int columnIndex, final Array x) throws SQLException
- { try { resultSet.updateArray(columnIndex, x); } catch (final SQLException e) { handleException(e); } }
+ public void updateArray(final int columnIndex, final Array x) throws SQLException {
+ try {
+ resultSet.updateArray(columnIndex, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
- public void updateArray(final String columnName, final Array x) throws SQLException
- { try { resultSet.updateArray(columnName, x); } catch (final SQLException e) { handleException(e); } }
-
+ public void updateArray(final String columnName, final Array x) throws SQLException {
+ try {
+ resultSet.updateArray(columnName, x);
+ } catch (final SQLException e) {
+ handleException(e);
+ }
+ }
@Override
public boolean isWrapperFor(final Class<?> iface) throws SQLException {
@@ -799,8 +1548,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public RowId getRowId(final int columnIndex) throws SQLException {
try {
return resultSet.getRowId(columnIndex);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -810,8 +1558,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public RowId getRowId(final String columnLabel) throws SQLException {
try {
return resultSet.getRowId(columnLabel);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -821,8 +1568,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateRowId(final int columnIndex, final RowId value) throws SQLException {
try {
resultSet.updateRowId(columnIndex, value);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -831,8 +1577,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateRowId(final String columnLabel, final RowId value) throws SQLException {
try {
resultSet.updateRowId(columnLabel, value);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -841,8 +1586,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public int getHoldability() throws SQLException {
try {
return resultSet.getHoldability();
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return 0;
}
@@ -852,8 +1596,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public boolean isClosed() throws SQLException {
try {
return resultSet.isClosed();
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return false;
}
@@ -863,8 +1606,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateNString(final int columnIndex, final String value) throws SQLException {
try {
resultSet.updateNString(columnIndex, value);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -873,8 +1615,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateNString(final String columnLabel, final String value) throws SQLException {
try {
resultSet.updateNString(columnLabel, value);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -883,8 +1624,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateNClob(final int columnIndex, final NClob value) throws SQLException {
try {
resultSet.updateNClob(columnIndex, value);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -893,8 +1633,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateNClob(final String columnLabel, final NClob value) throws SQLException {
try {
resultSet.updateNClob(columnLabel, value);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -903,8 +1642,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public NClob getNClob(final int columnIndex) throws SQLException {
try {
return resultSet.getNClob(columnIndex);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -914,8 +1652,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public NClob getNClob(final String columnLabel) throws SQLException {
try {
return resultSet.getNClob(columnLabel);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -925,8 +1662,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public SQLXML getSQLXML(final int columnIndex) throws SQLException {
try {
return resultSet.getSQLXML(columnIndex);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -936,8 +1672,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public SQLXML getSQLXML(final String columnLabel) throws SQLException {
try {
return resultSet.getSQLXML(columnLabel);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -947,8 +1682,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateSQLXML(final int columnIndex, final SQLXML value) throws SQLException {
try {
resultSet.updateSQLXML(columnIndex, value);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -957,8 +1691,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateSQLXML(final String columnLabel, final SQLXML value) throws SQLException {
try {
resultSet.updateSQLXML(columnLabel, value);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -967,8 +1700,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public String getNString(final int columnIndex) throws SQLException {
try {
return resultSet.getNString(columnIndex);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -978,8 +1710,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public String getNString(final String columnLabel) throws SQLException {
try {
return resultSet.getNString(columnLabel);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -989,8 +1720,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public Reader getNCharacterStream(final int columnIndex) throws SQLException {
try {
return resultSet.getNCharacterStream(columnIndex);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -1000,109 +1730,108 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public Reader getNCharacterStream(final String columnLabel) throws SQLException {
try {
return resultSet.getNCharacterStream(columnLabel);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
- public void updateNCharacterStream(final int columnIndex, final Reader reader, final long length) throws SQLException {
+ public void updateNCharacterStream(final int columnIndex, final Reader reader, final long length)
+ throws SQLException {
try {
resultSet.updateNCharacterStream(columnIndex, reader, length);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@Override
- public void updateNCharacterStream(final String columnLabel, final Reader reader, final long length) throws SQLException {
+ public void updateNCharacterStream(final String columnLabel, final Reader reader, final long length)
+ throws SQLException {
try {
resultSet.updateNCharacterStream(columnLabel, reader, length);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@Override
- public void updateAsciiStream(final int columnIndex, final InputStream inputStream, final long length) throws SQLException {
+ public void updateAsciiStream(final int columnIndex, final InputStream inputStream, final long length)
+ throws SQLException {
try {
resultSet.updateAsciiStream(columnIndex, inputStream, length);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@Override
- public void updateBinaryStream(final int columnIndex, final InputStream inputStream, final long length) throws SQLException {
+ public void updateBinaryStream(final int columnIndex, final InputStream inputStream, final long length)
+ throws SQLException {
try {
resultSet.updateBinaryStream(columnIndex, inputStream, length);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@Override
- public void updateCharacterStream(final int columnIndex, final Reader reader, final long length) throws SQLException {
+ public void updateCharacterStream(final int columnIndex, final Reader reader, final long length)
+ throws SQLException {
try {
resultSet.updateCharacterStream(columnIndex, reader, length);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@Override
- public void updateAsciiStream(final String columnLabel, final InputStream inputStream, final long length) throws SQLException {
+ public void updateAsciiStream(final String columnLabel, final InputStream inputStream, final long length)
+ throws SQLException {
try {
resultSet.updateAsciiStream(columnLabel, inputStream, length);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@Override
- public void updateBinaryStream(final String columnLabel, final InputStream inputStream, final long length) throws SQLException {
+ public void updateBinaryStream(final String columnLabel, final InputStream inputStream, final long length)
+ throws SQLException {
try {
resultSet.updateBinaryStream(columnLabel, inputStream, length);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@Override
- public void updateCharacterStream(final String columnLabel, final Reader reader, final long length) throws SQLException {
+ public void updateCharacterStream(final String columnLabel, final Reader reader, final long length)
+ throws SQLException {
try {
resultSet.updateCharacterStream(columnLabel, reader, length);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@Override
- public void updateBlob(final int columnIndex, final InputStream inputStream, final long length) throws SQLException {
+ public void updateBlob(final int columnIndex, final InputStream inputStream, final long length)
+ throws SQLException {
try {
resultSet.updateBlob(columnIndex, inputStream, length);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@Override
- public void updateBlob(final String columnLabel, final InputStream inputStream, final long length) throws SQLException {
+ public void updateBlob(final String columnLabel, final InputStream inputStream, final long length)
+ throws SQLException {
try {
resultSet.updateBlob(columnLabel, inputStream, length);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -1111,8 +1840,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateClob(final int columnIndex, final Reader reader, final long length) throws SQLException {
try {
resultSet.updateClob(columnIndex, reader, length);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -1121,8 +1849,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateClob(final String columnLabel, final Reader reader, final long length) throws SQLException {
try {
resultSet.updateClob(columnLabel, reader, length);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -1131,8 +1858,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateNClob(final int columnIndex, final Reader reader, final long length) throws SQLException {
try {
resultSet.updateNClob(columnIndex, reader, length);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -1141,8 +1867,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateNClob(final String columnLabel, final Reader reader, final long length) throws SQLException {
try {
resultSet.updateNClob(columnLabel, reader, length);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -1151,8 +1876,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateNCharacterStream(final int columnIndex, final Reader reader) throws SQLException {
try {
resultSet.updateNCharacterStream(columnIndex, reader);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -1161,8 +1885,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateNCharacterStream(final String columnLabel, final Reader reader) throws SQLException {
try {
resultSet.updateNCharacterStream(columnLabel, reader);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -1171,8 +1894,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateAsciiStream(final int columnIndex, final InputStream inputStream) throws SQLException {
try {
resultSet.updateAsciiStream(columnIndex, inputStream);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -1181,8 +1903,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateBinaryStream(final int columnIndex, final InputStream inputStream) throws SQLException {
try {
resultSet.updateBinaryStream(columnIndex, inputStream);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -1191,8 +1912,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateCharacterStream(final int columnIndex, final Reader reader) throws SQLException {
try {
resultSet.updateCharacterStream(columnIndex, reader);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -1201,8 +1921,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateAsciiStream(final String columnLabel, final InputStream inputStream) throws SQLException {
try {
resultSet.updateAsciiStream(columnLabel, inputStream);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -1211,8 +1930,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateBinaryStream(final String columnLabel, final InputStream inputStream) throws SQLException {
try {
resultSet.updateBinaryStream(columnLabel, inputStream);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -1221,8 +1939,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateCharacterStream(final String columnLabel, final Reader reader) throws SQLException {
try {
resultSet.updateCharacterStream(columnLabel, reader);
- }
- catch (final SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -1231,8 +1948,7 @@ public final class DelegatingResultSet extends AbandonedTrace implements ResultS
public void updateBlob(final int columnIndex, final InputStre
<TRUNCATED>