--- /srv/reproducible-results/rbuild-debian/r-b-build.Eutfr7n6/b1/c3p0_0.9.1.2-10_i386.changes +++ /srv/reproducible-results/rbuild-debian/r-b-build.Eutfr7n6/b2/c3p0_0.9.1.2-10_i386.changes ├── Files │ @@ -1,3 +1,3 @@ │ │ 30ec2b72a7b84eea543ebf0fbb9fcc2b 126804 doc optional libc3p0-java-doc_0.9.1.2-10_all.deb │ - fde0b17e37100e94b8d60a74f68bb0f6 607424 java optional libc3p0-java_0.9.1.2-10_all.deb │ + 7f75f54e7f11b9b75eb56e80bafd869a 607396 java optional libc3p0-java_0.9.1.2-10_all.deb ├── libc3p0-java_0.9.1.2-10_all.deb │ ├── file list │ │ @@ -1,3 +1,3 @@ │ │ -rw-r--r-- 0 0 0 4 2018-12-25 14:16:25.000000 debian-binary │ │ -rw-r--r-- 0 0 0 808 2018-12-25 14:16:25.000000 control.tar.xz │ │ --rw-r--r-- 0 0 0 606424 2018-12-25 14:16:25.000000 data.tar.xz │ │ +-rw-r--r-- 0 0 0 606396 2018-12-25 14:16:25.000000 data.tar.xz │ ├── control.tar.xz │ │ ├── control.tar │ │ │ ├── ./md5sums │ │ │ │ ├── ./md5sums │ │ │ │ │┄ Files differ │ ├── data.tar.xz │ │ ├── data.tar │ │ │ ├── file list │ │ │ │ @@ -3,15 +3,15 @@ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/doc/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/doc/libc3p0-java/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 1010 2018-12-25 14:16:25.000000 ./usr/share/doc/libc3p0-java/changelog.Debian.gz │ │ │ │ -rw-r--r-- 0 root (0) root (0) 26278 2007-05-21 18:58:41.000000 ./usr/share/doc/libc3p0-java/changelog.gz │ │ │ │ -rw-r--r-- 0 root (0) root (0) 1528 2018-12-25 14:16:25.000000 ./usr/share/doc/libc3p0-java/copyright │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/java/ │ │ │ │ --rw-r--r-- 0 root (0) root (0) 637109 2018-12-25 14:16:25.000000 ./usr/share/java/c3p0-0.9.1.2.jar │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 637242 2018-12-25 14:16:25.000000 ./usr/share/java/c3p0-0.9.1.2.jar │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/maven-repo/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/maven-repo/c3p0/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/maven-repo/c3p0/c3p0/ │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/maven-repo/c3p0/c3p0/0.9.1.2/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 916 2018-12-25 14:16:25.000000 ./usr/share/maven-repo/c3p0/c3p0/0.9.1.2/c3p0-0.9.1.2.pom │ │ │ │ drwxr-xr-x 0 root (0) root (0) 0 2018-12-25 14:16:25.000000 ./usr/share/maven-repo/c3p0/c3p0/debian/ │ │ │ │ -rw-r--r-- 0 root (0) root (0) 915 2018-12-25 14:16:25.000000 ./usr/share/maven-repo/c3p0/c3p0/debian/c3p0-debian.pom │ │ │ ├── ./usr/share/java/c3p0-0.9.1.2.jar │ │ │ │ ├── zipinfo {} │ │ │ │ │ @@ -1,8 +1,8 @@ │ │ │ │ │ -Zip file size: 637109 bytes, number of entries: 434 │ │ │ │ │ +Zip file size: 637242 bytes, number of entries: 434 │ │ │ │ │ drwxr-xr-x 2.0 unx 0 bx stor 18-Dec-25 14:16 META-INF/ │ │ │ │ │ -rw-r--r-- 2.0 unx 343 b- defN 18-Dec-25 14:16 META-INF/MANIFEST.MF │ │ │ │ │ drwxr-xr-x 2.0 unx 0 b- stor 18-Dec-25 14:16 com/ │ │ │ │ │ drwxr-xr-x 2.0 unx 0 b- stor 18-Dec-25 14:16 com/mchange/ │ │ │ │ │ -rw-r--r-- 2.0 unx 389 b- defN 18-Dec-25 14:16 com/mchange/Debug.class │ │ │ │ │ drwxr-xr-x 2.0 unx 0 b- stor 18-Dec-25 14:16 com/mchange/lang/ │ │ │ │ │ -rw-r--r-- 2.0 unx 2589 b- defN 18-Dec-25 14:16 com/mchange/lang/ByteUtils.class │ │ │ │ │ @@ -167,23 +167,23 @@ │ │ │ │ │ -rw-r--r-- 2.0 unx 1662 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/IdentityTokenizedCoalesceChecker.class │ │ │ │ │ -rw-r--r-- 2.0 unx 386 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/InternalPooledConnection.class │ │ │ │ │ -rw-r--r-- 2.0 unx 8361 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/JndiRefDataSourceBase.class │ │ │ │ │ -rw-r--r-- 2.0 unx 19071 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/NewPooledConnection.class │ │ │ │ │ -rw-r--r-- 2.0 unx 943 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/NewProxyCallableStatement$1.class │ │ │ │ │ -rw-r--r-- 2.0 unx 77245 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/NewProxyCallableStatement.class │ │ │ │ │ -rw-r--r-- 2.0 unx 901 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/NewProxyConnection$1.class │ │ │ │ │ --rw-r--r-- 2.0 unx 28466 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/NewProxyConnection.class │ │ │ │ │ +-rw-r--r-- 2.0 unx 28480 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/NewProxyConnection.class │ │ │ │ │ -rw-r--r-- 2.0 unx 937 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/NewProxyDatabaseMetaData$1.class │ │ │ │ │ -rw-r--r-- 2.0 unx 54238 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/NewProxyDatabaseMetaData.class │ │ │ │ │ -rw-r--r-- 2.0 unx 943 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/NewProxyPreparedStatement$1.class │ │ │ │ │ -rw-r--r-- 2.0 unx 39957 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/NewProxyPreparedStatement.class │ │ │ │ │ -rw-r--r-- 2.0 unx 895 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/NewProxyResultSet$1.class │ │ │ │ │ -rw-r--r-- 2.0 unx 64934 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/NewProxyResultSet.class │ │ │ │ │ -rw-r--r-- 2.0 unx 895 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/NewProxyStatement$1.class │ │ │ │ │ --rw-r--r-- 2.0 unx 21064 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/NewProxyStatement.class │ │ │ │ │ +-rw-r--r-- 2.0 unx 21066 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/NewProxyStatement.class │ │ │ │ │ -rw-r--r-- 2.0 unx 725 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/NullStatementSetManagedResultSet.class │ │ │ │ │ -rw-r--r-- 2.0 unx 8306 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/PoolBackedDataSourceBase.class │ │ │ │ │ -rw-r--r-- 2.0 unx 4406 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/SetManagedDatabaseMetaData.class │ │ │ │ │ -rw-r--r-- 2.0 unx 1074 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/SetManagedResultSet.class │ │ │ │ │ -rw-r--r-- 2.0 unx 893 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/SnatchFromSetResultSet.class │ │ │ │ │ -rw-r--r-- 2.0 unx 19599 b- defN 18-Dec-25 14:16 com/mchange/v2/c3p0/impl/WrapperConnectionPoolDataSourceBase.class │ │ │ │ │ drwxr-xr-x 2.0 unx 0 b- stor 18-Dec-25 14:16 com/mchange/v2/c3p0/jboss/ │ │ │ │ │ @@ -429,8 +429,8 @@ │ │ │ │ │ -rw-r--r-- 2.0 unx 2990 b- defN 18-Dec-25 14:16 com/mchange/v2/util/DoubleWeakHashMap$UserKeySet.class │ │ │ │ │ -rw-r--r-- 2.0 unx 1256 b- defN 18-Dec-25 14:16 com/mchange/v2/util/DoubleWeakHashMap$ValuesCollection$1.class │ │ │ │ │ -rw-r--r-- 2.0 unx 3497 b- defN 18-Dec-25 14:16 com/mchange/v2/util/DoubleWeakHashMap$ValuesCollection.class │ │ │ │ │ -rw-r--r-- 2.0 unx 1307 b- defN 18-Dec-25 14:16 com/mchange/v2/util/DoubleWeakHashMap$WKey.class │ │ │ │ │ -rw-r--r-- 2.0 unx 931 b- defN 18-Dec-25 14:16 com/mchange/v2/util/DoubleWeakHashMap$WVal.class │ │ │ │ │ -rw-r--r-- 2.0 unx 5389 b- defN 18-Dec-25 14:16 com/mchange/v2/util/DoubleWeakHashMap.class │ │ │ │ │ -rw-r--r-- 2.0 unx 1178 b- defN 18-Dec-25 14:16 com/mchange/v2/util/ResourceClosedException.class │ │ │ │ │ -434 files, 1482076 bytes uncompressed, 562639 bytes compressed: 62.0% │ │ │ │ │ +434 files, 1482092 bytes uncompressed, 562772 bytes compressed: 62.0% │ │ │ │ ├── com/mchange/v2/c3p0/impl/NewProxyCallableStatement.class │ │ │ │ │ ├── procyon -ec {} │ │ │ │ │ │ @@ -1,39 +1,39 @@ │ │ │ │ │ │ │ │ │ │ │ │ package com.mchange.v2.c3p0.impl; │ │ │ │ │ │ │ │ │ │ │ │ import com.mchange.v2.log.MLog; │ │ │ │ │ │ import java.lang.reflect.InvocationTargetException; │ │ │ │ │ │ import java.lang.reflect.Method; │ │ │ │ │ │ -import java.sql.SQLWarning; │ │ │ │ │ │ import java.sql.Connection; │ │ │ │ │ │ import com.mchange.v2.sql.SqlUtils; │ │ │ │ │ │ import com.mchange.v2.log.MLevel; │ │ │ │ │ │ -import java.sql.ParameterMetaData; │ │ │ │ │ │ +import java.sql.SQLWarning; │ │ │ │ │ │ import java.sql.Statement; │ │ │ │ │ │ import java.sql.ResultSet; │ │ │ │ │ │ import java.sql.ResultSetMetaData; │ │ │ │ │ │ +import java.sql.ParameterMetaData; │ │ │ │ │ │ +import java.sql.Date; │ │ │ │ │ │ +import java.sql.Time; │ │ │ │ │ │ +import java.net.URL; │ │ │ │ │ │ +import java.sql.Array; │ │ │ │ │ │ +import java.sql.Ref; │ │ │ │ │ │ +import java.util.Map; │ │ │ │ │ │ import java.sql.SQLXML; │ │ │ │ │ │ import java.sql.NClob; │ │ │ │ │ │ import java.sql.RowId; │ │ │ │ │ │ import java.sql.Clob; │ │ │ │ │ │ import java.sql.Blob; │ │ │ │ │ │ -import java.io.Reader; │ │ │ │ │ │ import java.sql.SQLType; │ │ │ │ │ │ -import java.io.InputStream; │ │ │ │ │ │ -import java.sql.Date; │ │ │ │ │ │ -import java.sql.Time; │ │ │ │ │ │ -import java.math.BigDecimal; │ │ │ │ │ │ import java.util.Calendar; │ │ │ │ │ │ import java.sql.Timestamp; │ │ │ │ │ │ -import java.net.URL; │ │ │ │ │ │ -import java.sql.Array; │ │ │ │ │ │ -import java.sql.Ref; │ │ │ │ │ │ -import java.util.Map; │ │ │ │ │ │ +import java.math.BigDecimal; │ │ │ │ │ │ +import java.io.InputStream; │ │ │ │ │ │ import java.sql.SQLException; │ │ │ │ │ │ +import java.io.Reader; │ │ │ │ │ │ import javax.sql.ConnectionEventListener; │ │ │ │ │ │ import com.mchange.v2.log.MLogger; │ │ │ │ │ │ import com.mchange.v2.c3p0.C3P0ProxyStatement; │ │ │ │ │ │ import java.sql.CallableStatement; │ │ │ │ │ │ │ │ │ │ │ │ public final class NewProxyCallableStatement implements CallableStatement, C3P0ProxyStatement │ │ │ │ │ │ { │ │ │ │ │ │ @@ -46,18 +46,18 @@ │ │ │ │ │ │ │ │ │ │ │ │ public NewProxyCallableStatement(final CallableStatement inner) { │ │ │ │ │ │ this.cel = (ConnectionEventListener)new NewProxyCallableStatement.NewProxyCallableStatement$1(this); │ │ │ │ │ │ this.inner = inner; │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean getBoolean(final int a) throws SQLException { │ │ │ │ │ │ + public final Reader getCharacterStream(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getBoolean(a); │ │ │ │ │ │ + return this.inner.getCharacterStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -66,18 +66,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean getBoolean(final String a) throws SQLException { │ │ │ │ │ │ + public final Reader getCharacterStream(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getBoolean(a); │ │ │ │ │ │ + return this.inner.getCharacterStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -86,18 +86,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte getByte(final int a) throws SQLException { │ │ │ │ │ │ + public final void setString(final String a, final String b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getByte(a); │ │ │ │ │ │ + this.inner.setString(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -106,18 +106,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte getByte(final String a) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final String a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getByte(a); │ │ │ │ │ │ + this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -126,18 +126,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final short getShort(final int a) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getShort(a); │ │ │ │ │ │ + this.inner.setAsciiStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -146,18 +146,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final short getShort(final String a) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getShort(a); │ │ │ │ │ │ + this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -166,18 +166,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getInt(final int a) throws SQLException { │ │ │ │ │ │ + public final void setCharacterStream(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getInt(a); │ │ │ │ │ │ + this.inner.setCharacterStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -186,18 +186,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getInt(final String a) throws SQLException { │ │ │ │ │ │ + public final void setCharacterStream(final String a, final Reader b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getInt(a); │ │ │ │ │ │ + this.inner.setCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -206,18 +206,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final long getLong(final int a) throws SQLException { │ │ │ │ │ │ + public final void setCharacterStream(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getLong(a); │ │ │ │ │ │ + this.inner.setCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -226,18 +226,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final long getLong(final String a) throws SQLException { │ │ │ │ │ │ + public final void setBytes(final String a, final byte[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getLong(a); │ │ │ │ │ │ + this.inner.setBytes(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -246,18 +246,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final float getFloat(final int a) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getFloat(a); │ │ │ │ │ │ + this.inner.setBinaryStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -266,18 +266,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final float getFloat(final String a) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final String a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getFloat(a); │ │ │ │ │ │ + this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -286,18 +286,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final double getDouble(final String a) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getDouble(a); │ │ │ │ │ │ + this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -306,18 +306,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final double getDouble(final int a) throws SQLException { │ │ │ │ │ │ + public final void setNull(final String a, final int b, final String c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getDouble(a); │ │ │ │ │ │ + this.inner.setNull(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -326,18 +326,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte[] getBytes(final String a) throws SQLException { │ │ │ │ │ │ + public final void setNull(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getBytes(a); │ │ │ │ │ │ + this.inner.setNull(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -346,18 +346,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte[] getBytes(final int a) throws SQLException { │ │ │ │ │ │ + public final void setBigDecimal(final String a, final BigDecimal b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getBytes(a); │ │ │ │ │ │ + this.inner.setBigDecimal(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -366,18 +366,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBoolean(final String a, final boolean b) throws SQLException { │ │ │ │ │ │ + public final void setTimestamp(final String a, final Timestamp b, final Calendar c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBoolean(a, b); │ │ │ │ │ │ + this.inner.setTimestamp(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -386,18 +386,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setByte(final String a, final byte b) throws SQLException { │ │ │ │ │ │ + public final void setTimestamp(final String a, final Timestamp b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setByte(a, b); │ │ │ │ │ │ + this.inner.setTimestamp(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -406,18 +406,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setShort(final String a, final short b) throws SQLException { │ │ │ │ │ │ + public final void setObject(final String a, final Object b, final int c, final int d) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setShort(a, b); │ │ │ │ │ │ + this.inner.setObject(a, b, c, d); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -426,18 +426,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setInt(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public final void setObject(final String a, final Object b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setInt(a, b); │ │ │ │ │ │ + this.inner.setObject(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -446,18 +446,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setLong(final String a, final long b) throws SQLException { │ │ │ │ │ │ + public final void setObject(final String a, final Object b, final SQLType c, final int d) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setLong(a, b); │ │ │ │ │ │ + this.inner.setObject(a, b, c, d); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -466,18 +466,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setFloat(final String a, final float b) throws SQLException { │ │ │ │ │ │ + public final void setObject(final String a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setFloat(a, b); │ │ │ │ │ │ + this.inner.setObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -486,18 +486,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setDouble(final String a, final double b) throws SQLException { │ │ │ │ │ │ + public final void setObject(final String a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDouble(a, b); │ │ │ │ │ │ + this.inner.setObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -506,18 +506,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final String a, final Class b) throws SQLException { │ │ │ │ │ │ + public final void setBlob(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getObject(a, (Class)b); │ │ │ │ │ │ + this.inner.setBlob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -526,18 +526,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final int a, final Map b) throws SQLException { │ │ │ │ │ │ + public final void setBlob(final String a, final Blob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getObject(a, b); │ │ │ │ │ │ + this.inner.setBlob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -546,18 +546,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final int a, final Class b) throws SQLException { │ │ │ │ │ │ + public final void setBlob(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getObject(a, (Class)b); │ │ │ │ │ │ + this.inner.setBlob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -566,18 +566,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final String a, final Map b) throws SQLException { │ │ │ │ │ │ + public final void setClob(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getObject(a, b); │ │ │ │ │ │ + this.inner.setClob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -586,18 +586,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final String a) throws SQLException { │ │ │ │ │ │ + public final void setClob(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getObject(a); │ │ │ │ │ │ + this.inner.setClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -606,18 +606,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final int a) throws SQLException { │ │ │ │ │ │ + public final void setClob(final String a, final Clob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getObject(a); │ │ │ │ │ │ + this.inner.setClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -626,18 +626,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Ref getRef(final String a) throws SQLException { │ │ │ │ │ │ + public final void setRowId(final String a, final RowId b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getRef(a); │ │ │ │ │ │ + this.inner.setRowId(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -646,18 +646,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Ref getRef(final int a) throws SQLException { │ │ │ │ │ │ + public final void setNString(final String a, final String b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getRef(a); │ │ │ │ │ │ + this.inner.setNString(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -666,18 +666,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Array getArray(final String a) throws SQLException { │ │ │ │ │ │ + public final void setNCharacterStream(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getArray(a); │ │ │ │ │ │ + this.inner.setNCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -686,18 +686,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Array getArray(final int a) throws SQLException { │ │ │ │ │ │ + public final void setNCharacterStream(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getArray(a); │ │ │ │ │ │ + this.inner.setNCharacterStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -706,18 +706,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setURL(final String a, final URL b) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final String a, final NClob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setURL(a, b); │ │ │ │ │ │ + this.inner.setNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -726,18 +726,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Timestamp getTimestamp(final String a) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getTimestamp(a); │ │ │ │ │ │ + this.inner.setNClob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -746,18 +746,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Timestamp getTimestamp(final int a) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getTimestamp(a); │ │ │ │ │ │ + this.inner.setNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -766,18 +766,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Timestamp getTimestamp(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final void setSQLXML(final String a, final SQLXML b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getTimestamp(a, b); │ │ │ │ │ │ + this.inner.setSQLXML(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -786,18 +786,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Timestamp getTimestamp(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final void registerOutParameter(final int a, final SQLType b, final String c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getTimestamp(a, b); │ │ │ │ │ │ + this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -806,18 +806,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getString(final String a) throws SQLException { │ │ │ │ │ │ + public final void registerOutParameter(final String a, final SQLType b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getString(a); │ │ │ │ │ │ + this.inner.registerOutParameter(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -826,18 +826,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getString(final int a) throws SQLException { │ │ │ │ │ │ + public final void registerOutParameter(final String a, final SQLType b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getString(a); │ │ │ │ │ │ + this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -846,18 +846,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final BigDecimal getBigDecimal(final String a) throws SQLException { │ │ │ │ │ │ + public final void registerOutParameter(final int a, final SQLType b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getBigDecimal(a); │ │ │ │ │ │ + this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -866,18 +866,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final BigDecimal getBigDecimal(final int a, final int b) throws SQLException { │ │ │ │ │ │ + public final void registerOutParameter(final int a, final SQLType b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getBigDecimal(a, b); │ │ │ │ │ │ + this.inner.registerOutParameter(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -886,18 +886,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final BigDecimal getBigDecimal(final int a) throws SQLException { │ │ │ │ │ │ + public final void registerOutParameter(final String a, final SQLType b, final String c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getBigDecimal(a); │ │ │ │ │ │ + this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -906,18 +906,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final int a) throws SQLException { │ │ │ │ │ │ + public final void registerOutParameter(final String a, final int b, final String c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getTime(a); │ │ │ │ │ │ + this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -926,18 +926,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final void registerOutParameter(final int a, final int b, final String c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getTime(a, b); │ │ │ │ │ │ + this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -946,18 +946,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final String a) throws SQLException { │ │ │ │ │ │ + public final void registerOutParameter(final String a, final int b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getTime(a); │ │ │ │ │ │ + this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -966,18 +966,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final void registerOutParameter(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getTime(a, b); │ │ │ │ │ │ + this.inner.registerOutParameter(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -986,18 +986,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setTime(final String a, final Time b) throws SQLException { │ │ │ │ │ │ + public final void registerOutParameter(final int a, final int b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTime(a, b); │ │ │ │ │ │ + this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1006,18 +1006,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setTime(final String a, final Time b, final Calendar c) throws SQLException { │ │ │ │ │ │ + public final void registerOutParameter(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTime(a, b, c); │ │ │ │ │ │ + this.inner.registerOutParameter(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1026,18 +1026,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setDate(final String a, final Date b) throws SQLException { │ │ │ │ │ │ + public final boolean wasNull() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDate(a, b); │ │ │ │ │ │ + return this.inner.wasNull(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1046,18 +1046,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setDate(final String a, final Date b, final Calendar c) throws SQLException { │ │ │ │ │ │ + public final Blob getBlob(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDate(a, b, c); │ │ │ │ │ │ + return this.inner.getBlob(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1066,18 +1066,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Blob getBlob(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getDate(a, b); │ │ │ │ │ │ + return this.inner.getBlob(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1086,18 +1086,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final int a) throws SQLException { │ │ │ │ │ │ + public final Clob getClob(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getDate(a); │ │ │ │ │ │ + return this.inner.getClob(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1106,18 +1106,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Clob getClob(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getDate(a, b); │ │ │ │ │ │ + return this.inner.getClob(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1126,18 +1126,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final String a) throws SQLException { │ │ │ │ │ │ + public final RowId getRowId(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getDate(a); │ │ │ │ │ │ + return this.inner.getRowId(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1146,18 +1146,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final URL getURL(final String a) throws SQLException { │ │ │ │ │ │ + public final RowId getRowId(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getURL(a); │ │ │ │ │ │ + return this.inner.getRowId(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1166,18 +1166,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final URL getURL(final int a) throws SQLException { │ │ │ │ │ │ + public final NClob getNClob(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getURL(a); │ │ │ │ │ │ + return this.inner.getNClob(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1186,18 +1186,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNull(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public final NClob getNClob(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNull(a, b); │ │ │ │ │ │ + return this.inner.getNClob(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1206,18 +1206,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNull(final String a, final int b, final String c) throws SQLException { │ │ │ │ │ │ + public final SQLXML getSQLXML(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNull(a, b, c); │ │ │ │ │ │ + return this.inner.getSQLXML(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1226,18 +1226,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBigDecimal(final String a, final BigDecimal b) throws SQLException { │ │ │ │ │ │ + public final SQLXML getSQLXML(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBigDecimal(a, b); │ │ │ │ │ │ + return this.inner.getSQLXML(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1246,18 +1246,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setString(final String a, final String b) throws SQLException { │ │ │ │ │ │ + public final String getNString(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setString(a, b); │ │ │ │ │ │ + return this.inner.getNString(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1266,18 +1266,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBytes(final String a, final byte[] b) throws SQLException { │ │ │ │ │ │ + public final String getNString(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBytes(a, b); │ │ │ │ │ │ + return this.inner.getNString(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1286,18 +1286,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setTimestamp(final String a, final Timestamp b) throws SQLException { │ │ │ │ │ │ + public final Reader getNCharacterStream(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTimestamp(a, b); │ │ │ │ │ │ + return this.inner.getNCharacterStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1306,18 +1306,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setTimestamp(final String a, final Timestamp b, final Calendar c) throws SQLException { │ │ │ │ │ │ + public final Reader getNCharacterStream(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTimestamp(a, b, c); │ │ │ │ │ │ + return this.inner.getNCharacterStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1326,18 +1326,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setAsciiStream(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final boolean getBoolean(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setAsciiStream(a, b); │ │ │ │ │ │ + return this.inner.getBoolean(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1346,18 +1346,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setAsciiStream(final String a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final boolean getBoolean(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ + return this.inner.getBoolean(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1366,18 +1366,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setAsciiStream(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final byte getByte(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ + return this.inner.getByte(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1386,18 +1386,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBinaryStream(final String a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final byte getByte(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ + return this.inner.getByte(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1406,18 +1406,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBinaryStream(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final short getShort(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ + return this.inner.getShort(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1426,18 +1426,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBinaryStream(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final short getShort(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBinaryStream(a, b); │ │ │ │ │ │ + return this.inner.getShort(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1446,18 +1446,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final String a, final Object b, final int c, final int d) throws SQLException { │ │ │ │ │ │ + public final int getInt(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c, d); │ │ │ │ │ │ + return this.inner.getInt(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1466,18 +1466,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final String a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ + public final int getInt(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c); │ │ │ │ │ │ + return this.inner.getInt(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1486,18 +1486,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final String a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ + public final long getLong(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c); │ │ │ │ │ │ + return this.inner.getLong(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1506,18 +1506,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final String a, final Object b) throws SQLException { │ │ │ │ │ │ + public final long getLong(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b); │ │ │ │ │ │ + return this.inner.getLong(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1526,18 +1526,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final String a, final Object b, final SQLType c, final int d) throws SQLException { │ │ │ │ │ │ + public final float getFloat(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c, d); │ │ │ │ │ │ + return this.inner.getFloat(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1546,18 +1546,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setCharacterStream(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final float getFloat(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setCharacterStream(a, b); │ │ │ │ │ │ + return this.inner.getFloat(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1566,18 +1566,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setCharacterStream(final String a, final Reader b, final int c) throws SQLException { │ │ │ │ │ │ + public final double getDouble(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setCharacterStream(a, b, c); │ │ │ │ │ │ + return this.inner.getDouble(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1586,18 +1586,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setCharacterStream(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final double getDouble(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setCharacterStream(a, b, c); │ │ │ │ │ │ + return this.inner.getDouble(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1606,18 +1606,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBlob(final String a, final Blob b) throws SQLException { │ │ │ │ │ │ + public final byte[] getBytes(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBlob(a, b); │ │ │ │ │ │ + return this.inner.getBytes(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1626,18 +1626,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBlob(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final byte[] getBytes(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBlob(a, b, c); │ │ │ │ │ │ + return this.inner.getBytes(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1646,18 +1646,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBlob(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void setBoolean(final String a, final boolean b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBlob(a, b); │ │ │ │ │ │ + this.inner.setBoolean(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1666,18 +1666,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setClob(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setByte(final String a, final byte b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setClob(a, b, c); │ │ │ │ │ │ + this.inner.setByte(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1686,18 +1686,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setClob(final String a, final Clob b) throws SQLException { │ │ │ │ │ │ + public final void setShort(final String a, final short b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setClob(a, b); │ │ │ │ │ │ + this.inner.setShort(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1706,18 +1706,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setClob(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void setInt(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setClob(a, b); │ │ │ │ │ │ + this.inner.setInt(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1726,18 +1726,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setRowId(final String a, final RowId b) throws SQLException { │ │ │ │ │ │ + public final void setLong(final String a, final long b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setRowId(a, b); │ │ │ │ │ │ + this.inner.setLong(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1746,18 +1746,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNString(final String a, final String b) throws SQLException { │ │ │ │ │ │ + public final void setFloat(final String a, final float b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNString(a, b); │ │ │ │ │ │ + this.inner.setFloat(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1766,18 +1766,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNCharacterStream(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void setDouble(final String a, final double b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNCharacterStream(a, b); │ │ │ │ │ │ + this.inner.setDouble(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1786,18 +1786,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNCharacterStream(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final String a, final Class b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNCharacterStream(a, b, c); │ │ │ │ │ │ + return this.inner.getObject(a, (Class)b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1806,18 +1806,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNClob(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final int a, final Class b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNClob(a, b); │ │ │ │ │ │ + return this.inner.getObject(a, (Class)b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1826,18 +1826,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNClob(final String a, final NClob b) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final String a, final Map b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNClob(a, b); │ │ │ │ │ │ + return this.inner.getObject(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1846,18 +1846,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNClob(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNClob(a, b, c); │ │ │ │ │ │ + return this.inner.getObject(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1866,18 +1866,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setSQLXML(final String a, final SQLXML b) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setSQLXML(a, b); │ │ │ │ │ │ + return this.inner.getObject(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1886,18 +1886,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void registerOutParameter(final String a, final SQLType b, final String c) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final int a, final Map b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ + return this.inner.getObject(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1906,18 +1906,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void registerOutParameter(final int a, final SQLType b, final int c) throws SQLException { │ │ │ │ │ │ + public final Ref getRef(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ + return this.inner.getRef(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1926,18 +1926,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void registerOutParameter(final int a, final SQLType b) throws SQLException { │ │ │ │ │ │ + public final Ref getRef(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.registerOutParameter(a, b); │ │ │ │ │ │ + return this.inner.getRef(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1946,18 +1946,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void registerOutParameter(final String a, final SQLType b, final int c) throws SQLException { │ │ │ │ │ │ + public final Array getArray(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ + return this.inner.getArray(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1966,18 +1966,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void registerOutParameter(final String a, final SQLType b) throws SQLException { │ │ │ │ │ │ + public final Array getArray(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.registerOutParameter(a, b); │ │ │ │ │ │ + return this.inner.getArray(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1986,18 +1986,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void registerOutParameter(final int a, final SQLType b, final String c) throws SQLException { │ │ │ │ │ │ + public final void setURL(final String a, final URL b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ + this.inner.setURL(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2006,18 +2006,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void registerOutParameter(final int a, final int b, final String c) throws SQLException { │ │ │ │ │ │ + public final Timestamp getTimestamp(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ + return this.inner.getTimestamp(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2026,18 +2026,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void registerOutParameter(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public final Timestamp getTimestamp(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.registerOutParameter(a, b); │ │ │ │ │ │ + return this.inner.getTimestamp(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2046,18 +2046,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void registerOutParameter(final String a, final int b, final int c) throws SQLException { │ │ │ │ │ │ + public final Timestamp getTimestamp(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ + return this.inner.getTimestamp(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2066,18 +2066,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void registerOutParameter(final String a, final int b, final String c) throws SQLException { │ │ │ │ │ │ + public final Timestamp getTimestamp(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ + return this.inner.getTimestamp(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2086,18 +2086,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void registerOutParameter(final int a, final int b) throws SQLException { │ │ │ │ │ │ + public final String getString(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.registerOutParameter(a, b); │ │ │ │ │ │ + return this.inner.getString(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2106,18 +2106,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void registerOutParameter(final int a, final int b, final int c) throws SQLException { │ │ │ │ │ │ + public final String getString(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.registerOutParameter(a, b, c); │ │ │ │ │ │ + return this.inner.getString(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2126,18 +2126,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean wasNull() throws SQLException { │ │ │ │ │ │ + public final BigDecimal getBigDecimal(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.wasNull(); │ │ │ │ │ │ + return this.inner.getBigDecimal(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2146,18 +2146,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Blob getBlob(final int a) throws SQLException { │ │ │ │ │ │ + public final BigDecimal getBigDecimal(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getBlob(a); │ │ │ │ │ │ + return this.inner.getBigDecimal(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2166,18 +2166,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Blob getBlob(final String a) throws SQLException { │ │ │ │ │ │ + public final BigDecimal getBigDecimal(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getBlob(a); │ │ │ │ │ │ + return this.inner.getBigDecimal(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2186,18 +2186,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Clob getClob(final String a) throws SQLException { │ │ │ │ │ │ + public final Time getTime(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getClob(a); │ │ │ │ │ │ + return this.inner.getTime(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2206,18 +2206,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Clob getClob(final int a) throws SQLException { │ │ │ │ │ │ + public final Time getTime(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getClob(a); │ │ │ │ │ │ + return this.inner.getTime(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2226,18 +2226,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final RowId getRowId(final int a) throws SQLException { │ │ │ │ │ │ + public final Time getTime(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getRowId(a); │ │ │ │ │ │ + return this.inner.getTime(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2246,18 +2246,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final RowId getRowId(final String a) throws SQLException { │ │ │ │ │ │ + public final Time getTime(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getRowId(a); │ │ │ │ │ │ + return this.inner.getTime(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2266,18 +2266,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final NClob getNClob(final String a) throws SQLException { │ │ │ │ │ │ + public final void setTime(final String a, final Time b, final Calendar c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getNClob(a); │ │ │ │ │ │ + this.inner.setTime(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2286,18 +2286,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final NClob getNClob(final int a) throws SQLException { │ │ │ │ │ │ + public final void setTime(final String a, final Time b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getNClob(a); │ │ │ │ │ │ + this.inner.setTime(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2306,18 +2306,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final SQLXML getSQLXML(final String a) throws SQLException { │ │ │ │ │ │ + public final void setDate(final String a, final Date b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getSQLXML(a); │ │ │ │ │ │ + this.inner.setDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2326,18 +2326,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final SQLXML getSQLXML(final int a) throws SQLException { │ │ │ │ │ │ + public final void setDate(final String a, final Date b, final Calendar c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getSQLXML(a); │ │ │ │ │ │ + this.inner.setDate(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2346,18 +2346,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getNString(final String a) throws SQLException { │ │ │ │ │ │ + public final Date getDate(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getNString(a); │ │ │ │ │ │ + return this.inner.getDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2366,18 +2366,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getNString(final int a) throws SQLException { │ │ │ │ │ │ + public final Date getDate(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getNString(a); │ │ │ │ │ │ + return this.inner.getDate(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2386,18 +2386,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Reader getNCharacterStream(final String a) throws SQLException { │ │ │ │ │ │ + public final Date getDate(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getNCharacterStream(a); │ │ │ │ │ │ + return this.inner.getDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2406,18 +2406,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Reader getNCharacterStream(final int a) throws SQLException { │ │ │ │ │ │ + public final Date getDate(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getNCharacterStream(a); │ │ │ │ │ │ + return this.inner.getDate(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2426,18 +2426,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Reader getCharacterStream(final int a) throws SQLException { │ │ │ │ │ │ + public final URL getURL(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getCharacterStream(a); │ │ │ │ │ │ + return this.inner.getURL(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2446,18 +2446,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Reader getCharacterStream(final String a) throws SQLException { │ │ │ │ │ │ + public final URL getURL(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getCharacterStream(a); │ │ │ │ │ │ + return this.inner.getURL(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2465,18 +2465,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean execute() throws SQLException { │ │ │ │ │ │ + public final int executeUpdate() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.execute(); │ │ │ │ │ │ + return this.inner.executeUpdate(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2484,18 +2484,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setBoolean(final int a, final boolean b) throws SQLException { │ │ │ │ │ │ + public final void addBatch() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBoolean(a, b); │ │ │ │ │ │ + this.inner.addBatch(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2503,18 +2503,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setByte(final int a, final byte b) throws SQLException { │ │ │ │ │ │ + public final long executeLargeUpdate() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setByte(a, b); │ │ │ │ │ │ + return this.inner.executeLargeUpdate(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2522,18 +2522,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setShort(final int a, final short b) throws SQLException { │ │ │ │ │ │ + public final void setString(final int a, final String b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setShort(a, b); │ │ │ │ │ │ + this.inner.setString(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2541,18 +2541,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setInt(final int a, final int b) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setInt(a, b); │ │ │ │ │ │ + this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2560,18 +2560,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setLong(final int a, final long b) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setLong(a, b); │ │ │ │ │ │ + this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2579,18 +2579,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setFloat(final int a, final float b) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setFloat(a, b); │ │ │ │ │ │ + this.inner.setAsciiStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2598,18 +2598,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setDouble(final int a, final double b) throws SQLException { │ │ │ │ │ │ + public final void setCharacterStream(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDouble(a, b); │ │ │ │ │ │ + this.inner.setCharacterStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2617,18 +2617,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setURL(final int a, final URL b) throws SQLException { │ │ │ │ │ │ + public final void setCharacterStream(final int a, final Reader b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setURL(a, b); │ │ │ │ │ │ + this.inner.setCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2636,18 +2636,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setArray(final int a, final Array b) throws SQLException { │ │ │ │ │ │ + public final void setCharacterStream(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setArray(a, b); │ │ │ │ │ │ + this.inner.setCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2655,18 +2655,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setTime(final int a, final Time b) throws SQLException { │ │ │ │ │ │ + public final void setBytes(final int a, final byte[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTime(a, b); │ │ │ │ │ │ + this.inner.setBytes(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2674,18 +2674,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setTime(final int a, final Time b, final Calendar c) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTime(a, b, c); │ │ │ │ │ │ + this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2693,18 +2693,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setDate(final int a, final Date b) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDate(a, b); │ │ │ │ │ │ + this.inner.setBinaryStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2712,18 +2712,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setDate(final int a, final Date b, final Calendar c) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDate(a, b, c); │ │ │ │ │ │ + this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2731,18 +2731,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final ResultSetMetaData getMetaData() throws SQLException { │ │ │ │ │ │ + public final void setNull(final int a, final int b, final String c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getMetaData(); │ │ │ │ │ │ + this.inner.setNull(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2750,23 +2750,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final ResultSet executeQuery() throws SQLException { │ │ │ │ │ │ + public final void setNull(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - final ResultSet innerResultSet = this.inner.executeQuery(); │ │ │ │ │ │ - if (innerResultSet == null) { │ │ │ │ │ │ - return null; │ │ │ │ │ │ - } │ │ │ │ │ │ - this.parentPooledConnection.markActiveResultSetForStatement((Statement)this.inner, innerResultSet); │ │ │ │ │ │ - return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ + this.inner.setNull(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2774,18 +2769,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int executeUpdate() throws SQLException { │ │ │ │ │ │ + public final void setBigDecimal(final int a, final BigDecimal b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeUpdate(); │ │ │ │ │ │ + this.inner.setBigDecimal(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2793,18 +2788,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void addBatch() throws SQLException { │ │ │ │ │ │ + public final void setTimestamp(final int a, final Timestamp b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.addBatch(); │ │ │ │ │ │ + this.inner.setTimestamp(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2812,18 +2807,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final long executeLargeUpdate() throws SQLException { │ │ │ │ │ │ + public final void setTimestamp(final int a, final Timestamp b, final Calendar c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeUpdate(); │ │ │ │ │ │ + this.inner.setTimestamp(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2831,18 +2826,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setNull(final int a, final int b) throws SQLException { │ │ │ │ │ │ + public final void setUnicodeStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNull(a, b); │ │ │ │ │ │ + this.inner.setUnicodeStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2850,18 +2845,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setNull(final int a, final int b, final String c) throws SQLException { │ │ │ │ │ │ + public final void clearParameters() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNull(a, b, c); │ │ │ │ │ │ + this.inner.clearParameters(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2869,18 +2864,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setBigDecimal(final int a, final BigDecimal b) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBigDecimal(a, b); │ │ │ │ │ │ + this.inner.setObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2888,18 +2883,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setString(final int a, final String b) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b, final int c, final int d) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setString(a, b); │ │ │ │ │ │ + this.inner.setObject(a, b, c, d); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2907,18 +2902,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setBytes(final int a, final byte[] b) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b, final SQLType c, final int d) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBytes(a, b); │ │ │ │ │ │ + this.inner.setObject(a, b, c, d); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2926,18 +2921,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setTimestamp(final int a, final Timestamp b) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTimestamp(a, b); │ │ │ │ │ │ + this.inner.setObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2945,18 +2940,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setTimestamp(final int a, final Timestamp b, final Calendar c) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTimestamp(a, b, c); │ │ │ │ │ │ + this.inner.setObject(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2964,18 +2959,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setAsciiStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setRef(final int a, final Ref b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ + this.inner.setRef(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2983,18 +2978,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setAsciiStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void setBlob(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setAsciiStream(a, b); │ │ │ │ │ │ + this.inner.setBlob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3002,18 +2997,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setAsciiStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setBlob(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ + this.inner.setBlob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3021,18 +3016,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setUnicodeStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setBlob(final int a, final Blob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setUnicodeStream(a, b, c); │ │ │ │ │ │ + this.inner.setBlob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3040,18 +3035,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setBinaryStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void setClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBinaryStream(a, b); │ │ │ │ │ │ + this.inner.setClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3059,18 +3054,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setBinaryStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setClob(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ + this.inner.setClob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3078,18 +3073,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setBinaryStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setClob(final int a, final Clob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ + this.inner.setClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3097,18 +3092,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void clearParameters() throws SQLException { │ │ │ │ │ │ + public final ParameterMetaData getParameterMetaData() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.clearParameters(); │ │ │ │ │ │ + return this.inner.getParameterMetaData(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3116,18 +3111,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setObject(final int a, final Object b, final SQLType c, final int d) throws SQLException { │ │ │ │ │ │ + public final void setRowId(final int a, final RowId b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c, d); │ │ │ │ │ │ + this.inner.setRowId(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3135,18 +3130,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setObject(final int a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ + public final void setNString(final int a, final String b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c); │ │ │ │ │ │ + this.inner.setNString(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3154,18 +3149,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setObject(final int a, final Object b, final int c, final int d) throws SQLException { │ │ │ │ │ │ + public final void setNCharacterStream(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c, d); │ │ │ │ │ │ + this.inner.setNCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3173,18 +3168,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setObject(final int a, final Object b) throws SQLException { │ │ │ │ │ │ + public final void setNCharacterStream(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b); │ │ │ │ │ │ + this.inner.setNCharacterStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3192,18 +3187,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setObject(final int a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c); │ │ │ │ │ │ + this.inner.setNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3211,18 +3206,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setCharacterStream(final int a, final Reader b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final int a, final NClob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setCharacterStream(a, b, c); │ │ │ │ │ │ + this.inner.setNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3230,18 +3225,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setCharacterStream(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setCharacterStream(a, b, c); │ │ │ │ │ │ + this.inner.setNClob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3249,18 +3244,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setCharacterStream(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void setSQLXML(final int a, final SQLXML b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setCharacterStream(a, b); │ │ │ │ │ │ + this.inner.setSQLXML(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3268,18 +3263,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setRef(final int a, final Ref b) throws SQLException { │ │ │ │ │ │ + public final boolean execute() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setRef(a, b); │ │ │ │ │ │ + return this.inner.execute(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3287,18 +3282,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setBlob(final int a, final Blob b) throws SQLException { │ │ │ │ │ │ + public final void setBoolean(final int a, final boolean b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBlob(a, b); │ │ │ │ │ │ + this.inner.setBoolean(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3306,18 +3301,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setBlob(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void setByte(final int a, final byte b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBlob(a, b); │ │ │ │ │ │ + this.inner.setByte(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3325,18 +3320,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setBlob(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setShort(final int a, final short b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBlob(a, b, c); │ │ │ │ │ │ + this.inner.setShort(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3344,18 +3339,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setClob(final int a, final Clob b) throws SQLException { │ │ │ │ │ │ + public final void setInt(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setClob(a, b); │ │ │ │ │ │ + this.inner.setInt(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3363,18 +3358,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void setLong(final int a, final long b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setClob(a, b); │ │ │ │ │ │ + this.inner.setLong(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3382,18 +3377,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setClob(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setFloat(final int a, final float b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setClob(a, b, c); │ │ │ │ │ │ + this.inner.setFloat(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3401,18 +3396,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final ParameterMetaData getParameterMetaData() throws SQLException { │ │ │ │ │ │ + public final void setDouble(final int a, final double b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getParameterMetaData(); │ │ │ │ │ │ + this.inner.setDouble(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3420,18 +3415,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setRowId(final int a, final RowId b) throws SQLException { │ │ │ │ │ │ + public final void setURL(final int a, final URL b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setRowId(a, b); │ │ │ │ │ │ + this.inner.setURL(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3439,18 +3434,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setNString(final int a, final String b) throws SQLException { │ │ │ │ │ │ + public final void setArray(final int a, final Array b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNString(a, b); │ │ │ │ │ │ + this.inner.setArray(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3458,18 +3453,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setNCharacterStream(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setTime(final int a, final Time b, final Calendar c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNCharacterStream(a, b, c); │ │ │ │ │ │ + this.inner.setTime(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3477,18 +3472,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setNCharacterStream(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void setTime(final int a, final Time b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNCharacterStream(a, b); │ │ │ │ │ │ + this.inner.setTime(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3496,18 +3491,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setNClob(final int a, final NClob b) throws SQLException { │ │ │ │ │ │ + public final void setDate(final int a, final Date b, final Calendar c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNClob(a, b); │ │ │ │ │ │ + this.inner.setDate(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3515,18 +3510,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setNClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void setDate(final int a, final Date b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNClob(a, b); │ │ │ │ │ │ + this.inner.setDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3534,18 +3529,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setNClob(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final ResultSetMetaData getMetaData() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNClob(a, b, c); │ │ │ │ │ │ + return this.inner.getMetaData(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3553,18 +3548,23 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setSQLXML(final int a, final SQLXML b) throws SQLException { │ │ │ │ │ │ + public final ResultSet executeQuery() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setSQLXML(a, b); │ │ │ │ │ │ + final ResultSet innerResultSet = this.inner.executeQuery(); │ │ │ │ │ │ + if (innerResultSet == null) { │ │ │ │ │ │ + return null; │ │ │ │ │ │ + } │ │ │ │ │ │ + this.parentPooledConnection.markActiveResultSetForStatement((Statement)this.inner, innerResultSet); │ │ │ │ │ │ + return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3572,18 +3572,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean execute(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ + public final int executeUpdate(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.execute(a, b); │ │ │ │ │ │ + return this.inner.executeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3591,18 +3591,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean execute(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public final int executeUpdate(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.execute(a, b); │ │ │ │ │ │ + return this.inner.executeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3610,18 +3610,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean execute(final String a) throws SQLException { │ │ │ │ │ │ + public final int executeUpdate(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.execute(a); │ │ │ │ │ │ + return this.inner.executeUpdate(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3629,18 +3629,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean execute(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ + public final int executeUpdate(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.execute(a, b); │ │ │ │ │ │ + return this.inner.executeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3648,56 +3648,37 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void close() throws SQLException { │ │ │ │ │ │ + public final int getMaxFieldSize() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - if (this.is_cached) { │ │ │ │ │ │ - this.parentPooledConnection.checkinStatement((Statement)this.inner); │ │ │ │ │ │ - } │ │ │ │ │ │ - else { │ │ │ │ │ │ - this.parentPooledConnection.markInactiveUncachedStatement((Statement)this.inner); │ │ │ │ │ │ - try { │ │ │ │ │ │ - this.inner.close(); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception e) { │ │ │ │ │ │ - if (NewProxyCallableStatement.logger.isLoggable(MLevel.WARNING)) { │ │ │ │ │ │ - NewProxyCallableStatement.logger.log(MLevel.WARNING, "Exception on close of inner statement.", (Throwable)e); │ │ │ │ │ │ - } │ │ │ │ │ │ - final SQLException sqle = SqlUtils.toSQLException((Throwable)e); │ │ │ │ │ │ - throw sqle; │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - this.detach(); │ │ │ │ │ │ - this.inner = null; │ │ │ │ │ │ - this.creatorProxy = null; │ │ │ │ │ │ - } │ │ │ │ │ │ + return this.inner.getMaxFieldSize(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ catch (final Exception exc2) { │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void cancel() throws SQLException { │ │ │ │ │ │ + public final void setMaxFieldSize(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.cancel(); │ │ │ │ │ │ + this.inner.setMaxFieldSize(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3705,18 +3686,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean isClosed() throws SQLException { │ │ │ │ │ │ + public final int getMaxRows() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.isDetached(); │ │ │ │ │ │ + return this.inner.getMaxRows(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3724,21 +3705,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final Connection getConnection() throws SQLException { │ │ │ │ │ │ + public final void setMaxRows(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - return (Connection)this.creatorProxy; │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new SQLException("You cannot operate on a closed Statement!"); │ │ │ │ │ │ + this.inner.setMaxRows(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3746,23 +3724,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final ResultSet executeQuery(final String a) throws SQLException { │ │ │ │ │ │ + public final void setEscapeProcessing(final boolean a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - final ResultSet innerResultSet = this.inner.executeQuery(a); │ │ │ │ │ │ - if (innerResultSet == null) { │ │ │ │ │ │ - return null; │ │ │ │ │ │ - } │ │ │ │ │ │ - this.parentPooledConnection.markActiveResultSetForStatement((Statement)this.inner, innerResultSet); │ │ │ │ │ │ - return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ + this.inner.setEscapeProcessing(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3770,18 +3743,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int executeUpdate(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ + public final int getQueryTimeout() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeUpdate(a, b); │ │ │ │ │ │ + return this.inner.getQueryTimeout(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3789,18 +3762,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int executeUpdate(final String a) throws SQLException { │ │ │ │ │ │ + public final void setQueryTimeout(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeUpdate(a); │ │ │ │ │ │ + this.inner.setQueryTimeout(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3808,18 +3781,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int executeUpdate(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public final SQLWarning getWarnings() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeUpdate(a, b); │ │ │ │ │ │ + return this.inner.getWarnings(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3827,18 +3800,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int executeUpdate(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ + public final void clearWarnings() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeUpdate(a, b); │ │ │ │ │ │ + this.inner.clearWarnings(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3846,18 +3819,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getMaxFieldSize() throws SQLException { │ │ │ │ │ │ + public final void setCursorName(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getMaxFieldSize(); │ │ │ │ │ │ + this.inner.setCursorName(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3865,18 +3838,23 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setMaxFieldSize(final int a) throws SQLException { │ │ │ │ │ │ + public final ResultSet getResultSet() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setMaxFieldSize(a); │ │ │ │ │ │ + final ResultSet innerResultSet = this.inner.getResultSet(); │ │ │ │ │ │ + if (innerResultSet == null) { │ │ │ │ │ │ + return null; │ │ │ │ │ │ + } │ │ │ │ │ │ + this.parentPooledConnection.markActiveResultSetForStatement((Statement)this.inner, innerResultSet); │ │ │ │ │ │ + return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3884,18 +3862,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getMaxRows() throws SQLException { │ │ │ │ │ │ + public final int getUpdateCount() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getMaxRows(); │ │ │ │ │ │ + return this.inner.getUpdateCount(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3903,18 +3881,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setMaxRows(final int a) throws SQLException { │ │ │ │ │ │ + public final boolean getMoreResults() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setMaxRows(a); │ │ │ │ │ │ + return this.inner.getMoreResults(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3922,18 +3900,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setEscapeProcessing(final boolean a) throws SQLException { │ │ │ │ │ │ + public final boolean getMoreResults(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setEscapeProcessing(a); │ │ │ │ │ │ + return this.inner.getMoreResults(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3941,18 +3919,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getQueryTimeout() throws SQLException { │ │ │ │ │ │ + public final void setFetchDirection(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getQueryTimeout(); │ │ │ │ │ │ + this.inner.setFetchDirection(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3960,18 +3938,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setQueryTimeout(final int a) throws SQLException { │ │ │ │ │ │ + public final int getFetchDirection() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setQueryTimeout(a); │ │ │ │ │ │ + return this.inner.getFetchDirection(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3979,18 +3957,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final SQLWarning getWarnings() throws SQLException { │ │ │ │ │ │ + public final void setFetchSize(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getWarnings(); │ │ │ │ │ │ + this.inner.setFetchSize(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3998,18 +3976,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void clearWarnings() throws SQLException { │ │ │ │ │ │ + public final int getFetchSize() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.clearWarnings(); │ │ │ │ │ │ + return this.inner.getFetchSize(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4017,18 +3995,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setCursorName(final String a) throws SQLException { │ │ │ │ │ │ + public final int getResultSetConcurrency() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setCursorName(a); │ │ │ │ │ │ + return this.inner.getResultSetConcurrency(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4036,23 +4014,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final ResultSet getResultSet() throws SQLException { │ │ │ │ │ │ + public final int getResultSetType() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - final ResultSet innerResultSet = this.inner.getResultSet(); │ │ │ │ │ │ - if (innerResultSet == null) { │ │ │ │ │ │ - return null; │ │ │ │ │ │ - } │ │ │ │ │ │ - this.parentPooledConnection.markActiveResultSetForStatement((Statement)this.inner, innerResultSet); │ │ │ │ │ │ - return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ + return this.inner.getResultSetType(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4060,18 +4033,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getUpdateCount() throws SQLException { │ │ │ │ │ │ + public final void addBatch(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getUpdateCount(); │ │ │ │ │ │ + this.inner.addBatch(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4079,18 +4052,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean getMoreResults() throws SQLException { │ │ │ │ │ │ + public final void clearBatch() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getMoreResults(); │ │ │ │ │ │ + this.inner.clearBatch(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4098,18 +4071,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean getMoreResults(final int a) throws SQLException { │ │ │ │ │ │ + public final int[] executeBatch() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getMoreResults(a); │ │ │ │ │ │ + return this.inner.executeBatch(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4117,18 +4090,23 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setFetchDirection(final int a) throws SQLException { │ │ │ │ │ │ + public final ResultSet getGeneratedKeys() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setFetchDirection(a); │ │ │ │ │ │ + final ResultSet innerResultSet = this.inner.getGeneratedKeys(); │ │ │ │ │ │ + if (innerResultSet == null) { │ │ │ │ │ │ + return null; │ │ │ │ │ │ + } │ │ │ │ │ │ + this.parentPooledConnection.markActiveResultSetForStatement((Statement)this.inner, innerResultSet); │ │ │ │ │ │ + return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4136,18 +4114,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getFetchDirection() throws SQLException { │ │ │ │ │ │ + public final int getResultSetHoldability() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getFetchDirection(); │ │ │ │ │ │ + return this.inner.getResultSetHoldability(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4155,18 +4133,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setFetchSize(final int a) throws SQLException { │ │ │ │ │ │ + public final void setPoolable(final boolean a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setFetchSize(a); │ │ │ │ │ │ + this.inner.setPoolable(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4174,18 +4152,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getFetchSize() throws SQLException { │ │ │ │ │ │ + public final boolean isPoolable() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getFetchSize(); │ │ │ │ │ │ + return this.inner.isPoolable(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4193,18 +4171,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getResultSetConcurrency() throws SQLException { │ │ │ │ │ │ + public final void closeOnCompletion() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getResultSetConcurrency(); │ │ │ │ │ │ + this.inner.closeOnCompletion(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4212,18 +4190,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getResultSetType() throws SQLException { │ │ │ │ │ │ + public final boolean isCloseOnCompletion() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getResultSetType(); │ │ │ │ │ │ + return this.inner.isCloseOnCompletion(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4231,18 +4209,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void addBatch(final String a) throws SQLException { │ │ │ │ │ │ + public final long getLargeUpdateCount() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.addBatch(a); │ │ │ │ │ │ + return this.inner.getLargeUpdateCount(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4250,18 +4228,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void clearBatch() throws SQLException { │ │ │ │ │ │ + public final void setLargeMaxRows(final long a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.clearBatch(); │ │ │ │ │ │ + this.inner.setLargeMaxRows(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4269,18 +4247,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int[] executeBatch() throws SQLException { │ │ │ │ │ │ + public final long getLargeMaxRows() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeBatch(); │ │ │ │ │ │ + return this.inner.getLargeMaxRows(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4288,23 +4266,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final ResultSet getGeneratedKeys() throws SQLException { │ │ │ │ │ │ + public final long[] executeLargeBatch() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - final ResultSet innerResultSet = this.inner.getGeneratedKeys(); │ │ │ │ │ │ - if (innerResultSet == null) { │ │ │ │ │ │ - return null; │ │ │ │ │ │ - } │ │ │ │ │ │ - this.parentPooledConnection.markActiveResultSetForStatement((Statement)this.inner, innerResultSet); │ │ │ │ │ │ - return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ + return this.inner.executeLargeBatch(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4312,18 +4285,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getResultSetHoldability() throws SQLException { │ │ │ │ │ │ + public final long executeLargeUpdate(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getResultSetHoldability(); │ │ │ │ │ │ + return this.inner.executeLargeUpdate(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4331,18 +4304,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setPoolable(final boolean a) throws SQLException { │ │ │ │ │ │ + public final long executeLargeUpdate(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setPoolable(a); │ │ │ │ │ │ + return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4350,18 +4323,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean isPoolable() throws SQLException { │ │ │ │ │ │ + public final long executeLargeUpdate(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.isPoolable(); │ │ │ │ │ │ + return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4369,18 +4342,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void closeOnCompletion() throws SQLException { │ │ │ │ │ │ + public final long executeLargeUpdate(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.closeOnCompletion(); │ │ │ │ │ │ + return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4388,18 +4361,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean isCloseOnCompletion() throws SQLException { │ │ │ │ │ │ + public final String enquoteLiteral(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.isCloseOnCompletion(); │ │ │ │ │ │ + return this.inner.enquoteLiteral(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4407,18 +4380,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final long getLargeUpdateCount() throws SQLException { │ │ │ │ │ │ + public final String enquoteIdentifier(final String a, final boolean b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getLargeUpdateCount(); │ │ │ │ │ │ + return this.inner.enquoteIdentifier(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4426,18 +4399,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setLargeMaxRows(final long a) throws SQLException { │ │ │ │ │ │ + public final boolean isSimpleIdentifier(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setLargeMaxRows(a); │ │ │ │ │ │ + return this.inner.isSimpleIdentifier(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4445,18 +4418,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final long getLargeMaxRows() throws SQLException { │ │ │ │ │ │ + public final String enquoteNCharLiteral(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getLargeMaxRows(); │ │ │ │ │ │ + return this.inner.enquoteNCharLiteral(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4464,18 +4437,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final long[] executeLargeBatch() throws SQLException { │ │ │ │ │ │ + public final boolean execute(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeBatch(); │ │ │ │ │ │ + return this.inner.execute(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4483,18 +4456,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final long executeLargeUpdate(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ + public final boolean execute(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ + return this.inner.execute(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4502,18 +4475,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final long executeLargeUpdate(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ + public final boolean execute(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ + return this.inner.execute(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4521,18 +4494,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final long executeLargeUpdate(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public final boolean execute(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ + return this.inner.execute(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4540,37 +4513,56 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final long executeLargeUpdate(final String a) throws SQLException { │ │ │ │ │ │ + public final void close() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeUpdate(a); │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + if (this.is_cached) { │ │ │ │ │ │ + this.parentPooledConnection.checkinStatement((Statement)this.inner); │ │ │ │ │ │ + } │ │ │ │ │ │ + else { │ │ │ │ │ │ + this.parentPooledConnection.markInactiveUncachedStatement((Statement)this.inner); │ │ │ │ │ │ + try { │ │ │ │ │ │ + this.inner.close(); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception e) { │ │ │ │ │ │ + if (NewProxyCallableStatement.logger.isLoggable(MLevel.WARNING)) { │ │ │ │ │ │ + NewProxyCallableStatement.logger.log(MLevel.WARNING, "Exception on close of inner statement.", (Throwable)e); │ │ │ │ │ │ + } │ │ │ │ │ │ + final SQLException sqle = SqlUtils.toSQLException((Throwable)e); │ │ │ │ │ │ + throw sqle; │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + this.detach(); │ │ │ │ │ │ + this.inner = null; │ │ │ │ │ │ + this.creatorProxy = null; │ │ │ │ │ │ + } │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ catch (final Exception exc2) { │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final String enquoteLiteral(final String a) throws SQLException { │ │ │ │ │ │ + public final void cancel() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.enquoteLiteral(a); │ │ │ │ │ │ + this.inner.cancel(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4578,18 +4570,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final String enquoteIdentifier(final String a, final boolean b) throws SQLException { │ │ │ │ │ │ + public final boolean isClosed() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.enquoteIdentifier(a, b); │ │ │ │ │ │ + return this.isDetached(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4597,18 +4589,21 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean isSimpleIdentifier(final String a) throws SQLException { │ │ │ │ │ │ + public final Connection getConnection() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.isSimpleIdentifier(a); │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + return (Connection)this.creatorProxy; │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new SQLException("You cannot operate on a closed Statement!"); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4616,18 +4611,23 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final String enquoteNCharLiteral(final String a) throws SQLException { │ │ │ │ │ │ + public final ResultSet executeQuery(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.enquoteNCharLiteral(a); │ │ │ │ │ │ + final ResultSet innerResultSet = this.inner.executeQuery(a); │ │ │ │ │ │ + if (innerResultSet == null) { │ │ │ │ │ │ + return null; │ │ │ │ │ │ + } │ │ │ │ │ │ + this.parentPooledConnection.markActiveResultSetForStatement((Statement)this.inner, innerResultSet); │ │ │ │ │ │ + return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4635,18 +4635,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final Object unwrap(final Class a) throws SQLException { │ │ │ │ │ │ + public final boolean isWrapperFor(final Class a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.unwrap((Class)a); │ │ │ │ │ │ + return this.inner.isWrapperFor(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4654,18 +4654,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean isWrapperFor(final Class a) throws SQLException { │ │ │ │ │ │ + public final Object unwrap(final Class a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.isWrapperFor(a); │ │ │ │ │ │ + return this.inner.unwrap((Class)a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ ├── com/mchange/v2/c3p0/impl/NewProxyConnection.class │ │ │ │ │ ├── procyon -ec {} │ │ │ │ │ │ @@ -1,33 +1,33 @@ │ │ │ │ │ │ │ │ │ │ │ │ package com.mchange.v2.c3p0.impl; │ │ │ │ │ │ │ │ │ │ │ │ import com.mchange.v2.log.MLog; │ │ │ │ │ │ import java.lang.reflect.InvocationTargetException; │ │ │ │ │ │ import java.sql.ResultSet; │ │ │ │ │ │ +import java.sql.CallableStatement; │ │ │ │ │ │ +import java.lang.reflect.Method; │ │ │ │ │ │ +import com.mchange.v2.util.ResourceClosedException; │ │ │ │ │ │ +import com.mchange.v2.log.MLevel; │ │ │ │ │ │ +import java.sql.PreparedStatement; │ │ │ │ │ │ +import java.sql.Statement; │ │ │ │ │ │ import java.sql.ShardingKey; │ │ │ │ │ │ +import java.util.concurrent.Executor; │ │ │ │ │ │ import java.sql.Struct; │ │ │ │ │ │ import java.sql.Array; │ │ │ │ │ │ import java.sql.SQLClientInfoException; │ │ │ │ │ │ import java.util.Properties; │ │ │ │ │ │ import java.sql.SQLXML; │ │ │ │ │ │ import java.sql.NClob; │ │ │ │ │ │ import java.sql.Blob; │ │ │ │ │ │ import java.sql.Clob; │ │ │ │ │ │ -import java.sql.SQLWarning; │ │ │ │ │ │ import java.sql.Savepoint; │ │ │ │ │ │ import java.util.Map; │ │ │ │ │ │ -import java.sql.CallableStatement; │ │ │ │ │ │ -import java.lang.reflect.Method; │ │ │ │ │ │ -import com.mchange.v2.util.ResourceClosedException; │ │ │ │ │ │ -import com.mchange.v2.log.MLevel; │ │ │ │ │ │ -import java.sql.PreparedStatement; │ │ │ │ │ │ -import java.sql.Statement; │ │ │ │ │ │ -import java.util.concurrent.Executor; │ │ │ │ │ │ import java.sql.SQLException; │ │ │ │ │ │ +import java.sql.SQLWarning; │ │ │ │ │ │ import javax.sql.ConnectionEventListener; │ │ │ │ │ │ import com.mchange.v2.log.MLogger; │ │ │ │ │ │ import java.sql.DatabaseMetaData; │ │ │ │ │ │ import com.mchange.v2.c3p0.C3P0ProxyConnection; │ │ │ │ │ │ import java.sql.Connection; │ │ │ │ │ │ │ │ │ │ │ │ public final class NewProxyConnection implements Connection, C3P0ProxyConnection │ │ │ │ │ │ @@ -43,18 +43,18 @@ │ │ │ │ │ │ this.txn_known_resolved = true; │ │ │ │ │ │ this.metaData = null; │ │ │ │ │ │ this.cel = (ConnectionEventListener)new NewProxyConnection.NewProxyConnection$1(this); │ │ │ │ │ │ this.inner = inner; │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void setReadOnly(final boolean a) throws SQLException { │ │ │ │ │ │ + public synchronized SQLWarning getWarnings() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.inner.setReadOnly(a); │ │ │ │ │ │ - this.parentPooledConnection.markNewReadOnly(a); │ │ │ │ │ │ + this.txn_known_resolved = false; │ │ │ │ │ │ + return this.inner.getWarnings(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -63,41 +63,38 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void close() throws SQLException { │ │ │ │ │ │ + public synchronized void clearWarnings() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - final NewPooledConnection npc = this.parentPooledConnection; │ │ │ │ │ │ - this.detach(); │ │ │ │ │ │ - npc.markClosedProxyConnection(this, this.txn_known_resolved); │ │ │ │ │ │ - this.inner = null; │ │ │ │ │ │ - } │ │ │ │ │ │ + this.txn_known_resolved = false; │ │ │ │ │ │ + this.inner.clearWarnings(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ catch (final Exception exc2) { │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized boolean isReadOnly() throws SQLException { │ │ │ │ │ │ + public synchronized String nativeSQL(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.isReadOnly(); │ │ │ │ │ │ + return this.inner.nativeSQL(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -106,18 +103,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized boolean isValid(final int a) throws SQLException { │ │ │ │ │ │ + public synchronized boolean getAutoCommit() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.isValid(a); │ │ │ │ │ │ + return this.inner.getAutoCommit(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -126,18 +123,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void commit() throws SQLException { │ │ │ │ │ │ + public synchronized String getCatalog() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.txn_known_resolved = true; │ │ │ │ │ │ - this.inner.commit(); │ │ │ │ │ │ + this.txn_known_resolved = false; │ │ │ │ │ │ + return this.inner.getCatalog(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -146,18 +143,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void abort(final Executor a) throws SQLException { │ │ │ │ │ │ + public synchronized int getTransactionIsolation() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - this.inner.abort(a); │ │ │ │ │ │ + return this.inner.getTransactionIsolation(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -166,20 +163,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized Statement createStatement(final int a, final int b, final int c) throws SQLException { │ │ │ │ │ │ + public synchronized Map getTypeMap() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - final Statement innerStmt = this.inner.createStatement(a, b, c); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement(innerStmt); │ │ │ │ │ │ - return (Statement)new NewProxyStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + return this.inner.getTypeMap(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -188,20 +183,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized Statement createStatement() throws SQLException { │ │ │ │ │ │ + public synchronized int getHoldability() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - final Statement innerStmt = this.inner.createStatement(); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement(innerStmt); │ │ │ │ │ │ - return (Statement)new NewProxyStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + return this.inner.getHoldability(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -210,20 +203,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized Statement createStatement(final int a, final int b) throws SQLException { │ │ │ │ │ │ + public synchronized Savepoint setSavepoint(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - final Statement innerStmt = this.inner.createStatement(a, b); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement(innerStmt); │ │ │ │ │ │ - return (Statement)new NewProxyStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + return this.inner.setSavepoint(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -232,37 +223,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized PreparedStatement prepareStatement(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ + public synchronized Savepoint setSavepoint() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ - try { │ │ │ │ │ │ - final Class[] argTypes = { String.class, int[].class }; │ │ │ │ │ │ - final Method method = Connection.class.getMethod("prepareStatement", (Class[])argTypes); │ │ │ │ │ │ - final Object[] args = { a, b }; │ │ │ │ │ │ - final PreparedStatement innerStmt = (PreparedStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final ResourceClosedException e) { │ │ │ │ │ │ - if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ - NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a Statement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ - } │ │ │ │ │ │ - final PreparedStatement innerStmt = this.inner.prepareStatement(a, b); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - final PreparedStatement innerStmt = this.inner.prepareStatement(a, b); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + return this.inner.setSavepoint(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -271,37 +243,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized PreparedStatement prepareStatement(final String a) throws SQLException { │ │ │ │ │ │ + public synchronized void releaseSavepoint(final Savepoint a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ - try { │ │ │ │ │ │ - final Class[] argTypes = { String.class }; │ │ │ │ │ │ - final Method method = Connection.class.getMethod("prepareStatement", (Class[])argTypes); │ │ │ │ │ │ - final Object[] args = { a }; │ │ │ │ │ │ - final PreparedStatement innerStmt = (PreparedStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final ResourceClosedException e) { │ │ │ │ │ │ - if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ - NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a Statement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ - } │ │ │ │ │ │ - final PreparedStatement innerStmt = this.inner.prepareStatement(a); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - final PreparedStatement innerStmt = this.inner.prepareStatement(a); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + this.inner.releaseSavepoint(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -310,37 +263,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized PreparedStatement prepareStatement(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public synchronized Clob createClob() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ - try { │ │ │ │ │ │ - final Class[] argTypes = { String.class, Integer.TYPE }; │ │ │ │ │ │ - final Method method = Connection.class.getMethod("prepareStatement", (Class[])argTypes); │ │ │ │ │ │ - final Object[] args = { a, new Integer(b) }; │ │ │ │ │ │ - final PreparedStatement innerStmt = (PreparedStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final ResourceClosedException e) { │ │ │ │ │ │ - if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ - NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a Statement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ - } │ │ │ │ │ │ - final PreparedStatement innerStmt = this.inner.prepareStatement(a, b); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - final PreparedStatement innerStmt = this.inner.prepareStatement(a, b); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + return this.inner.createClob(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -349,37 +283,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized PreparedStatement prepareStatement(final String a, final int b, final int c, final int d) throws SQLException { │ │ │ │ │ │ + public synchronized Blob createBlob() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ - try { │ │ │ │ │ │ - final Class[] argTypes = { String.class, Integer.TYPE, Integer.TYPE, Integer.TYPE }; │ │ │ │ │ │ - final Method method = Connection.class.getMethod("prepareStatement", (Class[])argTypes); │ │ │ │ │ │ - final Object[] args = { a, new Integer(b), new Integer(c), new Integer(d) }; │ │ │ │ │ │ - final PreparedStatement innerStmt = (PreparedStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final ResourceClosedException e) { │ │ │ │ │ │ - if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ - NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a Statement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ - } │ │ │ │ │ │ - final PreparedStatement innerStmt = this.inner.prepareStatement(a, b, c, d); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - final PreparedStatement innerStmt = this.inner.prepareStatement(a, b, c, d); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + return this.inner.createBlob(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -388,37 +303,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized PreparedStatement prepareStatement(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ + public synchronized NClob createNClob() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ - try { │ │ │ │ │ │ - final Class[] argTypes = { String.class, String[].class }; │ │ │ │ │ │ - final Method method = Connection.class.getMethod("prepareStatement", (Class[])argTypes); │ │ │ │ │ │ - final Object[] args = { a, b }; │ │ │ │ │ │ - final PreparedStatement innerStmt = (PreparedStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final ResourceClosedException e) { │ │ │ │ │ │ - if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ - NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a Statement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ - } │ │ │ │ │ │ - final PreparedStatement innerStmt = this.inner.prepareStatement(a, b); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - final PreparedStatement innerStmt = this.inner.prepareStatement(a, b); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + return this.inner.createNClob(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -427,37 +323,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized PreparedStatement prepareStatement(final String a, final int b, final int c) throws SQLException { │ │ │ │ │ │ + public synchronized SQLXML createSQLXML() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ - try { │ │ │ │ │ │ - final Class[] argTypes = { String.class, Integer.TYPE, Integer.TYPE }; │ │ │ │ │ │ - final Method method = Connection.class.getMethod("prepareStatement", (Class[])argTypes); │ │ │ │ │ │ - final Object[] args = { a, new Integer(b), new Integer(c) }; │ │ │ │ │ │ - final PreparedStatement innerStmt = (PreparedStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final ResourceClosedException e) { │ │ │ │ │ │ - if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ - NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a Statement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ - } │ │ │ │ │ │ - final PreparedStatement innerStmt = this.inner.prepareStatement(a, b, c); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - final PreparedStatement innerStmt = this.inner.prepareStatement(a, b, c); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + return this.inner.createSQLXML(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -466,37 +343,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized CallableStatement prepareCall(final String a) throws SQLException { │ │ │ │ │ │ + public synchronized void setClientInfo(final Properties a) throws SQLClientInfoException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ - try { │ │ │ │ │ │ - final Class[] argTypes = { String.class }; │ │ │ │ │ │ - final Method method = Connection.class.getMethod("prepareCall", (Class[])argTypes); │ │ │ │ │ │ - final Object[] args = { a }; │ │ │ │ │ │ - final CallableStatement innerStmt = (CallableStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ - return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final ResourceClosedException e) { │ │ │ │ │ │ - if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ - NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a CallableStatement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ - } │ │ │ │ │ │ - final CallableStatement innerStmt = this.inner.prepareCall(a); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - final CallableStatement innerStmt = this.inner.prepareCall(a); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + this.inner.setClientInfo(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -505,37 +363,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized CallableStatement prepareCall(final String a, final int b, final int c, final int d) throws SQLException { │ │ │ │ │ │ + public synchronized void setClientInfo(final String a, final String b) throws SQLClientInfoException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ - try { │ │ │ │ │ │ - final Class[] argTypes = { String.class, Integer.TYPE, Integer.TYPE, Integer.TYPE }; │ │ │ │ │ │ - final Method method = Connection.class.getMethod("prepareCall", (Class[])argTypes); │ │ │ │ │ │ - final Object[] args = { a, new Integer(b), new Integer(c), new Integer(d) }; │ │ │ │ │ │ - final CallableStatement innerStmt = (CallableStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ - return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final ResourceClosedException e) { │ │ │ │ │ │ - if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ - NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a CallableStatement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ - } │ │ │ │ │ │ - final CallableStatement innerStmt = this.inner.prepareCall(a, b, c, d); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - final CallableStatement innerStmt = this.inner.prepareCall(a, b, c, d); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + this.inner.setClientInfo(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -544,37 +383,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized CallableStatement prepareCall(final String a, final int b, final int c) throws SQLException { │ │ │ │ │ │ + public synchronized Properties getClientInfo() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ - try { │ │ │ │ │ │ - final Class[] argTypes = { String.class, Integer.TYPE, Integer.TYPE }; │ │ │ │ │ │ - final Method method = Connection.class.getMethod("prepareCall", (Class[])argTypes); │ │ │ │ │ │ - final Object[] args = { a, new Integer(b), new Integer(c) }; │ │ │ │ │ │ - final CallableStatement innerStmt = (CallableStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ - return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final ResourceClosedException e) { │ │ │ │ │ │ - if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ - NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a CallableStatement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ - } │ │ │ │ │ │ - final CallableStatement innerStmt = this.inner.prepareCall(a, b, c); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - final CallableStatement innerStmt = this.inner.prepareCall(a, b, c); │ │ │ │ │ │ - this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ - return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + return this.inner.getClientInfo(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -583,22 +403,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized DatabaseMetaData getMetaData() throws SQLException { │ │ │ │ │ │ + public synchronized String getClientInfo(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - if (this.metaData == null) { │ │ │ │ │ │ - final DatabaseMetaData innerMetaData = this.inner.getMetaData(); │ │ │ │ │ │ - this.metaData = (DatabaseMetaData)new NewProxyDatabaseMetaData(innerMetaData, this.parentPooledConnection, this); │ │ │ │ │ │ - } │ │ │ │ │ │ - return this.metaData; │ │ │ │ │ │ + return this.inner.getClientInfo(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -607,18 +423,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void setTransactionIsolation(final int a) throws SQLException { │ │ │ │ │ │ + public synchronized Array createArrayOf(final String a, final Object[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.inner.setTransactionIsolation(a); │ │ │ │ │ │ - this.parentPooledConnection.markNewTxnIsolation(a); │ │ │ │ │ │ + this.txn_known_resolved = false; │ │ │ │ │ │ + return this.inner.createArrayOf(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -627,18 +443,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void setCatalog(final String a) throws SQLException { │ │ │ │ │ │ + public synchronized Struct createStruct(final String a, final Object[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.inner.setCatalog(a); │ │ │ │ │ │ - this.parentPooledConnection.markNewCatalog(a); │ │ │ │ │ │ + this.txn_known_resolved = false; │ │ │ │ │ │ + return this.inner.createStruct(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -647,18 +463,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void setHoldability(final int a) throws SQLException { │ │ │ │ │ │ + public synchronized void setSchema(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.inner.setHoldability(a); │ │ │ │ │ │ - this.parentPooledConnection.markNewHoldability(a); │ │ │ │ │ │ + this.txn_known_resolved = false; │ │ │ │ │ │ + this.inner.setSchema(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -667,18 +483,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void setTypeMap(final Map a) throws SQLException { │ │ │ │ │ │ + public synchronized String getSchema() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.inner.setTypeMap(a); │ │ │ │ │ │ - this.parentPooledConnection.markNewTypeMap(a); │ │ │ │ │ │ + this.txn_known_resolved = false; │ │ │ │ │ │ + return this.inner.getSchema(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -687,17 +503,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized boolean isClosed() throws SQLException { │ │ │ │ │ │ + public synchronized void setNetworkTimeout(final Executor a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - return this.isDetached(); │ │ │ │ │ │ + this.txn_known_resolved = false; │ │ │ │ │ │ + this.inner.setNetworkTimeout(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -706,18 +523,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void rollback(final Savepoint a) throws SQLException { │ │ │ │ │ │ + public synchronized int getNetworkTimeout() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.txn_known_resolved = true; │ │ │ │ │ │ - this.inner.rollback(a); │ │ │ │ │ │ + this.txn_known_resolved = false; │ │ │ │ │ │ + return this.inner.getNetworkTimeout(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -726,18 +543,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void rollback() throws SQLException { │ │ │ │ │ │ + public synchronized void beginRequest() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.txn_known_resolved = true; │ │ │ │ │ │ - this.inner.rollback(); │ │ │ │ │ │ + this.txn_known_resolved = false; │ │ │ │ │ │ + this.inner.beginRequest(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -746,18 +563,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void setAutoCommit(final boolean a) throws SQLException { │ │ │ │ │ │ + public synchronized void endRequest() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.txn_known_resolved = true; │ │ │ │ │ │ - this.inner.setAutoCommit(a); │ │ │ │ │ │ + this.txn_known_resolved = false; │ │ │ │ │ │ + this.inner.endRequest(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -766,18 +583,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized SQLWarning getWarnings() throws SQLException { │ │ │ │ │ │ + public synchronized boolean setShardingKeyIfValid(final ShardingKey a, final ShardingKey b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.getWarnings(); │ │ │ │ │ │ + return this.inner.setShardingKeyIfValid(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -786,18 +603,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void clearWarnings() throws SQLException { │ │ │ │ │ │ + public synchronized boolean setShardingKeyIfValid(final ShardingKey a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - this.inner.clearWarnings(); │ │ │ │ │ │ + return this.inner.setShardingKeyIfValid(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -806,18 +623,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized String nativeSQL(final String a) throws SQLException { │ │ │ │ │ │ + public synchronized void setShardingKey(final ShardingKey a, final ShardingKey b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.nativeSQL(a); │ │ │ │ │ │ + this.inner.setShardingKey(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -826,18 +643,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized boolean getAutoCommit() throws SQLException { │ │ │ │ │ │ + public synchronized void setShardingKey(final ShardingKey a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.getAutoCommit(); │ │ │ │ │ │ + this.inner.setShardingKey(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -846,18 +663,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized String getCatalog() throws SQLException { │ │ │ │ │ │ + public synchronized void setReadOnly(final boolean a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.getCatalog(); │ │ │ │ │ │ + this.inner.setReadOnly(a); │ │ │ │ │ │ + this.parentPooledConnection.markNewReadOnly(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -866,38 +683,41 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized int getTransactionIsolation() throws SQLException { │ │ │ │ │ │ + public synchronized void close() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.getTransactionIsolation(); │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + final NewPooledConnection npc = this.parentPooledConnection; │ │ │ │ │ │ + this.detach(); │ │ │ │ │ │ + npc.markClosedProxyConnection(this, this.txn_known_resolved); │ │ │ │ │ │ + this.inner = null; │ │ │ │ │ │ + } │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ catch (final Exception exc2) { │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized Map getTypeMap() throws SQLException { │ │ │ │ │ │ + public synchronized boolean isReadOnly() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.getTypeMap(); │ │ │ │ │ │ + return this.inner.isReadOnly(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -906,18 +726,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized int getHoldability() throws SQLException { │ │ │ │ │ │ + public synchronized boolean isValid(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.getHoldability(); │ │ │ │ │ │ + return this.inner.isValid(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -926,18 +746,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized Savepoint setSavepoint() throws SQLException { │ │ │ │ │ │ + public synchronized void commit() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.setSavepoint(); │ │ │ │ │ │ + this.txn_known_resolved = true; │ │ │ │ │ │ + this.inner.commit(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -946,18 +766,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized Savepoint setSavepoint(final String a) throws SQLException { │ │ │ │ │ │ + public synchronized void abort(final Executor a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.setSavepoint(a); │ │ │ │ │ │ + this.inner.abort(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -966,18 +786,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void releaseSavepoint(final Savepoint a) throws SQLException { │ │ │ │ │ │ + public synchronized Statement createStatement() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - this.inner.releaseSavepoint(a); │ │ │ │ │ │ + final Statement innerStmt = this.inner.createStatement(); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement(innerStmt); │ │ │ │ │ │ + return (Statement)new NewProxyStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -986,18 +808,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized Clob createClob() throws SQLException { │ │ │ │ │ │ + public synchronized Statement createStatement(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.createClob(); │ │ │ │ │ │ + final Statement innerStmt = this.inner.createStatement(a, b); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement(innerStmt); │ │ │ │ │ │ + return (Statement)new NewProxyStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1006,18 +830,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized Blob createBlob() throws SQLException { │ │ │ │ │ │ + public synchronized Statement createStatement(final int a, final int b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.createBlob(); │ │ │ │ │ │ + final Statement innerStmt = this.inner.createStatement(a, b, c); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement(innerStmt); │ │ │ │ │ │ + return (Statement)new NewProxyStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1026,18 +852,37 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized NClob createNClob() throws SQLException { │ │ │ │ │ │ + public synchronized PreparedStatement prepareStatement(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.createNClob(); │ │ │ │ │ │ + if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ + try { │ │ │ │ │ │ + final Class[] argTypes = { String.class, Integer.TYPE }; │ │ │ │ │ │ + final Method method = Connection.class.getMethod("prepareStatement", (Class[])argTypes); │ │ │ │ │ │ + final Object[] args = { a, new Integer(b) }; │ │ │ │ │ │ + final PreparedStatement innerStmt = (PreparedStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final ResourceClosedException e) { │ │ │ │ │ │ + if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ + NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a Statement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ + } │ │ │ │ │ │ + final PreparedStatement innerStmt = this.inner.prepareStatement(a, b); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + final PreparedStatement innerStmt = this.inner.prepareStatement(a, b); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1046,18 +891,37 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized SQLXML createSQLXML() throws SQLException { │ │ │ │ │ │ + public synchronized PreparedStatement prepareStatement(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.createSQLXML(); │ │ │ │ │ │ + if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ + try { │ │ │ │ │ │ + final Class[] argTypes = { String.class, int[].class }; │ │ │ │ │ │ + final Method method = Connection.class.getMethod("prepareStatement", (Class[])argTypes); │ │ │ │ │ │ + final Object[] args = { a, b }; │ │ │ │ │ │ + final PreparedStatement innerStmt = (PreparedStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final ResourceClosedException e) { │ │ │ │ │ │ + if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ + NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a Statement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ + } │ │ │ │ │ │ + final PreparedStatement innerStmt = this.inner.prepareStatement(a, b); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + final PreparedStatement innerStmt = this.inner.prepareStatement(a, b); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1066,18 +930,37 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void setClientInfo(final Properties a) throws SQLClientInfoException { │ │ │ │ │ │ + public synchronized PreparedStatement prepareStatement(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - this.inner.setClientInfo(a); │ │ │ │ │ │ + if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ + try { │ │ │ │ │ │ + final Class[] argTypes = { String.class, String[].class }; │ │ │ │ │ │ + final Method method = Connection.class.getMethod("prepareStatement", (Class[])argTypes); │ │ │ │ │ │ + final Object[] args = { a, b }; │ │ │ │ │ │ + final PreparedStatement innerStmt = (PreparedStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final ResourceClosedException e) { │ │ │ │ │ │ + if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ + NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a Statement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ + } │ │ │ │ │ │ + final PreparedStatement innerStmt = this.inner.prepareStatement(a, b); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + final PreparedStatement innerStmt = this.inner.prepareStatement(a, b); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1086,18 +969,37 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void setClientInfo(final String a, final String b) throws SQLClientInfoException { │ │ │ │ │ │ + public synchronized PreparedStatement prepareStatement(final String a, final int b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - this.inner.setClientInfo(a, b); │ │ │ │ │ │ + if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ + try { │ │ │ │ │ │ + final Class[] argTypes = { String.class, Integer.TYPE, Integer.TYPE }; │ │ │ │ │ │ + final Method method = Connection.class.getMethod("prepareStatement", (Class[])argTypes); │ │ │ │ │ │ + final Object[] args = { a, new Integer(b), new Integer(c) }; │ │ │ │ │ │ + final PreparedStatement innerStmt = (PreparedStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final ResourceClosedException e) { │ │ │ │ │ │ + if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ + NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a Statement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ + } │ │ │ │ │ │ + final PreparedStatement innerStmt = this.inner.prepareStatement(a, b, c); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + final PreparedStatement innerStmt = this.inner.prepareStatement(a, b, c); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1106,18 +1008,37 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized Properties getClientInfo() throws SQLException { │ │ │ │ │ │ + public synchronized PreparedStatement prepareStatement(final String a, final int b, final int c, final int d) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.getClientInfo(); │ │ │ │ │ │ + if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ + try { │ │ │ │ │ │ + final Class[] argTypes = { String.class, Integer.TYPE, Integer.TYPE, Integer.TYPE }; │ │ │ │ │ │ + final Method method = Connection.class.getMethod("prepareStatement", (Class[])argTypes); │ │ │ │ │ │ + final Object[] args = { a, new Integer(b), new Integer(c), new Integer(d) }; │ │ │ │ │ │ + final PreparedStatement innerStmt = (PreparedStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final ResourceClosedException e) { │ │ │ │ │ │ + if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ + NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a Statement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ + } │ │ │ │ │ │ + final PreparedStatement innerStmt = this.inner.prepareStatement(a, b, c, d); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + final PreparedStatement innerStmt = this.inner.prepareStatement(a, b, c, d); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1126,18 +1047,37 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized String getClientInfo(final String a) throws SQLException { │ │ │ │ │ │ + public synchronized PreparedStatement prepareStatement(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.getClientInfo(a); │ │ │ │ │ │ + if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ + try { │ │ │ │ │ │ + final Class[] argTypes = { String.class }; │ │ │ │ │ │ + final Method method = Connection.class.getMethod("prepareStatement", (Class[])argTypes); │ │ │ │ │ │ + final Object[] args = { a }; │ │ │ │ │ │ + final PreparedStatement innerStmt = (PreparedStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final ResourceClosedException e) { │ │ │ │ │ │ + if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ + NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a Statement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ + } │ │ │ │ │ │ + final PreparedStatement innerStmt = this.inner.prepareStatement(a); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + final PreparedStatement innerStmt = this.inner.prepareStatement(a); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (PreparedStatement)new NewProxyPreparedStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1146,18 +1086,37 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized Array createArrayOf(final String a, final Object[] b) throws SQLException { │ │ │ │ │ │ + public synchronized CallableStatement prepareCall(final String a, final int b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.createArrayOf(a, b); │ │ │ │ │ │ + if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ + try { │ │ │ │ │ │ + final Class[] argTypes = { String.class, Integer.TYPE, Integer.TYPE }; │ │ │ │ │ │ + final Method method = Connection.class.getMethod("prepareCall", (Class[])argTypes); │ │ │ │ │ │ + final Object[] args = { a, new Integer(b), new Integer(c) }; │ │ │ │ │ │ + final CallableStatement innerStmt = (CallableStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ + return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final ResourceClosedException e) { │ │ │ │ │ │ + if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ + NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a CallableStatement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ + } │ │ │ │ │ │ + final CallableStatement innerStmt = this.inner.prepareCall(a, b, c); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + final CallableStatement innerStmt = this.inner.prepareCall(a, b, c); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1166,18 +1125,37 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized Struct createStruct(final String a, final Object[] b) throws SQLException { │ │ │ │ │ │ + public synchronized CallableStatement prepareCall(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.createStruct(a, b); │ │ │ │ │ │ + if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ + try { │ │ │ │ │ │ + final Class[] argTypes = { String.class }; │ │ │ │ │ │ + final Method method = Connection.class.getMethod("prepareCall", (Class[])argTypes); │ │ │ │ │ │ + final Object[] args = { a }; │ │ │ │ │ │ + final CallableStatement innerStmt = (CallableStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ + return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final ResourceClosedException e) { │ │ │ │ │ │ + if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ + NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a CallableStatement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ + } │ │ │ │ │ │ + final CallableStatement innerStmt = this.inner.prepareCall(a); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + final CallableStatement innerStmt = this.inner.prepareCall(a); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1186,18 +1164,37 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void setSchema(final String a) throws SQLException { │ │ │ │ │ │ + public synchronized CallableStatement prepareCall(final String a, final int b, final int c, final int d) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - this.inner.setSchema(a); │ │ │ │ │ │ + if (this.parentPooledConnection.isStatementCaching()) { │ │ │ │ │ │ + try { │ │ │ │ │ │ + final Class[] argTypes = { String.class, Integer.TYPE, Integer.TYPE, Integer.TYPE }; │ │ │ │ │ │ + final Method method = Connection.class.getMethod("prepareCall", (Class[])argTypes); │ │ │ │ │ │ + final Object[] args = { a, new Integer(b), new Integer(c), new Integer(d) }; │ │ │ │ │ │ + final CallableStatement innerStmt = (CallableStatement)this.parentPooledConnection.checkoutStatement(method, args); │ │ │ │ │ │ + return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, true, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final ResourceClosedException e) { │ │ │ │ │ │ + if (NewProxyConnection.logger.isLoggable(MLevel.FINE)) { │ │ │ │ │ │ + NewProxyConnection.logger.log(MLevel.FINE, "A Connection tried to prepare a CallableStatement via a Statement cache that is already closed. This can happen -- rarely -- if a DataSource is closed or reset() while Connections are checked-out and in use.", (Throwable)e); │ │ │ │ │ │ + } │ │ │ │ │ │ + final CallableStatement innerStmt = this.inner.prepareCall(a, b, c, d); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + final CallableStatement innerStmt = this.inner.prepareCall(a, b, c, d); │ │ │ │ │ │ + this.parentPooledConnection.markActiveUncachedStatement((Statement)innerStmt); │ │ │ │ │ │ + return (CallableStatement)new NewProxyCallableStatement(innerStmt, this.parentPooledConnection, false, this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1206,18 +1203,22 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized String getSchema() throws SQLException { │ │ │ │ │ │ + public synchronized DatabaseMetaData getMetaData() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.getSchema(); │ │ │ │ │ │ + if (this.metaData == null) { │ │ │ │ │ │ + final DatabaseMetaData innerMetaData = this.inner.getMetaData(); │ │ │ │ │ │ + this.metaData = (DatabaseMetaData)new NewProxyDatabaseMetaData(innerMetaData, this.parentPooledConnection, this); │ │ │ │ │ │ + } │ │ │ │ │ │ + return this.metaData; │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1226,18 +1227,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void setNetworkTimeout(final Executor a, final int b) throws SQLException { │ │ │ │ │ │ + public synchronized void setTransactionIsolation(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.txn_known_resolved = false; │ │ │ │ │ │ - this.inner.setNetworkTimeout(a, b); │ │ │ │ │ │ + this.inner.setTransactionIsolation(a); │ │ │ │ │ │ + this.parentPooledConnection.markNewTxnIsolation(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1246,18 +1247,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized int getNetworkTimeout() throws SQLException { │ │ │ │ │ │ + public synchronized void setCatalog(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.getNetworkTimeout(); │ │ │ │ │ │ + this.inner.setCatalog(a); │ │ │ │ │ │ + this.parentPooledConnection.markNewCatalog(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1266,18 +1267,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void beginRequest() throws SQLException { │ │ │ │ │ │ + public synchronized void setHoldability(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.txn_known_resolved = false; │ │ │ │ │ │ - this.inner.beginRequest(); │ │ │ │ │ │ + this.inner.setHoldability(a); │ │ │ │ │ │ + this.parentPooledConnection.markNewHoldability(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1286,18 +1287,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void endRequest() throws SQLException { │ │ │ │ │ │ + public synchronized void setTypeMap(final Map a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.txn_known_resolved = false; │ │ │ │ │ │ - this.inner.endRequest(); │ │ │ │ │ │ + this.inner.setTypeMap(a); │ │ │ │ │ │ + this.parentPooledConnection.markNewTypeMap(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1306,18 +1307,17 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized boolean setShardingKeyIfValid(final ShardingKey a, final ShardingKey b, final int c) throws SQLException { │ │ │ │ │ │ + public synchronized boolean isClosed() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.setShardingKeyIfValid(a, b, c); │ │ │ │ │ │ + return this.isDetached(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1326,18 +1326,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized boolean setShardingKeyIfValid(final ShardingKey a, final int b) throws SQLException { │ │ │ │ │ │ + public synchronized void rollback(final Savepoint a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.setShardingKeyIfValid(a, b); │ │ │ │ │ │ + this.txn_known_resolved = true; │ │ │ │ │ │ + this.inner.rollback(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1346,18 +1346,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void setShardingKey(final ShardingKey a) throws SQLException { │ │ │ │ │ │ + public synchronized void rollback() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.txn_known_resolved = false; │ │ │ │ │ │ - this.inner.setShardingKey(a); │ │ │ │ │ │ + this.txn_known_resolved = true; │ │ │ │ │ │ + this.inner.rollback(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1366,18 +1366,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void setShardingKey(final ShardingKey a, final ShardingKey b) throws SQLException { │ │ │ │ │ │ + public synchronized void setAutoCommit(final boolean a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.txn_known_resolved = false; │ │ │ │ │ │ - this.inner.setShardingKey(a, b); │ │ │ │ │ │ + this.txn_known_resolved = true; │ │ │ │ │ │ + this.inner.setAutoCommit(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1385,18 +1385,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public synchronized Object unwrap(final Class a) throws SQLException { │ │ │ │ │ │ + public synchronized boolean isWrapperFor(final Class a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.unwrap((Class)a); │ │ │ │ │ │ + return this.inner.isWrapperFor(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1404,18 +1404,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public synchronized boolean isWrapperFor(final Class a) throws SQLException { │ │ │ │ │ │ + public synchronized Object unwrap(final Class a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.isWrapperFor(a); │ │ │ │ │ │ + return this.inner.unwrap((Class)a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Connection!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ ├── com/mchange/v2/c3p0/impl/NewProxyDatabaseMetaData.class │ │ │ │ │ ├── procyon -ec {} │ │ │ │ │ │ @@ -1,15 +1,15 @@ │ │ │ │ │ │ │ │ │ │ │ │ package com.mchange.v2.c3p0.impl; │ │ │ │ │ │ │ │ │ │ │ │ import com.mchange.v2.log.MLog; │ │ │ │ │ │ -import java.sql.RowIdLifetime; │ │ │ │ │ │ import java.sql.Connection; │ │ │ │ │ │ -import java.sql.SQLException; │ │ │ │ │ │ +import java.sql.RowIdLifetime; │ │ │ │ │ │ import java.sql.ResultSet; │ │ │ │ │ │ +import java.sql.SQLException; │ │ │ │ │ │ import javax.sql.ConnectionEventListener; │ │ │ │ │ │ import com.mchange.v2.log.MLogger; │ │ │ │ │ │ import java.sql.DatabaseMetaData; │ │ │ │ │ │ │ │ │ │ │ │ public final class NewProxyDatabaseMetaData implements DatabaseMetaData │ │ │ │ │ │ { │ │ │ │ │ │ protected DatabaseMetaData inner; │ │ │ │ │ │ @@ -20,94 +20,14 @@ │ │ │ │ │ │ │ │ │ │ │ │ public NewProxyDatabaseMetaData(final DatabaseMetaData inner) { │ │ │ │ │ │ this.cel = (ConnectionEventListener)new NewProxyDatabaseMetaData.NewProxyDatabaseMetaData$1(this); │ │ │ │ │ │ this.inner = inner; │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final ResultSet getAttributes(final String a, final String b, final String c, final String d) throws SQLException { │ │ │ │ │ │ - try { │ │ │ │ │ │ - final ResultSet innerResultSet = this.inner.getAttributes(a, b, c, d); │ │ │ │ │ │ - if (innerResultSet == null) { │ │ │ │ │ │ - return null; │ │ │ │ │ │ - } │ │ │ │ │ │ - return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed DatabaseMetaData!!!", exc); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception exc2) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - │ │ │ │ │ │ - @Override │ │ │ │ │ │ - public final boolean isReadOnly() throws SQLException { │ │ │ │ │ │ - try { │ │ │ │ │ │ - return this.inner.isReadOnly(); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed DatabaseMetaData!!!", exc); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception exc2) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - │ │ │ │ │ │ - @Override │ │ │ │ │ │ - public final String getURL() throws SQLException { │ │ │ │ │ │ - try { │ │ │ │ │ │ - return this.inner.getURL(); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed DatabaseMetaData!!!", exc); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception exc2) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - │ │ │ │ │ │ - @Override │ │ │ │ │ │ - public final Connection getConnection() throws SQLException { │ │ │ │ │ │ - try { │ │ │ │ │ │ - return (Connection)this.proxyCon; │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed DatabaseMetaData!!!", exc); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception exc2) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new RuntimeException(exc2); │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - │ │ │ │ │ │ - @Override │ │ │ │ │ │ public final int getResultSetHoldability() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ return this.inner.getResultSetHoldability(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed DatabaseMetaData!!!", exc); │ │ │ │ │ │ @@ -756,17 +676,17 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean supportsConvert() throws SQLException { │ │ │ │ │ │ + public final boolean supportsConvert(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - return this.inner.supportsConvert(); │ │ │ │ │ │ + return this.inner.supportsConvert(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed DatabaseMetaData!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -775,17 +695,17 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean supportsConvert(final int a, final int b) throws SQLException { │ │ │ │ │ │ + public final boolean supportsConvert() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - return this.inner.supportsConvert(a, b); │ │ │ │ │ │ + return this.inner.supportsConvert(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed DatabaseMetaData!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2364,17 +2284,17 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final ResultSet getSchemas(final String a, final String b) throws SQLException { │ │ │ │ │ │ + public final ResultSet getSchemas() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - final ResultSet innerResultSet = this.inner.getSchemas(a, b); │ │ │ │ │ │ + final ResultSet innerResultSet = this.inner.getSchemas(); │ │ │ │ │ │ if (innerResultSet == null) { │ │ │ │ │ │ return null; │ │ │ │ │ │ } │ │ │ │ │ │ return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ @@ -2387,17 +2307,17 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final ResultSet getSchemas() throws SQLException { │ │ │ │ │ │ + public final ResultSet getSchemas(final String a, final String b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - final ResultSet innerResultSet = this.inner.getSchemas(); │ │ │ │ │ │ + final ResultSet innerResultSet = this.inner.getSchemas(a, b); │ │ │ │ │ │ if (innerResultSet == null) { │ │ │ │ │ │ return null; │ │ │ │ │ │ } │ │ │ │ │ │ return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ @@ -3459,17 +3379,78 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object unwrap(final Class a) throws SQLException { │ │ │ │ │ │ + public final ResultSet getAttributes(final String a, final String b, final String c, final String d) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - return this.inner.unwrap((Class)a); │ │ │ │ │ │ + final ResultSet innerResultSet = this.inner.getAttributes(a, b, c, d); │ │ │ │ │ │ + if (innerResultSet == null) { │ │ │ │ │ │ + return null; │ │ │ │ │ │ + } │ │ │ │ │ │ + return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final NullPointerException exc) { │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed DatabaseMetaData!!!", exc); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception exc2) { │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + │ │ │ │ │ │ + @Override │ │ │ │ │ │ + public final boolean isReadOnly() throws SQLException { │ │ │ │ │ │ + try { │ │ │ │ │ │ + return this.inner.isReadOnly(); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final NullPointerException exc) { │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed DatabaseMetaData!!!", exc); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception exc2) { │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + │ │ │ │ │ │ + @Override │ │ │ │ │ │ + public final String getURL() throws SQLException { │ │ │ │ │ │ + try { │ │ │ │ │ │ + return this.inner.getURL(); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final NullPointerException exc) { │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed DatabaseMetaData!!!", exc); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception exc2) { │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + │ │ │ │ │ │ + @Override │ │ │ │ │ │ + public final Connection getConnection() throws SQLException { │ │ │ │ │ │ + try { │ │ │ │ │ │ + return (Connection)this.proxyCon; │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed DatabaseMetaData!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3488,14 +3469,33 @@ │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed DatabaseMetaData!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ + catch (final Exception exc2) { │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new RuntimeException(exc2); │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + │ │ │ │ │ │ + @Override │ │ │ │ │ │ + public final Object unwrap(final Class a) throws SQLException { │ │ │ │ │ │ + try { │ │ │ │ │ │ + return this.inner.unwrap((Class)a); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final NullPointerException exc) { │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed DatabaseMetaData!!!", exc); │ │ │ │ │ │ + } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ + } │ │ │ │ │ │ catch (final Exception exc2) { │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ ├── com/mchange/v2/c3p0/impl/NewProxyPreparedStatement.class │ │ │ │ │ ├── procyon -ec {} │ │ │ │ │ │ @@ -1,37 +1,37 @@ │ │ │ │ │ │ │ │ │ │ │ │ package com.mchange.v2.c3p0.impl; │ │ │ │ │ │ │ │ │ │ │ │ import com.mchange.v2.log.MLog; │ │ │ │ │ │ import java.lang.reflect.InvocationTargetException; │ │ │ │ │ │ import java.lang.reflect.Method; │ │ │ │ │ │ -import java.sql.SQLWarning; │ │ │ │ │ │ import java.sql.Connection; │ │ │ │ │ │ import com.mchange.v2.sql.SqlUtils; │ │ │ │ │ │ import com.mchange.v2.log.MLevel; │ │ │ │ │ │ +import java.sql.SQLWarning; │ │ │ │ │ │ +import java.sql.Statement; │ │ │ │ │ │ +import java.sql.ResultSet; │ │ │ │ │ │ +import java.sql.ResultSetMetaData; │ │ │ │ │ │ +import java.sql.Date; │ │ │ │ │ │ +import java.sql.Time; │ │ │ │ │ │ +import java.sql.Array; │ │ │ │ │ │ +import java.net.URL; │ │ │ │ │ │ import java.sql.SQLXML; │ │ │ │ │ │ import java.sql.NClob; │ │ │ │ │ │ import java.sql.RowId; │ │ │ │ │ │ import java.sql.ParameterMetaData; │ │ │ │ │ │ import java.sql.Clob; │ │ │ │ │ │ import java.sql.Blob; │ │ │ │ │ │ import java.sql.Ref; │ │ │ │ │ │ -import java.io.Reader; │ │ │ │ │ │ import java.sql.SQLType; │ │ │ │ │ │ -import java.io.InputStream; │ │ │ │ │ │ +import java.util.Calendar; │ │ │ │ │ │ import java.sql.Timestamp; │ │ │ │ │ │ import java.math.BigDecimal; │ │ │ │ │ │ -import java.sql.Statement; │ │ │ │ │ │ -import java.sql.ResultSet; │ │ │ │ │ │ -import java.sql.ResultSetMetaData; │ │ │ │ │ │ -import java.sql.Date; │ │ │ │ │ │ -import java.util.Calendar; │ │ │ │ │ │ -import java.sql.Time; │ │ │ │ │ │ -import java.sql.Array; │ │ │ │ │ │ -import java.net.URL; │ │ │ │ │ │ +import java.io.Reader; │ │ │ │ │ │ +import java.io.InputStream; │ │ │ │ │ │ import java.sql.SQLException; │ │ │ │ │ │ import javax.sql.ConnectionEventListener; │ │ │ │ │ │ import com.mchange.v2.log.MLogger; │ │ │ │ │ │ import com.mchange.v2.c3p0.C3P0ProxyStatement; │ │ │ │ │ │ import java.sql.PreparedStatement; │ │ │ │ │ │ │ │ │ │ │ │ public final class NewProxyPreparedStatement implements PreparedStatement, C3P0ProxyStatement │ │ │ │ │ │ @@ -45,18 +45,18 @@ │ │ │ │ │ │ │ │ │ │ │ │ public NewProxyPreparedStatement(final PreparedStatement inner) { │ │ │ │ │ │ this.cel = (ConnectionEventListener)new NewProxyPreparedStatement.NewProxyPreparedStatement$1(this); │ │ │ │ │ │ this.inner = inner; │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean execute() throws SQLException { │ │ │ │ │ │ + public final int executeUpdate() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.execute(); │ │ │ │ │ │ + return this.inner.executeUpdate(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -65,18 +65,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBoolean(final int a, final boolean b) throws SQLException { │ │ │ │ │ │ + public final void addBatch() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBoolean(a, b); │ │ │ │ │ │ + this.inner.addBatch(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -85,18 +85,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setByte(final int a, final byte b) throws SQLException { │ │ │ │ │ │ + public final long executeLargeUpdate() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setByte(a, b); │ │ │ │ │ │ + return this.inner.executeLargeUpdate(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -105,18 +105,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setShort(final int a, final short b) throws SQLException { │ │ │ │ │ │ + public final void setString(final int a, final String b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setShort(a, b); │ │ │ │ │ │ + this.inner.setString(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -125,18 +125,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setInt(final int a, final int b) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setInt(a, b); │ │ │ │ │ │ + this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -145,18 +145,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setLong(final int a, final long b) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setLong(a, b); │ │ │ │ │ │ + this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -165,18 +165,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setFloat(final int a, final float b) throws SQLException { │ │ │ │ │ │ + public final void setAsciiStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setFloat(a, b); │ │ │ │ │ │ + this.inner.setAsciiStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -185,18 +185,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setDouble(final int a, final double b) throws SQLException { │ │ │ │ │ │ + public final void setCharacterStream(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDouble(a, b); │ │ │ │ │ │ + this.inner.setCharacterStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -205,18 +205,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setURL(final int a, final URL b) throws SQLException { │ │ │ │ │ │ + public final void setCharacterStream(final int a, final Reader b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setURL(a, b); │ │ │ │ │ │ + this.inner.setCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -225,18 +225,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setArray(final int a, final Array b) throws SQLException { │ │ │ │ │ │ + public final void setCharacterStream(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setArray(a, b); │ │ │ │ │ │ + this.inner.setCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -245,18 +245,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setTime(final int a, final Time b) throws SQLException { │ │ │ │ │ │ + public final void setBytes(final int a, final byte[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTime(a, b); │ │ │ │ │ │ + this.inner.setBytes(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -265,18 +265,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setTime(final int a, final Time b, final Calendar c) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTime(a, b, c); │ │ │ │ │ │ + this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -285,18 +285,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setDate(final int a, final Date b) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDate(a, b); │ │ │ │ │ │ + this.inner.setBinaryStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -305,18 +305,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setDate(final int a, final Date b, final Calendar c) throws SQLException { │ │ │ │ │ │ + public final void setBinaryStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDate(a, b, c); │ │ │ │ │ │ + this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -325,18 +325,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final ResultSetMetaData getMetaData() throws SQLException { │ │ │ │ │ │ + public final void setNull(final int a, final int b, final String c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getMetaData(); │ │ │ │ │ │ + this.inner.setNull(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -345,23 +345,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final ResultSet executeQuery() throws SQLException { │ │ │ │ │ │ + public final void setNull(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - final ResultSet innerResultSet = this.inner.executeQuery(); │ │ │ │ │ │ - if (innerResultSet == null) { │ │ │ │ │ │ - return null; │ │ │ │ │ │ - } │ │ │ │ │ │ - this.parentPooledConnection.markActiveResultSetForStatement((Statement)this.inner, innerResultSet); │ │ │ │ │ │ - return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ + this.inner.setNull(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -370,18 +365,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int executeUpdate() throws SQLException { │ │ │ │ │ │ + public final void setBigDecimal(final int a, final BigDecimal b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeUpdate(); │ │ │ │ │ │ + this.inner.setBigDecimal(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -390,18 +385,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void addBatch() throws SQLException { │ │ │ │ │ │ + public final void setTimestamp(final int a, final Timestamp b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.addBatch(); │ │ │ │ │ │ + this.inner.setTimestamp(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -410,18 +405,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final long executeLargeUpdate() throws SQLException { │ │ │ │ │ │ + public final void setTimestamp(final int a, final Timestamp b, final Calendar c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeUpdate(); │ │ │ │ │ │ + this.inner.setTimestamp(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -430,18 +425,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNull(final int a, final int b) throws SQLException { │ │ │ │ │ │ + public final void setUnicodeStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNull(a, b); │ │ │ │ │ │ + this.inner.setUnicodeStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -450,18 +445,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNull(final int a, final int b, final String c) throws SQLException { │ │ │ │ │ │ + public final void clearParameters() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNull(a, b, c); │ │ │ │ │ │ + this.inner.clearParameters(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -470,18 +465,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBigDecimal(final int a, final BigDecimal b) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBigDecimal(a, b); │ │ │ │ │ │ + this.inner.setObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -490,18 +485,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setString(final int a, final String b) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b, final int c, final int d) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setString(a, b); │ │ │ │ │ │ + this.inner.setObject(a, b, c, d); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -510,18 +505,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBytes(final int a, final byte[] b) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b, final SQLType c, final int d) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBytes(a, b); │ │ │ │ │ │ + this.inner.setObject(a, b, c, d); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -530,18 +525,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setTimestamp(final int a, final Timestamp b) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTimestamp(a, b); │ │ │ │ │ │ + this.inner.setObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -550,18 +545,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setTimestamp(final int a, final Timestamp b, final Calendar c) throws SQLException { │ │ │ │ │ │ + public final void setObject(final int a, final Object b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTimestamp(a, b, c); │ │ │ │ │ │ + this.inner.setObject(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -570,18 +565,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setAsciiStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setRef(final int a, final Ref b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ + this.inner.setRef(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -590,18 +585,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setAsciiStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void setBlob(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setAsciiStream(a, b); │ │ │ │ │ │ + this.inner.setBlob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -610,18 +605,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setAsciiStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setBlob(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setAsciiStream(a, b, c); │ │ │ │ │ │ + this.inner.setBlob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -630,18 +625,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setUnicodeStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setBlob(final int a, final Blob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setUnicodeStream(a, b, c); │ │ │ │ │ │ + this.inner.setBlob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -650,18 +645,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBinaryStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void setClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBinaryStream(a, b); │ │ │ │ │ │ + this.inner.setClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -670,18 +665,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBinaryStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setClob(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ + this.inner.setClob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -690,18 +685,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBinaryStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setClob(final int a, final Clob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBinaryStream(a, b, c); │ │ │ │ │ │ + this.inner.setClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -710,18 +705,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void clearParameters() throws SQLException { │ │ │ │ │ │ + public final ParameterMetaData getParameterMetaData() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.clearParameters(); │ │ │ │ │ │ + return this.inner.getParameterMetaData(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -730,18 +725,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final int a, final Object b, final SQLType c, final int d) throws SQLException { │ │ │ │ │ │ + public final void setRowId(final int a, final RowId b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c, d); │ │ │ │ │ │ + this.inner.setRowId(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -750,18 +745,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final int a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ + public final void setNString(final int a, final String b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c); │ │ │ │ │ │ + this.inner.setNString(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -770,18 +765,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final int a, final Object b, final int c, final int d) throws SQLException { │ │ │ │ │ │ + public final void setNCharacterStream(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c, d); │ │ │ │ │ │ + this.inner.setNCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -790,18 +785,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final int a, final Object b) throws SQLException { │ │ │ │ │ │ + public final void setNCharacterStream(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b); │ │ │ │ │ │ + this.inner.setNCharacterStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -810,18 +805,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setObject(final int a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setObject(a, b, c); │ │ │ │ │ │ + this.inner.setNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -830,18 +825,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setCharacterStream(final int a, final Reader b, final int c) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final int a, final NClob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setCharacterStream(a, b, c); │ │ │ │ │ │ + this.inner.setNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -850,18 +845,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setCharacterStream(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setNClob(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setCharacterStream(a, b, c); │ │ │ │ │ │ + this.inner.setNClob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -870,18 +865,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setCharacterStream(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void setSQLXML(final int a, final SQLXML b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setCharacterStream(a, b); │ │ │ │ │ │ + this.inner.setSQLXML(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -890,18 +885,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setRef(final int a, final Ref b) throws SQLException { │ │ │ │ │ │ + public final boolean execute() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setRef(a, b); │ │ │ │ │ │ + return this.inner.execute(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -910,18 +905,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBlob(final int a, final Blob b) throws SQLException { │ │ │ │ │ │ + public final void setBoolean(final int a, final boolean b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBlob(a, b); │ │ │ │ │ │ + this.inner.setBoolean(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -930,18 +925,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBlob(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void setByte(final int a, final byte b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBlob(a, b); │ │ │ │ │ │ + this.inner.setByte(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -950,18 +945,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBlob(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setShort(final int a, final short b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBlob(a, b, c); │ │ │ │ │ │ + this.inner.setShort(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -970,18 +965,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setClob(final int a, final Clob b) throws SQLException { │ │ │ │ │ │ + public final void setInt(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setClob(a, b); │ │ │ │ │ │ + this.inner.setInt(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -990,18 +985,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void setLong(final int a, final long b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setClob(a, b); │ │ │ │ │ │ + this.inner.setLong(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1010,18 +1005,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setClob(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setFloat(final int a, final float b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setClob(a, b, c); │ │ │ │ │ │ + this.inner.setFloat(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1030,18 +1025,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final ParameterMetaData getParameterMetaData() throws SQLException { │ │ │ │ │ │ + public final void setDouble(final int a, final double b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getParameterMetaData(); │ │ │ │ │ │ + this.inner.setDouble(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1050,18 +1045,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setRowId(final int a, final RowId b) throws SQLException { │ │ │ │ │ │ + public final void setURL(final int a, final URL b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setRowId(a, b); │ │ │ │ │ │ + this.inner.setURL(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1070,18 +1065,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNString(final int a, final String b) throws SQLException { │ │ │ │ │ │ + public final void setArray(final int a, final Array b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNString(a, b); │ │ │ │ │ │ + this.inner.setArray(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1090,18 +1085,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNCharacterStream(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void setTime(final int a, final Time b, final Calendar c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNCharacterStream(a, b, c); │ │ │ │ │ │ + this.inner.setTime(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1110,18 +1105,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNCharacterStream(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void setTime(final int a, final Time b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNCharacterStream(a, b); │ │ │ │ │ │ + this.inner.setTime(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1130,18 +1125,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNClob(final int a, final NClob b) throws SQLException { │ │ │ │ │ │ + public final void setDate(final int a, final Date b, final Calendar c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNClob(a, b); │ │ │ │ │ │ + this.inner.setDate(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1150,18 +1145,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void setDate(final int a, final Date b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNClob(a, b); │ │ │ │ │ │ + this.inner.setDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1170,18 +1165,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setNClob(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final ResultSetMetaData getMetaData() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setNClob(a, b, c); │ │ │ │ │ │ + return this.inner.getMetaData(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1190,18 +1185,23 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setSQLXML(final int a, final SQLXML b) throws SQLException { │ │ │ │ │ │ + public final ResultSet executeQuery() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setSQLXML(a, b); │ │ │ │ │ │ + final ResultSet innerResultSet = this.inner.executeQuery(); │ │ │ │ │ │ + if (innerResultSet == null) { │ │ │ │ │ │ + return null; │ │ │ │ │ │ + } │ │ │ │ │ │ + this.parentPooledConnection.markActiveResultSetForStatement((Statement)this.inner, innerResultSet); │ │ │ │ │ │ + return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1209,18 +1209,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean execute(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ + public final int executeUpdate(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.execute(a, b); │ │ │ │ │ │ + return this.inner.executeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1228,18 +1228,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean execute(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public final int executeUpdate(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.execute(a, b); │ │ │ │ │ │ + return this.inner.executeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1247,18 +1247,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean execute(final String a) throws SQLException { │ │ │ │ │ │ + public final int executeUpdate(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.execute(a); │ │ │ │ │ │ + return this.inner.executeUpdate(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1266,18 +1266,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean execute(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ + public final int executeUpdate(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.execute(a, b); │ │ │ │ │ │ + return this.inner.executeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1285,56 +1285,37 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void close() throws SQLException { │ │ │ │ │ │ + public final int getMaxFieldSize() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - if (this.is_cached) { │ │ │ │ │ │ - this.parentPooledConnection.checkinStatement((Statement)this.inner); │ │ │ │ │ │ - } │ │ │ │ │ │ - else { │ │ │ │ │ │ - this.parentPooledConnection.markInactiveUncachedStatement((Statement)this.inner); │ │ │ │ │ │ - try { │ │ │ │ │ │ - this.inner.close(); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception e) { │ │ │ │ │ │ - if (NewProxyPreparedStatement.logger.isLoggable(MLevel.WARNING)) { │ │ │ │ │ │ - NewProxyPreparedStatement.logger.log(MLevel.WARNING, "Exception on close of inner statement.", (Throwable)e); │ │ │ │ │ │ - } │ │ │ │ │ │ - final SQLException sqle = SqlUtils.toSQLException((Throwable)e); │ │ │ │ │ │ - throw sqle; │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - this.detach(); │ │ │ │ │ │ - this.inner = null; │ │ │ │ │ │ - this.creatorProxy = null; │ │ │ │ │ │ - } │ │ │ │ │ │ + return this.inner.getMaxFieldSize(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ catch (final Exception exc2) { │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void cancel() throws SQLException { │ │ │ │ │ │ + public final void setMaxFieldSize(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.cancel(); │ │ │ │ │ │ + this.inner.setMaxFieldSize(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1342,18 +1323,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean isClosed() throws SQLException { │ │ │ │ │ │ + public final int getMaxRows() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.isDetached(); │ │ │ │ │ │ + return this.inner.getMaxRows(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1361,21 +1342,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final Connection getConnection() throws SQLException { │ │ │ │ │ │ + public final void setMaxRows(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - return (Connection)this.creatorProxy; │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new SQLException("You cannot operate on a closed Statement!"); │ │ │ │ │ │ + this.inner.setMaxRows(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1383,23 +1361,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final ResultSet executeQuery(final String a) throws SQLException { │ │ │ │ │ │ + public final void setEscapeProcessing(final boolean a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - final ResultSet innerResultSet = this.inner.executeQuery(a); │ │ │ │ │ │ - if (innerResultSet == null) { │ │ │ │ │ │ - return null; │ │ │ │ │ │ - } │ │ │ │ │ │ - this.parentPooledConnection.markActiveResultSetForStatement((Statement)this.inner, innerResultSet); │ │ │ │ │ │ - return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ + this.inner.setEscapeProcessing(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1407,18 +1380,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int executeUpdate(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ + public final int getQueryTimeout() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeUpdate(a, b); │ │ │ │ │ │ + return this.inner.getQueryTimeout(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1426,18 +1399,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int executeUpdate(final String a) throws SQLException { │ │ │ │ │ │ + public final void setQueryTimeout(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeUpdate(a); │ │ │ │ │ │ + this.inner.setQueryTimeout(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1445,18 +1418,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int executeUpdate(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public final SQLWarning getWarnings() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeUpdate(a, b); │ │ │ │ │ │ + return this.inner.getWarnings(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1464,18 +1437,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int executeUpdate(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ + public final void clearWarnings() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeUpdate(a, b); │ │ │ │ │ │ + this.inner.clearWarnings(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1483,18 +1456,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getMaxFieldSize() throws SQLException { │ │ │ │ │ │ + public final void setCursorName(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getMaxFieldSize(); │ │ │ │ │ │ + this.inner.setCursorName(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1502,18 +1475,23 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setMaxFieldSize(final int a) throws SQLException { │ │ │ │ │ │ + public final ResultSet getResultSet() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setMaxFieldSize(a); │ │ │ │ │ │ + final ResultSet innerResultSet = this.inner.getResultSet(); │ │ │ │ │ │ + if (innerResultSet == null) { │ │ │ │ │ │ + return null; │ │ │ │ │ │ + } │ │ │ │ │ │ + this.parentPooledConnection.markActiveResultSetForStatement((Statement)this.inner, innerResultSet); │ │ │ │ │ │ + return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1521,18 +1499,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getMaxRows() throws SQLException { │ │ │ │ │ │ + public final int getUpdateCount() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getMaxRows(); │ │ │ │ │ │ + return this.inner.getUpdateCount(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1540,18 +1518,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setMaxRows(final int a) throws SQLException { │ │ │ │ │ │ + public final boolean getMoreResults() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setMaxRows(a); │ │ │ │ │ │ + return this.inner.getMoreResults(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1559,18 +1537,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setEscapeProcessing(final boolean a) throws SQLException { │ │ │ │ │ │ + public final boolean getMoreResults(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setEscapeProcessing(a); │ │ │ │ │ │ + return this.inner.getMoreResults(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1578,18 +1556,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getQueryTimeout() throws SQLException { │ │ │ │ │ │ + public final void setFetchDirection(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getQueryTimeout(); │ │ │ │ │ │ + this.inner.setFetchDirection(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1597,18 +1575,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setQueryTimeout(final int a) throws SQLException { │ │ │ │ │ │ + public final int getFetchDirection() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setQueryTimeout(a); │ │ │ │ │ │ + return this.inner.getFetchDirection(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1616,18 +1594,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final SQLWarning getWarnings() throws SQLException { │ │ │ │ │ │ + public final void setFetchSize(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getWarnings(); │ │ │ │ │ │ + this.inner.setFetchSize(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1635,18 +1613,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void clearWarnings() throws SQLException { │ │ │ │ │ │ + public final int getFetchSize() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.clearWarnings(); │ │ │ │ │ │ + return this.inner.getFetchSize(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1654,18 +1632,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setCursorName(final String a) throws SQLException { │ │ │ │ │ │ + public final int getResultSetConcurrency() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setCursorName(a); │ │ │ │ │ │ + return this.inner.getResultSetConcurrency(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1673,23 +1651,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final ResultSet getResultSet() throws SQLException { │ │ │ │ │ │ + public final int getResultSetType() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - final ResultSet innerResultSet = this.inner.getResultSet(); │ │ │ │ │ │ - if (innerResultSet == null) { │ │ │ │ │ │ - return null; │ │ │ │ │ │ - } │ │ │ │ │ │ - this.parentPooledConnection.markActiveResultSetForStatement((Statement)this.inner, innerResultSet); │ │ │ │ │ │ - return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ + return this.inner.getResultSetType(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1697,18 +1670,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getUpdateCount() throws SQLException { │ │ │ │ │ │ + public final void addBatch(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getUpdateCount(); │ │ │ │ │ │ + this.inner.addBatch(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1716,18 +1689,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean getMoreResults() throws SQLException { │ │ │ │ │ │ + public final void clearBatch() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getMoreResults(); │ │ │ │ │ │ + this.inner.clearBatch(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1735,18 +1708,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean getMoreResults(final int a) throws SQLException { │ │ │ │ │ │ + public final int[] executeBatch() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getMoreResults(a); │ │ │ │ │ │ + return this.inner.executeBatch(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1754,18 +1727,23 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setFetchDirection(final int a) throws SQLException { │ │ │ │ │ │ + public final ResultSet getGeneratedKeys() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setFetchDirection(a); │ │ │ │ │ │ + final ResultSet innerResultSet = this.inner.getGeneratedKeys(); │ │ │ │ │ │ + if (innerResultSet == null) { │ │ │ │ │ │ + return null; │ │ │ │ │ │ + } │ │ │ │ │ │ + this.parentPooledConnection.markActiveResultSetForStatement((Statement)this.inner, innerResultSet); │ │ │ │ │ │ + return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1773,18 +1751,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getFetchDirection() throws SQLException { │ │ │ │ │ │ + public final int getResultSetHoldability() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getFetchDirection(); │ │ │ │ │ │ + return this.inner.getResultSetHoldability(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1792,18 +1770,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setFetchSize(final int a) throws SQLException { │ │ │ │ │ │ + public final void setPoolable(final boolean a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setFetchSize(a); │ │ │ │ │ │ + this.inner.setPoolable(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1811,18 +1789,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getFetchSize() throws SQLException { │ │ │ │ │ │ + public final boolean isPoolable() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getFetchSize(); │ │ │ │ │ │ + return this.inner.isPoolable(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1830,18 +1808,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getResultSetConcurrency() throws SQLException { │ │ │ │ │ │ + public final void closeOnCompletion() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getResultSetConcurrency(); │ │ │ │ │ │ + this.inner.closeOnCompletion(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1849,18 +1827,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getResultSetType() throws SQLException { │ │ │ │ │ │ + public final boolean isCloseOnCompletion() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getResultSetType(); │ │ │ │ │ │ + return this.inner.isCloseOnCompletion(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1868,18 +1846,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void addBatch(final String a) throws SQLException { │ │ │ │ │ │ + public final long getLargeUpdateCount() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.addBatch(a); │ │ │ │ │ │ + return this.inner.getLargeUpdateCount(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1887,18 +1865,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void clearBatch() throws SQLException { │ │ │ │ │ │ + public final void setLargeMaxRows(final long a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.clearBatch(); │ │ │ │ │ │ + this.inner.setLargeMaxRows(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1906,18 +1884,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int[] executeBatch() throws SQLException { │ │ │ │ │ │ + public final long getLargeMaxRows() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeBatch(); │ │ │ │ │ │ + return this.inner.getLargeMaxRows(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1925,23 +1903,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final ResultSet getGeneratedKeys() throws SQLException { │ │ │ │ │ │ + public final long[] executeLargeBatch() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - final ResultSet innerResultSet = this.inner.getGeneratedKeys(); │ │ │ │ │ │ - if (innerResultSet == null) { │ │ │ │ │ │ - return null; │ │ │ │ │ │ - } │ │ │ │ │ │ - this.parentPooledConnection.markActiveResultSetForStatement((Statement)this.inner, innerResultSet); │ │ │ │ │ │ - return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ + return this.inner.executeLargeBatch(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1949,18 +1922,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final int getResultSetHoldability() throws SQLException { │ │ │ │ │ │ + public final long executeLargeUpdate(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getResultSetHoldability(); │ │ │ │ │ │ + return this.inner.executeLargeUpdate(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1968,18 +1941,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setPoolable(final boolean a) throws SQLException { │ │ │ │ │ │ + public final long executeLargeUpdate(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setPoolable(a); │ │ │ │ │ │ + return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1987,18 +1960,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean isPoolable() throws SQLException { │ │ │ │ │ │ + public final long executeLargeUpdate(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.isPoolable(); │ │ │ │ │ │ + return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2006,18 +1979,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void closeOnCompletion() throws SQLException { │ │ │ │ │ │ + public final long executeLargeUpdate(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.closeOnCompletion(); │ │ │ │ │ │ + return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2025,18 +1998,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean isCloseOnCompletion() throws SQLException { │ │ │ │ │ │ + public final String enquoteLiteral(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.isCloseOnCompletion(); │ │ │ │ │ │ + return this.inner.enquoteLiteral(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2044,18 +2017,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final long getLargeUpdateCount() throws SQLException { │ │ │ │ │ │ + public final String enquoteIdentifier(final String a, final boolean b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getLargeUpdateCount(); │ │ │ │ │ │ + return this.inner.enquoteIdentifier(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2063,18 +2036,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final void setLargeMaxRows(final long a) throws SQLException { │ │ │ │ │ │ + public final boolean isSimpleIdentifier(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setLargeMaxRows(a); │ │ │ │ │ │ + return this.inner.isSimpleIdentifier(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2082,18 +2055,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final long getLargeMaxRows() throws SQLException { │ │ │ │ │ │ + public final String enquoteNCharLiteral(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getLargeMaxRows(); │ │ │ │ │ │ + return this.inner.enquoteNCharLiteral(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2101,18 +2074,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final long[] executeLargeBatch() throws SQLException { │ │ │ │ │ │ + public final boolean execute(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeBatch(); │ │ │ │ │ │ + return this.inner.execute(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2120,18 +2093,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final long executeLargeUpdate(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ + public final boolean execute(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ + return this.inner.execute(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2139,18 +2112,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final long executeLargeUpdate(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ + public final boolean execute(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ + return this.inner.execute(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2158,18 +2131,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final long executeLargeUpdate(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public final boolean execute(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ + return this.inner.execute(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2177,37 +2150,56 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final long executeLargeUpdate(final String a) throws SQLException { │ │ │ │ │ │ + public final void close() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeUpdate(a); │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + if (this.is_cached) { │ │ │ │ │ │ + this.parentPooledConnection.checkinStatement((Statement)this.inner); │ │ │ │ │ │ + } │ │ │ │ │ │ + else { │ │ │ │ │ │ + this.parentPooledConnection.markInactiveUncachedStatement((Statement)this.inner); │ │ │ │ │ │ + try { │ │ │ │ │ │ + this.inner.close(); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception e) { │ │ │ │ │ │ + if (NewProxyPreparedStatement.logger.isLoggable(MLevel.WARNING)) { │ │ │ │ │ │ + NewProxyPreparedStatement.logger.log(MLevel.WARNING, "Exception on close of inner statement.", (Throwable)e); │ │ │ │ │ │ + } │ │ │ │ │ │ + final SQLException sqle = SqlUtils.toSQLException((Throwable)e); │ │ │ │ │ │ + throw sqle; │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + this.detach(); │ │ │ │ │ │ + this.inner = null; │ │ │ │ │ │ + this.creatorProxy = null; │ │ │ │ │ │ + } │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ catch (final Exception exc2) { │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final String enquoteLiteral(final String a) throws SQLException { │ │ │ │ │ │ + public final void cancel() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.enquoteLiteral(a); │ │ │ │ │ │ + this.inner.cancel(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2215,18 +2207,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final String enquoteIdentifier(final String a, final boolean b) throws SQLException { │ │ │ │ │ │ + public final boolean isClosed() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.enquoteIdentifier(a, b); │ │ │ │ │ │ + return this.isDetached(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2234,18 +2226,21 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean isSimpleIdentifier(final String a) throws SQLException { │ │ │ │ │ │ + public final Connection getConnection() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.isSimpleIdentifier(a); │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + return (Connection)this.creatorProxy; │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new SQLException("You cannot operate on a closed Statement!"); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2253,18 +2248,23 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final String enquoteNCharLiteral(final String a) throws SQLException { │ │ │ │ │ │ + public final ResultSet executeQuery(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.enquoteNCharLiteral(a); │ │ │ │ │ │ + final ResultSet innerResultSet = this.inner.executeQuery(a); │ │ │ │ │ │ + if (innerResultSet == null) { │ │ │ │ │ │ + return null; │ │ │ │ │ │ + } │ │ │ │ │ │ + this.parentPooledConnection.markActiveResultSetForStatement((Statement)this.inner, innerResultSet); │ │ │ │ │ │ + return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2272,18 +2272,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final Object unwrap(final Class a) throws SQLException { │ │ │ │ │ │ + public final boolean isWrapperFor(final Class a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.unwrap((Class)a); │ │ │ │ │ │ + return this.inner.isWrapperFor(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2291,18 +2291,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean isWrapperFor(final Class a) throws SQLException { │ │ │ │ │ │ + public final Object unwrap(final Class a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.isWrapperFor(a); │ │ │ │ │ │ + return this.inner.unwrap((Class)a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ ├── com/mchange/v2/c3p0/impl/NewProxyResultSet.class │ │ │ │ │ ├── procyon -ec {} │ │ │ │ │ │ @@ -1,34 +1,34 @@ │ │ │ │ │ │ │ │ │ │ │ │ package com.mchange.v2.c3p0.impl; │ │ │ │ │ │ │ │ │ │ │ │ import com.mchange.v2.log.MLog; │ │ │ │ │ │ -import java.sql.SQLWarning; │ │ │ │ │ │ import java.sql.ResultSetMetaData; │ │ │ │ │ │ import java.net.URL; │ │ │ │ │ │ import java.sql.Time; │ │ │ │ │ │ import java.util.Calendar; │ │ │ │ │ │ import java.util.Map; │ │ │ │ │ │ import java.sql.Connection; │ │ │ │ │ │ import java.sql.DatabaseMetaData; │ │ │ │ │ │ import java.sql.Statement; │ │ │ │ │ │ -import java.sql.SQLXML; │ │ │ │ │ │ -import java.sql.NClob; │ │ │ │ │ │ -import java.sql.RowId; │ │ │ │ │ │ import java.sql.Array; │ │ │ │ │ │ -import java.sql.Clob; │ │ │ │ │ │ -import java.sql.Blob; │ │ │ │ │ │ import java.sql.Ref; │ │ │ │ │ │ import java.sql.SQLType; │ │ │ │ │ │ -import java.io.Reader; │ │ │ │ │ │ import java.sql.Timestamp; │ │ │ │ │ │ import java.sql.Date; │ │ │ │ │ │ import java.math.BigDecimal; │ │ │ │ │ │ -import java.sql.SQLException; │ │ │ │ │ │ +import java.sql.SQLXML; │ │ │ │ │ │ +import java.sql.NClob; │ │ │ │ │ │ +import java.sql.RowId; │ │ │ │ │ │ +import java.sql.Clob; │ │ │ │ │ │ +import java.sql.Blob; │ │ │ │ │ │ import java.io.InputStream; │ │ │ │ │ │ +import java.io.Reader; │ │ │ │ │ │ +import java.sql.SQLException; │ │ │ │ │ │ +import java.sql.SQLWarning; │ │ │ │ │ │ import javax.sql.ConnectionEventListener; │ │ │ │ │ │ import com.mchange.v2.log.MLogger; │ │ │ │ │ │ import java.sql.ResultSet; │ │ │ │ │ │ │ │ │ │ │ │ public final class NewProxyResultSet implements ResultSet │ │ │ │ │ │ { │ │ │ │ │ │ protected ResultSet inner; │ │ │ │ │ │ @@ -41,20 +41,20 @@ │ │ │ │ │ │ │ │ │ │ │ │ public NewProxyResultSet(final ResultSet inner) { │ │ │ │ │ │ this.cel = (ConnectionEventListener)new NewProxyResultSet.NewProxyResultSet$1(this); │ │ │ │ │ │ this.inner = inner; │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final InputStream getUnicodeStream(final int a) throws SQLException { │ │ │ │ │ │ + public final SQLWarning getWarnings() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getUnicodeStream(a); │ │ │ │ │ │ + return this.inner.getWarnings(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -63,20 +63,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final InputStream getUnicodeStream(final String a) throws SQLException { │ │ │ │ │ │ + public final void clearWarnings() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getUnicodeStream(a); │ │ │ │ │ │ + this.inner.clearWarnings(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -85,20 +85,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getCursorName() throws SQLException { │ │ │ │ │ │ + public final void setFetchDirection(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getCursorName(); │ │ │ │ │ │ + this.inner.setFetchDirection(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -107,20 +107,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int findColumn(final String a) throws SQLException { │ │ │ │ │ │ + public final int getFetchDirection() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.findColumn(a); │ │ │ │ │ │ + return this.inner.getFetchDirection(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -129,20 +129,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean isBeforeFirst() throws SQLException { │ │ │ │ │ │ + public final void setFetchSize(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.isBeforeFirst(); │ │ │ │ │ │ + this.inner.setFetchSize(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -151,20 +151,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean isAfterLast() throws SQLException { │ │ │ │ │ │ + public final int getFetchSize() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.isAfterLast(); │ │ │ │ │ │ + return this.inner.getFetchSize(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -173,20 +173,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean isFirst() throws SQLException { │ │ │ │ │ │ + public final int getHoldability() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.isFirst(); │ │ │ │ │ │ + return this.inner.getHoldability(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -195,20 +195,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean isLast() throws SQLException { │ │ │ │ │ │ + public final Reader getCharacterStream(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.isLast(); │ │ │ │ │ │ + return this.inner.getCharacterStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -217,20 +217,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void beforeFirst() throws SQLException { │ │ │ │ │ │ + public final Reader getCharacterStream(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.beforeFirst(); │ │ │ │ │ │ + return this.inner.getCharacterStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -239,20 +239,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void afterLast() throws SQLException { │ │ │ │ │ │ + public final InputStream getAsciiStream(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.afterLast(); │ │ │ │ │ │ + return this.inner.getAsciiStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -261,20 +261,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getRow() throws SQLException { │ │ │ │ │ │ + public final InputStream getAsciiStream(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getRow(); │ │ │ │ │ │ + return this.inner.getAsciiStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -283,20 +283,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getConcurrency() throws SQLException { │ │ │ │ │ │ + public final InputStream getBinaryStream(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getConcurrency(); │ │ │ │ │ │ + return this.inner.getBinaryStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -305,20 +305,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean rowUpdated() throws SQLException { │ │ │ │ │ │ + public final InputStream getBinaryStream(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.rowUpdated(); │ │ │ │ │ │ + return this.inner.getBinaryStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -327,20 +327,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean rowInserted() throws SQLException { │ │ │ │ │ │ + public final boolean wasNull() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.rowInserted(); │ │ │ │ │ │ + return this.inner.wasNull(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -349,20 +349,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean rowDeleted() throws SQLException { │ │ │ │ │ │ + public final Blob getBlob(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.rowDeleted(); │ │ │ │ │ │ + return this.inner.getBlob(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -371,20 +371,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNull(final String a) throws SQLException { │ │ │ │ │ │ + public final Blob getBlob(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateNull(a); │ │ │ │ │ │ + return this.inner.getBlob(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -393,20 +393,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNull(final int a) throws SQLException { │ │ │ │ │ │ + public final Clob getClob(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateNull(a); │ │ │ │ │ │ + return this.inner.getClob(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -415,20 +415,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBoolean(final String a, final boolean b) throws SQLException { │ │ │ │ │ │ + public final Clob getClob(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBoolean(a, b); │ │ │ │ │ │ + return this.inner.getClob(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -437,20 +437,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBoolean(final int a, final boolean b) throws SQLException { │ │ │ │ │ │ + public final RowId getRowId(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBoolean(a, b); │ │ │ │ │ │ + return this.inner.getRowId(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -459,20 +459,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateByte(final int a, final byte b) throws SQLException { │ │ │ │ │ │ + public final RowId getRowId(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateByte(a, b); │ │ │ │ │ │ + return this.inner.getRowId(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -481,20 +481,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateByte(final String a, final byte b) throws SQLException { │ │ │ │ │ │ + public final NClob getNClob(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateByte(a, b); │ │ │ │ │ │ + return this.inner.getNClob(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -503,20 +503,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateShort(final int a, final short b) throws SQLException { │ │ │ │ │ │ + public final NClob getNClob(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateShort(a, b); │ │ │ │ │ │ + return this.inner.getNClob(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -525,20 +525,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateShort(final String a, final short b) throws SQLException { │ │ │ │ │ │ + public final SQLXML getSQLXML(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateShort(a, b); │ │ │ │ │ │ + return this.inner.getSQLXML(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -547,20 +547,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateInt(final int a, final int b) throws SQLException { │ │ │ │ │ │ + public final SQLXML getSQLXML(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateInt(a, b); │ │ │ │ │ │ + return this.inner.getSQLXML(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -569,20 +569,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateInt(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public final String getNString(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateInt(a, b); │ │ │ │ │ │ + return this.inner.getNString(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -591,20 +591,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateLong(final int a, final long b) throws SQLException { │ │ │ │ │ │ + public final String getNString(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateLong(a, b); │ │ │ │ │ │ + return this.inner.getNString(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -613,20 +613,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateLong(final String a, final long b) throws SQLException { │ │ │ │ │ │ + public final Reader getNCharacterStream(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateLong(a, b); │ │ │ │ │ │ + return this.inner.getNCharacterStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -635,20 +635,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateFloat(final int a, final float b) throws SQLException { │ │ │ │ │ │ + public final Reader getNCharacterStream(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateFloat(a, b); │ │ │ │ │ │ + return this.inner.getNCharacterStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -657,20 +657,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateFloat(final String a, final float b) throws SQLException { │ │ │ │ │ │ + public final InputStream getUnicodeStream(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateFloat(a, b); │ │ │ │ │ │ + return this.inner.getUnicodeStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -679,20 +679,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateDouble(final int a, final double b) throws SQLException { │ │ │ │ │ │ + public final InputStream getUnicodeStream(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateDouble(a, b); │ │ │ │ │ │ + return this.inner.getUnicodeStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -701,20 +701,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateDouble(final String a, final double b) throws SQLException { │ │ │ │ │ │ + public final String getCursorName() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateDouble(a, b); │ │ │ │ │ │ + return this.inner.getCursorName(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -723,20 +723,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBigDecimal(final int a, final BigDecimal b) throws SQLException { │ │ │ │ │ │ + public final int findColumn(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBigDecimal(a, b); │ │ │ │ │ │ + return this.inner.findColumn(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -745,20 +745,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBigDecimal(final String a, final BigDecimal b) throws SQLException { │ │ │ │ │ │ + public final boolean isBeforeFirst() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBigDecimal(a, b); │ │ │ │ │ │ + return this.inner.isBeforeFirst(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -767,20 +767,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateString(final int a, final String b) throws SQLException { │ │ │ │ │ │ + public final boolean isAfterLast() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateString(a, b); │ │ │ │ │ │ + return this.inner.isAfterLast(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -789,20 +789,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateString(final String a, final String b) throws SQLException { │ │ │ │ │ │ + public final boolean isFirst() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateString(a, b); │ │ │ │ │ │ + return this.inner.isFirst(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -811,20 +811,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateDate(final String a, final Date b) throws SQLException { │ │ │ │ │ │ + public final boolean isLast() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateDate(a, b); │ │ │ │ │ │ + return this.inner.isLast(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -833,20 +833,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateDate(final int a, final Date b) throws SQLException { │ │ │ │ │ │ + public final void beforeFirst() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateDate(a, b); │ │ │ │ │ │ + this.inner.beforeFirst(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -855,20 +855,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateTimestamp(final String a, final Timestamp b) throws SQLException { │ │ │ │ │ │ + public final void afterLast() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateTimestamp(a, b); │ │ │ │ │ │ + this.inner.afterLast(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -877,20 +877,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateTimestamp(final int a, final Timestamp b) throws SQLException { │ │ │ │ │ │ + public final int getRow() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateTimestamp(a, b); │ │ │ │ │ │ + return this.inner.getRow(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -899,20 +899,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateAsciiStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final int getConcurrency() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateAsciiStream(a, b, c); │ │ │ │ │ │ + return this.inner.getConcurrency(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -921,20 +921,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateAsciiStream(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final boolean rowUpdated() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateAsciiStream(a, b); │ │ │ │ │ │ + return this.inner.rowUpdated(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -943,20 +943,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateAsciiStream(final String a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final boolean rowInserted() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateAsciiStream(a, b, c); │ │ │ │ │ │ + return this.inner.rowInserted(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -965,20 +965,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateAsciiStream(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final boolean rowDeleted() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateAsciiStream(a, b, c); │ │ │ │ │ │ + return this.inner.rowDeleted(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -987,20 +987,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateAsciiStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final void updateNull(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateAsciiStream(a, b, c); │ │ │ │ │ │ + this.inner.updateNull(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1009,20 +1009,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateAsciiStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void updateNull(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateAsciiStream(a, b); │ │ │ │ │ │ + this.inner.updateNull(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1031,20 +1031,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBinaryStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void updateBoolean(final int a, final boolean b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBinaryStream(a, b); │ │ │ │ │ │ + this.inner.updateBoolean(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1053,20 +1053,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBinaryStream(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void updateBoolean(final String a, final boolean b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBinaryStream(a, b); │ │ │ │ │ │ + this.inner.updateBoolean(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1075,20 +1075,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBinaryStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final void updateByte(final int a, final byte b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBinaryStream(a, b, c); │ │ │ │ │ │ + this.inner.updateByte(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1097,20 +1097,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBinaryStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void updateByte(final String a, final byte b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBinaryStream(a, b, c); │ │ │ │ │ │ + this.inner.updateByte(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1119,20 +1119,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBinaryStream(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void updateShort(final int a, final short b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBinaryStream(a, b, c); │ │ │ │ │ │ + this.inner.updateShort(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1141,20 +1141,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBinaryStream(final String a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ + public final void updateShort(final String a, final short b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBinaryStream(a, b, c); │ │ │ │ │ │ + this.inner.updateShort(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1163,20 +1163,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateCharacterStream(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void updateInt(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateCharacterStream(a, b); │ │ │ │ │ │ + this.inner.updateInt(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1185,20 +1185,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateCharacterStream(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void updateInt(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateCharacterStream(a, b); │ │ │ │ │ │ + this.inner.updateInt(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1207,20 +1207,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateCharacterStream(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void updateLong(final String a, final long b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateCharacterStream(a, b, c); │ │ │ │ │ │ + this.inner.updateLong(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1229,20 +1229,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateCharacterStream(final int a, final Reader b, final int c) throws SQLException { │ │ │ │ │ │ + public final void updateLong(final int a, final long b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateCharacterStream(a, b, c); │ │ │ │ │ │ + this.inner.updateLong(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1251,20 +1251,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateCharacterStream(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void updateFloat(final String a, final float b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateCharacterStream(a, b, c); │ │ │ │ │ │ + this.inner.updateFloat(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1273,20 +1273,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateCharacterStream(final String a, final Reader b, final int c) throws SQLException { │ │ │ │ │ │ + public final void updateFloat(final int a, final float b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateCharacterStream(a, b, c); │ │ │ │ │ │ + this.inner.updateFloat(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1295,20 +1295,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateObject(final int a, final Object b) throws SQLException { │ │ │ │ │ │ + public final void updateDouble(final int a, final double b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateObject(a, b); │ │ │ │ │ │ + this.inner.updateDouble(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1317,20 +1317,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateObject(final String a, final Object b) throws SQLException { │ │ │ │ │ │ + public final void updateDouble(final String a, final double b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateObject(a, b); │ │ │ │ │ │ + this.inner.updateDouble(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1339,20 +1339,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateObject(final int a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ + public final void updateBigDecimal(final int a, final BigDecimal b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateObject(a, b, c); │ │ │ │ │ │ + this.inner.updateBigDecimal(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1361,20 +1361,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateObject(final int a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ + public final void updateBigDecimal(final String a, final BigDecimal b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateObject(a, b, c); │ │ │ │ │ │ + this.inner.updateBigDecimal(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1383,20 +1383,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateObject(final String a, final Object b, final SQLType c, final int d) throws SQLException { │ │ │ │ │ │ + public final void updateString(final String a, final String b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateObject(a, b, c, d); │ │ │ │ │ │ + this.inner.updateString(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1405,20 +1405,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateObject(final String a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ + public final void updateString(final int a, final String b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateObject(a, b, c); │ │ │ │ │ │ + this.inner.updateString(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1427,20 +1427,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateObject(final String a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ + public final void updateDate(final String a, final Date b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateObject(a, b, c); │ │ │ │ │ │ + this.inner.updateDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1449,20 +1449,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateObject(final int a, final Object b, final SQLType c, final int d) throws SQLException { │ │ │ │ │ │ + public final void updateDate(final int a, final Date b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateObject(a, b, c, d); │ │ │ │ │ │ + this.inner.updateDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1471,20 +1471,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void insertRow() throws SQLException { │ │ │ │ │ │ + public final void updateTimestamp(final String a, final Timestamp b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.insertRow(); │ │ │ │ │ │ + this.inner.updateTimestamp(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1493,20 +1493,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateRow() throws SQLException { │ │ │ │ │ │ + public final void updateTimestamp(final int a, final Timestamp b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateRow(); │ │ │ │ │ │ + this.inner.updateTimestamp(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1515,20 +1515,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void deleteRow() throws SQLException { │ │ │ │ │ │ + public final void updateAsciiStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.deleteRow(); │ │ │ │ │ │ + this.inner.updateAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1537,20 +1537,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void refreshRow() throws SQLException { │ │ │ │ │ │ + public final void updateAsciiStream(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.refreshRow(); │ │ │ │ │ │ + this.inner.updateAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1559,20 +1559,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void cancelRowUpdates() throws SQLException { │ │ │ │ │ │ + public final void updateAsciiStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.cancelRowUpdates(); │ │ │ │ │ │ + this.inner.updateAsciiStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1581,20 +1581,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void moveToInsertRow() throws SQLException { │ │ │ │ │ │ + public final void updateAsciiStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.moveToInsertRow(); │ │ │ │ │ │ + this.inner.updateAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1603,20 +1603,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void moveToCurrentRow() throws SQLException { │ │ │ │ │ │ + public final void updateAsciiStream(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.moveToCurrentRow(); │ │ │ │ │ │ + this.inner.updateAsciiStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1625,20 +1625,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateRef(final int a, final Ref b) throws SQLException { │ │ │ │ │ │ + public final void updateAsciiStream(final String a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateRef(a, b); │ │ │ │ │ │ + this.inner.updateAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1647,20 +1647,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateRef(final String a, final Ref b) throws SQLException { │ │ │ │ │ │ + public final void updateBinaryStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateRef(a, b); │ │ │ │ │ │ + this.inner.updateBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1669,20 +1669,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBlob(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void updateBinaryStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBlob(a, b); │ │ │ │ │ │ + this.inner.updateBinaryStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1691,20 +1691,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBlob(final String a, final Blob b) throws SQLException { │ │ │ │ │ │ + public final void updateBinaryStream(final String a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBlob(a, b); │ │ │ │ │ │ + this.inner.updateBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1713,20 +1713,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBlob(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void updateBinaryStream(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBlob(a, b, c); │ │ │ │ │ │ + this.inner.updateBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1735,20 +1735,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBlob(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ + public final void updateBinaryStream(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBlob(a, b, c); │ │ │ │ │ │ + this.inner.updateBinaryStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1757,20 +1757,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBlob(final int a, final Blob b) throws SQLException { │ │ │ │ │ │ + public final void updateBinaryStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBlob(a, b); │ │ │ │ │ │ + this.inner.updateBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1779,20 +1779,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBlob(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ + public final void updateCharacterStream(final int a, final Reader b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBlob(a, b); │ │ │ │ │ │ + this.inner.updateCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1801,20 +1801,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateClob(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void updateCharacterStream(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateClob(a, b, c); │ │ │ │ │ │ + this.inner.updateCharacterStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1823,20 +1823,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateClob(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void updateCharacterStream(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateClob(a, b); │ │ │ │ │ │ + this.inner.updateCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1845,20 +1845,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void updateCharacterStream(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateClob(a, b); │ │ │ │ │ │ + this.inner.updateCharacterStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1867,20 +1867,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateClob(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void updateCharacterStream(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateClob(a, b, c); │ │ │ │ │ │ + this.inner.updateCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1889,20 +1889,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateClob(final int a, final Clob b) throws SQLException { │ │ │ │ │ │ + public final void updateCharacterStream(final String a, final Reader b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateClob(a, b); │ │ │ │ │ │ + this.inner.updateCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1911,20 +1911,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateClob(final String a, final Clob b) throws SQLException { │ │ │ │ │ │ + public final void updateObject(final String a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateClob(a, b); │ │ │ │ │ │ + this.inner.updateObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1933,20 +1933,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateArray(final String a, final Array b) throws SQLException { │ │ │ │ │ │ + public final void updateObject(final String a, final Object b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateArray(a, b); │ │ │ │ │ │ + this.inner.updateObject(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1955,20 +1955,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateArray(final int a, final Array b) throws SQLException { │ │ │ │ │ │ + public final void updateObject(final int a, final Object b, final SQLType c, final int d) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateArray(a, b); │ │ │ │ │ │ + this.inner.updateObject(a, b, c, d); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1977,20 +1977,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateRowId(final String a, final RowId b) throws SQLException { │ │ │ │ │ │ + public final void updateObject(final String a, final Object b, final SQLType c, final int d) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateRowId(a, b); │ │ │ │ │ │ + this.inner.updateObject(a, b, c, d); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1999,20 +1999,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateRowId(final int a, final RowId b) throws SQLException { │ │ │ │ │ │ + public final void updateObject(final int a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateRowId(a, b); │ │ │ │ │ │ + this.inner.updateObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2021,20 +2021,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNString(final int a, final String b) throws SQLException { │ │ │ │ │ │ + public final void updateObject(final int a, final Object b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateNString(a, b); │ │ │ │ │ │ + this.inner.updateObject(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2043,20 +2043,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNString(final String a, final String b) throws SQLException { │ │ │ │ │ │ + public final void updateObject(final int a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateNString(a, b); │ │ │ │ │ │ + this.inner.updateObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2065,20 +2065,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNClob(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void updateObject(final String a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateNClob(a, b); │ │ │ │ │ │ + this.inner.updateObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2087,20 +2087,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void insertRow() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateNClob(a, b); │ │ │ │ │ │ + this.inner.insertRow(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2109,20 +2109,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNClob(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void updateRow() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateNClob(a, b, c); │ │ │ │ │ │ + this.inner.updateRow(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2131,20 +2131,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNClob(final String a, final NClob b) throws SQLException { │ │ │ │ │ │ + public final void deleteRow() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateNClob(a, b); │ │ │ │ │ │ + this.inner.deleteRow(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2153,20 +2153,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNClob(final int a, final NClob b) throws SQLException { │ │ │ │ │ │ + public final void refreshRow() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateNClob(a, b); │ │ │ │ │ │ + this.inner.refreshRow(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2175,20 +2175,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNClob(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void cancelRowUpdates() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateNClob(a, b, c); │ │ │ │ │ │ + this.inner.cancelRowUpdates(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2197,20 +2197,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateSQLXML(final String a, final SQLXML b) throws SQLException { │ │ │ │ │ │ + public final void moveToInsertRow() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateSQLXML(a, b); │ │ │ │ │ │ + this.inner.moveToInsertRow(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2219,20 +2219,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateSQLXML(final int a, final SQLXML b) throws SQLException { │ │ │ │ │ │ + public final void moveToCurrentRow() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateSQLXML(a, b); │ │ │ │ │ │ + this.inner.moveToCurrentRow(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2241,20 +2241,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNCharacterStream(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void updateRef(final int a, final Ref b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateNCharacterStream(a, b, c); │ │ │ │ │ │ + this.inner.updateRef(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2263,20 +2263,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNCharacterStream(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ + public final void updateRef(final String a, final Ref b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateNCharacterStream(a, b, c); │ │ │ │ │ │ + this.inner.updateRef(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2285,20 +2285,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNCharacterStream(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void updateBlob(final int a, final Blob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateNCharacterStream(a, b); │ │ │ │ │ │ + this.inner.updateBlob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2307,20 +2307,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNCharacterStream(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void updateBlob(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateNCharacterStream(a, b); │ │ │ │ │ │ + this.inner.updateBlob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2329,20 +2329,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBytes(final int a, final byte[] b) throws SQLException { │ │ │ │ │ │ + public final void updateBlob(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBytes(a, b); │ │ │ │ │ │ + this.inner.updateBlob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2351,20 +2351,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBytes(final String a, final byte[] b) throws SQLException { │ │ │ │ │ │ + public final void updateBlob(final String a, final Blob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBytes(a, b); │ │ │ │ │ │ + this.inner.updateBlob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2373,20 +2373,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean getBoolean(final String a) throws SQLException { │ │ │ │ │ │ + public final void updateBlob(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBoolean(a); │ │ │ │ │ │ + this.inner.updateBlob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2395,20 +2395,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean getBoolean(final int a) throws SQLException { │ │ │ │ │ │ + public final void updateBlob(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBoolean(a); │ │ │ │ │ │ + this.inner.updateBlob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2417,20 +2417,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte getByte(final int a) throws SQLException { │ │ │ │ │ │ + public final void updateClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getByte(a); │ │ │ │ │ │ + this.inner.updateClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2439,20 +2439,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte getByte(final String a) throws SQLException { │ │ │ │ │ │ + public final void updateClob(final String a, final Clob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getByte(a); │ │ │ │ │ │ + this.inner.updateClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2461,20 +2461,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final short getShort(final int a) throws SQLException { │ │ │ │ │ │ + public final void updateClob(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getShort(a); │ │ │ │ │ │ + this.inner.updateClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2483,20 +2483,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final short getShort(final String a) throws SQLException { │ │ │ │ │ │ + public final void updateClob(final int a, final Clob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getShort(a); │ │ │ │ │ │ + this.inner.updateClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2505,20 +2505,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getInt(final int a) throws SQLException { │ │ │ │ │ │ + public final void updateClob(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getInt(a); │ │ │ │ │ │ + this.inner.updateClob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2527,20 +2527,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getInt(final String a) throws SQLException { │ │ │ │ │ │ + public final void updateClob(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getInt(a); │ │ │ │ │ │ + this.inner.updateClob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2549,20 +2549,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final long getLong(final String a) throws SQLException { │ │ │ │ │ │ + public final void updateArray(final int a, final Array b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getLong(a); │ │ │ │ │ │ + this.inner.updateArray(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2571,20 +2571,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final long getLong(final int a) throws SQLException { │ │ │ │ │ │ + public final void updateArray(final String a, final Array b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getLong(a); │ │ │ │ │ │ + this.inner.updateArray(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2593,20 +2593,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final float getFloat(final int a) throws SQLException { │ │ │ │ │ │ + public final void updateRowId(final String a, final RowId b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getFloat(a); │ │ │ │ │ │ + this.inner.updateRowId(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2615,20 +2615,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final float getFloat(final String a) throws SQLException { │ │ │ │ │ │ + public final void updateRowId(final int a, final RowId b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getFloat(a); │ │ │ │ │ │ + this.inner.updateRowId(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2637,20 +2637,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final double getDouble(final String a) throws SQLException { │ │ │ │ │ │ + public final void updateNString(final String a, final String b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getDouble(a); │ │ │ │ │ │ + this.inner.updateNString(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2659,20 +2659,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final double getDouble(final int a) throws SQLException { │ │ │ │ │ │ + public final void updateNString(final int a, final String b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getDouble(a); │ │ │ │ │ │ + this.inner.updateNString(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2681,20 +2681,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte[] getBytes(final int a) throws SQLException { │ │ │ │ │ │ + public final void updateNClob(final String a, final NClob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBytes(a); │ │ │ │ │ │ + this.inner.updateNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2703,20 +2703,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte[] getBytes(final String a) throws SQLException { │ │ │ │ │ │ + public final void updateNClob(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBytes(a); │ │ │ │ │ │ + this.inner.updateNClob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2725,20 +2725,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean next() throws SQLException { │ │ │ │ │ │ + public final void updateNClob(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.next(); │ │ │ │ │ │ + this.inner.updateNClob(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2747,20 +2747,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean last() throws SQLException { │ │ │ │ │ │ + public final void updateNClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.last(); │ │ │ │ │ │ + this.inner.updateNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2769,20 +2769,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean first() throws SQLException { │ │ │ │ │ │ + public final void updateNClob(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.first(); │ │ │ │ │ │ + this.inner.updateNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2791,57 +2791,42 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void close() throws SQLException { │ │ │ │ │ │ + public final void updateNClob(final int a, final NClob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - if (this.creator instanceof Statement) { │ │ │ │ │ │ - this.parentPooledConnection.markInactiveResultSetForStatement((Statement)this.creator, this.inner); │ │ │ │ │ │ - } │ │ │ │ │ │ - else if (this.creator instanceof DatabaseMetaData) { │ │ │ │ │ │ - this.parentPooledConnection.markInactiveMetaDataResultSet(this.inner); │ │ │ │ │ │ - } │ │ │ │ │ │ - else { │ │ │ │ │ │ - if (!(this.creator instanceof Connection)) { │ │ │ │ │ │ - throw new InternalError("Must be Statement or DatabaseMetaData -- Bad Creator: " + this.creator); │ │ │ │ │ │ - } │ │ │ │ │ │ - this.parentPooledConnection.markInactiveRawConnectionResultSet(this.inner); │ │ │ │ │ │ - } │ │ │ │ │ │ - this.detach(); │ │ │ │ │ │ - this.inner.close(); │ │ │ │ │ │ - this.inner = null; │ │ │ │ │ │ - } │ │ │ │ │ │ + this.inner.updateNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ catch (final Exception exc2) { │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getType() throws SQLException { │ │ │ │ │ │ + public final void updateSQLXML(final String a, final SQLXML b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getType(); │ │ │ │ │ │ + this.inner.updateSQLXML(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2850,20 +2835,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final String a, final Class b) throws SQLException { │ │ │ │ │ │ + public final void updateSQLXML(final int a, final SQLXML b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getObject(a, (Class)b); │ │ │ │ │ │ + this.inner.updateSQLXML(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2872,20 +2857,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final int a, final Class b) throws SQLException { │ │ │ │ │ │ + public final void updateNCharacterStream(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getObject(a, (Class)b); │ │ │ │ │ │ + this.inner.updateNCharacterStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2894,20 +2879,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final String a) throws SQLException { │ │ │ │ │ │ + public final void updateNCharacterStream(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getObject(a); │ │ │ │ │ │ + this.inner.updateNCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2916,20 +2901,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final int a) throws SQLException { │ │ │ │ │ │ + public final void updateNCharacterStream(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getObject(a); │ │ │ │ │ │ + this.inner.updateNCharacterStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2938,20 +2923,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final int a, final Map b) throws SQLException { │ │ │ │ │ │ + public final void updateNCharacterStream(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getObject(a, b); │ │ │ │ │ │ + this.inner.updateNCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2960,20 +2945,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final String a, final Map b) throws SQLException { │ │ │ │ │ │ + public final void updateBytes(final int a, final byte[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getObject(a, b); │ │ │ │ │ │ + this.inner.updateBytes(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2982,20 +2967,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Ref getRef(final int a) throws SQLException { │ │ │ │ │ │ + public final void updateBytes(final String a, final byte[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getRef(a); │ │ │ │ │ │ + this.inner.updateBytes(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3004,20 +2989,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Ref getRef(final String a) throws SQLException { │ │ │ │ │ │ + public final boolean getBoolean(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getRef(a); │ │ │ │ │ │ + return this.inner.getBoolean(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3026,20 +3011,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean previous() throws SQLException { │ │ │ │ │ │ + public final boolean getBoolean(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.previous(); │ │ │ │ │ │ + return this.inner.getBoolean(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3048,20 +3033,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Array getArray(final int a) throws SQLException { │ │ │ │ │ │ + public final byte getByte(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getArray(a); │ │ │ │ │ │ + return this.inner.getByte(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3070,20 +3055,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Array getArray(final String a) throws SQLException { │ │ │ │ │ │ + public final byte getByte(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getArray(a); │ │ │ │ │ │ + return this.inner.getByte(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3092,20 +3077,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean absolute(final int a) throws SQLException { │ │ │ │ │ │ + public final short getShort(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.absolute(a); │ │ │ │ │ │ + return this.inner.getShort(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3114,20 +3099,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Timestamp getTimestamp(final String a) throws SQLException { │ │ │ │ │ │ + public final short getShort(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getTimestamp(a); │ │ │ │ │ │ + return this.inner.getShort(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3136,20 +3121,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Timestamp getTimestamp(final int a) throws SQLException { │ │ │ │ │ │ + public final int getInt(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getTimestamp(a); │ │ │ │ │ │ + return this.inner.getInt(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3158,20 +3143,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Timestamp getTimestamp(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final int getInt(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getTimestamp(a, b); │ │ │ │ │ │ + return this.inner.getInt(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3180,20 +3165,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Timestamp getTimestamp(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final long getLong(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getTimestamp(a, b); │ │ │ │ │ │ + return this.inner.getLong(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3202,20 +3187,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getString(final int a) throws SQLException { │ │ │ │ │ │ + public final long getLong(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getString(a); │ │ │ │ │ │ + return this.inner.getLong(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3224,20 +3209,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getString(final String a) throws SQLException { │ │ │ │ │ │ + public final float getFloat(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getString(a); │ │ │ │ │ │ + return this.inner.getFloat(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3246,20 +3231,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final BigDecimal getBigDecimal(final int a) throws SQLException { │ │ │ │ │ │ + public final float getFloat(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBigDecimal(a); │ │ │ │ │ │ + return this.inner.getFloat(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3268,20 +3253,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final BigDecimal getBigDecimal(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public final double getDouble(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBigDecimal(a, b); │ │ │ │ │ │ + return this.inner.getDouble(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3290,20 +3275,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final BigDecimal getBigDecimal(final String a) throws SQLException { │ │ │ │ │ │ + public final double getDouble(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBigDecimal(a); │ │ │ │ │ │ + return this.inner.getDouble(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3312,20 +3297,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final BigDecimal getBigDecimal(final int a, final int b) throws SQLException { │ │ │ │ │ │ + public final byte[] getBytes(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBigDecimal(a, b); │ │ │ │ │ │ + return this.inner.getBytes(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3334,20 +3319,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final byte[] getBytes(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getTime(a, b); │ │ │ │ │ │ + return this.inner.getBytes(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3356,20 +3341,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final String a) throws SQLException { │ │ │ │ │ │ + public final boolean next() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getTime(a); │ │ │ │ │ │ + return this.inner.next(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3378,20 +3363,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final boolean last() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getTime(a, b); │ │ │ │ │ │ + return this.inner.last(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3400,20 +3385,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final int a) throws SQLException { │ │ │ │ │ │ + public final boolean first() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getTime(a); │ │ │ │ │ │ + return this.inner.first(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3422,42 +3407,57 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateTime(final String a, final Time b) throws SQLException { │ │ │ │ │ │ + public final void close() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateTime(a, b); │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + if (this.creator instanceof Statement) { │ │ │ │ │ │ + this.parentPooledConnection.markInactiveResultSetForStatement((Statement)this.creator, this.inner); │ │ │ │ │ │ + } │ │ │ │ │ │ + else if (this.creator instanceof DatabaseMetaData) { │ │ │ │ │ │ + this.parentPooledConnection.markInactiveMetaDataResultSet(this.inner); │ │ │ │ │ │ + } │ │ │ │ │ │ + else { │ │ │ │ │ │ + if (!(this.creator instanceof Connection)) { │ │ │ │ │ │ + throw new InternalError("Must be Statement or DatabaseMetaData -- Bad Creator: " + this.creator); │ │ │ │ │ │ + } │ │ │ │ │ │ + this.parentPooledConnection.markInactiveRawConnectionResultSet(this.inner); │ │ │ │ │ │ + } │ │ │ │ │ │ + this.detach(); │ │ │ │ │ │ + this.inner.close(); │ │ │ │ │ │ + this.inner = null; │ │ │ │ │ │ + } │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ catch (final Exception exc2) { │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateTime(final int a, final Time b) throws SQLException { │ │ │ │ │ │ + public final int getType() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateTime(a, b); │ │ │ │ │ │ + return this.inner.getType(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3466,20 +3466,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final String a, final Map b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getDate(a, b); │ │ │ │ │ │ + return this.inner.getObject(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3488,20 +3488,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final String a) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getDate(a); │ │ │ │ │ │ + return this.inner.getObject(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3510,20 +3510,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final int a) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getDate(a); │ │ │ │ │ │ + return this.inner.getObject(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3532,20 +3532,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final int a, final Map b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getDate(a, b); │ │ │ │ │ │ + return this.inner.getObject(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3554,20 +3554,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final URL getURL(final int a) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final String a, final Class b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getURL(a); │ │ │ │ │ │ + return this.inner.getObject(a, (Class)b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3576,20 +3576,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final URL getURL(final String a) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final int a, final Class b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getURL(a); │ │ │ │ │ │ + return this.inner.getObject(a, (Class)b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3598,20 +3598,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean relative(final int a) throws SQLException { │ │ │ │ │ │ + public final Ref getRef(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.relative(a); │ │ │ │ │ │ + return this.inner.getRef(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3620,26 +3620,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Statement getStatement() throws SQLException { │ │ │ │ │ │ + public final Ref getRef(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - if (this.creator instanceof Statement) { │ │ │ │ │ │ - return (Statement)this.creatorProxy; │ │ │ │ │ │ - } │ │ │ │ │ │ - if (this.creator instanceof DatabaseMetaData) { │ │ │ │ │ │ - return null; │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new InternalError("Must be Statement or DatabaseMetaData -- Bad Creator: " + this.creator); │ │ │ │ │ │ + return this.inner.getRef(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3648,20 +3642,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final ResultSetMetaData getMetaData() throws SQLException { │ │ │ │ │ │ + public final boolean previous() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getMetaData(); │ │ │ │ │ │ + return this.inner.previous(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3670,20 +3664,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean isClosed() throws SQLException { │ │ │ │ │ │ + public final Array getArray(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.isDetached(); │ │ │ │ │ │ + return this.inner.getArray(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3692,20 +3686,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final SQLWarning getWarnings() throws SQLException { │ │ │ │ │ │ + public final Array getArray(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getWarnings(); │ │ │ │ │ │ + return this.inner.getArray(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3714,20 +3708,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void clearWarnings() throws SQLException { │ │ │ │ │ │ + public final boolean absolute(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.clearWarnings(); │ │ │ │ │ │ + return this.inner.absolute(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3736,20 +3730,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setFetchDirection(final int a) throws SQLException { │ │ │ │ │ │ + public final Timestamp getTimestamp(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.setFetchDirection(a); │ │ │ │ │ │ + return this.inner.getTimestamp(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3758,20 +3752,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getFetchDirection() throws SQLException { │ │ │ │ │ │ + public final Timestamp getTimestamp(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getFetchDirection(); │ │ │ │ │ │ + return this.inner.getTimestamp(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3780,20 +3774,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setFetchSize(final int a) throws SQLException { │ │ │ │ │ │ + public final Timestamp getTimestamp(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.setFetchSize(a); │ │ │ │ │ │ + return this.inner.getTimestamp(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3802,20 +3796,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getFetchSize() throws SQLException { │ │ │ │ │ │ + public final Timestamp getTimestamp(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getFetchSize(); │ │ │ │ │ │ + return this.inner.getTimestamp(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3824,20 +3818,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getHoldability() throws SQLException { │ │ │ │ │ │ + public final String getString(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getHoldability(); │ │ │ │ │ │ + return this.inner.getString(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3846,20 +3840,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean wasNull() throws SQLException { │ │ │ │ │ │ + public final String getString(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.wasNull(); │ │ │ │ │ │ + return this.inner.getString(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3868,20 +3862,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Blob getBlob(final int a) throws SQLException { │ │ │ │ │ │ + public final BigDecimal getBigDecimal(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBlob(a); │ │ │ │ │ │ + return this.inner.getBigDecimal(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3890,20 +3884,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Blob getBlob(final String a) throws SQLException { │ │ │ │ │ │ + public final BigDecimal getBigDecimal(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBlob(a); │ │ │ │ │ │ + return this.inner.getBigDecimal(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3912,20 +3906,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Clob getClob(final int a) throws SQLException { │ │ │ │ │ │ + public final BigDecimal getBigDecimal(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getClob(a); │ │ │ │ │ │ + return this.inner.getBigDecimal(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3934,20 +3928,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Clob getClob(final String a) throws SQLException { │ │ │ │ │ │ + public final BigDecimal getBigDecimal(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getClob(a); │ │ │ │ │ │ + return this.inner.getBigDecimal(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3956,20 +3950,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final RowId getRowId(final int a) throws SQLException { │ │ │ │ │ │ + public final Time getTime(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getRowId(a); │ │ │ │ │ │ + return this.inner.getTime(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3978,20 +3972,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final RowId getRowId(final String a) throws SQLException { │ │ │ │ │ │ + public final Time getTime(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getRowId(a); │ │ │ │ │ │ + return this.inner.getTime(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4000,20 +3994,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final NClob getNClob(final String a) throws SQLException { │ │ │ │ │ │ + public final Time getTime(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getNClob(a); │ │ │ │ │ │ + return this.inner.getTime(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4022,20 +4016,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final NClob getNClob(final int a) throws SQLException { │ │ │ │ │ │ + public final Time getTime(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getNClob(a); │ │ │ │ │ │ + return this.inner.getTime(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4044,20 +4038,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final SQLXML getSQLXML(final String a) throws SQLException { │ │ │ │ │ │ + public final void updateTime(final int a, final Time b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getSQLXML(a); │ │ │ │ │ │ + this.inner.updateTime(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4066,20 +4060,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final SQLXML getSQLXML(final int a) throws SQLException { │ │ │ │ │ │ + public final void updateTime(final String a, final Time b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getSQLXML(a); │ │ │ │ │ │ + this.inner.updateTime(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4088,20 +4082,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getNString(final int a) throws SQLException { │ │ │ │ │ │ + public final Date getDate(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getNString(a); │ │ │ │ │ │ + return this.inner.getDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4110,20 +4104,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getNString(final String a) throws SQLException { │ │ │ │ │ │ + public final Date getDate(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getNString(a); │ │ │ │ │ │ + return this.inner.getDate(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4132,20 +4126,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Reader getNCharacterStream(final int a) throws SQLException { │ │ │ │ │ │ + public final Date getDate(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getNCharacterStream(a); │ │ │ │ │ │ + return this.inner.getDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4154,20 +4148,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Reader getNCharacterStream(final String a) throws SQLException { │ │ │ │ │ │ + public final Date getDate(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getNCharacterStream(a); │ │ │ │ │ │ + return this.inner.getDate(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4176,20 +4170,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Reader getCharacterStream(final String a) throws SQLException { │ │ │ │ │ │ + public final URL getURL(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getCharacterStream(a); │ │ │ │ │ │ + return this.inner.getURL(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4198,20 +4192,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Reader getCharacterStream(final int a) throws SQLException { │ │ │ │ │ │ + public final URL getURL(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getCharacterStream(a); │ │ │ │ │ │ + return this.inner.getURL(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4220,20 +4214,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final InputStream getAsciiStream(final int a) throws SQLException { │ │ │ │ │ │ + public final boolean relative(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getAsciiStream(a); │ │ │ │ │ │ + return this.inner.relative(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4242,20 +4236,26 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final InputStream getAsciiStream(final String a) throws SQLException { │ │ │ │ │ │ + public final Statement getStatement() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getAsciiStream(a); │ │ │ │ │ │ + if (this.creator instanceof Statement) { │ │ │ │ │ │ + return (Statement)this.creatorProxy; │ │ │ │ │ │ + } │ │ │ │ │ │ + if (this.creator instanceof DatabaseMetaData) { │ │ │ │ │ │ + return null; │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new InternalError("Must be Statement or DatabaseMetaData -- Bad Creator: " + this.creator); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4264,20 +4264,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final InputStream getBinaryStream(final int a) throws SQLException { │ │ │ │ │ │ + public final ResultSetMetaData getMetaData() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBinaryStream(a); │ │ │ │ │ │ + return this.inner.getMetaData(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4286,20 +4286,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final InputStream getBinaryStream(final String a) throws SQLException { │ │ │ │ │ │ + public final boolean isClosed() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBinaryStream(a); │ │ │ │ │ │ + return this.isDetached(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4308,20 +4308,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object unwrap(final Class a) throws SQLException { │ │ │ │ │ │ + public final boolean isWrapperFor(final Class a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.unwrap((Class)a); │ │ │ │ │ │ + return this.inner.isWrapperFor(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -4330,20 +4330,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean isWrapperFor(final Class a) throws SQLException { │ │ │ │ │ │ + public final Object unwrap(final Class a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.isWrapperFor(a); │ │ │ │ │ │ + return this.inner.unwrap((Class)a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed ResultSet!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ ├── com/mchange/v2/c3p0/impl/NewProxyStatement.class │ │ │ │ │ ├── procyon -ec {} │ │ │ │ │ │ @@ -1,18 +1,18 @@ │ │ │ │ │ │ │ │ │ │ │ │ package com.mchange.v2.c3p0.impl; │ │ │ │ │ │ │ │ │ │ │ │ import com.mchange.v2.log.MLog; │ │ │ │ │ │ import java.lang.reflect.InvocationTargetException; │ │ │ │ │ │ import java.lang.reflect.Method; │ │ │ │ │ │ -import java.sql.SQLWarning; │ │ │ │ │ │ -import java.sql.ResultSet; │ │ │ │ │ │ import java.sql.Connection; │ │ │ │ │ │ import com.mchange.v2.sql.SqlUtils; │ │ │ │ │ │ import com.mchange.v2.log.MLevel; │ │ │ │ │ │ +import java.sql.ResultSet; │ │ │ │ │ │ +import java.sql.SQLWarning; │ │ │ │ │ │ import java.sql.SQLException; │ │ │ │ │ │ import javax.sql.ConnectionEventListener; │ │ │ │ │ │ import com.mchange.v2.log.MLogger; │ │ │ │ │ │ import com.mchange.v2.c3p0.C3P0ProxyStatement; │ │ │ │ │ │ import java.sql.Statement; │ │ │ │ │ │ │ │ │ │ │ │ public final class NewProxyStatement implements Statement, C3P0ProxyStatement │ │ │ │ │ │ @@ -26,18 +26,18 @@ │ │ │ │ │ │ │ │ │ │ │ │ public NewProxyStatement(final Statement inner) { │ │ │ │ │ │ this.cel = (ConnectionEventListener)new NewProxyStatement.NewProxyStatement$1(this); │ │ │ │ │ │ this.inner = inner; │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean execute(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ + public final int executeUpdate(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.execute(a, b); │ │ │ │ │ │ + return this.inner.executeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -46,18 +46,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean execute(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public final int executeUpdate(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.execute(a, b); │ │ │ │ │ │ + return this.inner.executeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -66,18 +66,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean execute(final String a) throws SQLException { │ │ │ │ │ │ + public final int executeUpdate(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.execute(a); │ │ │ │ │ │ + return this.inner.executeUpdate(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -86,18 +86,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean execute(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ + public final int executeUpdate(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.execute(a, b); │ │ │ │ │ │ + return this.inner.executeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -106,57 +106,38 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void close() throws SQLException { │ │ │ │ │ │ + public final int getMaxFieldSize() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - if (this.is_cached) { │ │ │ │ │ │ - this.parentPooledConnection.checkinStatement(this.inner); │ │ │ │ │ │ - } │ │ │ │ │ │ - else { │ │ │ │ │ │ - this.parentPooledConnection.markInactiveUncachedStatement(this.inner); │ │ │ │ │ │ - try { │ │ │ │ │ │ - this.inner.close(); │ │ │ │ │ │ - } │ │ │ │ │ │ - catch (final Exception e) { │ │ │ │ │ │ - if (NewProxyStatement.logger.isLoggable(MLevel.WARNING)) { │ │ │ │ │ │ - NewProxyStatement.logger.log(MLevel.WARNING, "Exception on close of inner statement.", (Throwable)e); │ │ │ │ │ │ - } │ │ │ │ │ │ - final SQLException sqle = SqlUtils.toSQLException((Throwable)e); │ │ │ │ │ │ - throw sqle; │ │ │ │ │ │ - } │ │ │ │ │ │ - } │ │ │ │ │ │ - this.detach(); │ │ │ │ │ │ - this.inner = null; │ │ │ │ │ │ - this.creatorProxy = null; │ │ │ │ │ │ - } │ │ │ │ │ │ + return this.inner.getMaxFieldSize(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ + if (this.isDetached()) { │ │ │ │ │ │ + throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ catch (final Exception exc2) { │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void cancel() throws SQLException { │ │ │ │ │ │ + public final void setMaxFieldSize(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.cancel(); │ │ │ │ │ │ + this.inner.setMaxFieldSize(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -165,18 +146,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean isClosed() throws SQLException { │ │ │ │ │ │ + public final int getMaxRows() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.isDetached(); │ │ │ │ │ │ + return this.inner.getMaxRows(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -185,21 +166,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Connection getConnection() throws SQLException { │ │ │ │ │ │ + public final void setMaxRows(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - return (Connection)this.creatorProxy; │ │ │ │ │ │ - } │ │ │ │ │ │ - throw new SQLException("You cannot operate on a closed Statement!"); │ │ │ │ │ │ + this.inner.setMaxRows(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -208,23 +186,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final ResultSet executeQuery(final String a) throws SQLException { │ │ │ │ │ │ + public final void setEscapeProcessing(final boolean a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - final ResultSet innerResultSet = this.inner.executeQuery(a); │ │ │ │ │ │ - if (innerResultSet == null) { │ │ │ │ │ │ - return null; │ │ │ │ │ │ - } │ │ │ │ │ │ - this.parentPooledConnection.markActiveResultSetForStatement(this.inner, innerResultSet); │ │ │ │ │ │ - return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ + this.inner.setEscapeProcessing(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -233,18 +206,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int executeUpdate(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ + public final int getQueryTimeout() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeUpdate(a, b); │ │ │ │ │ │ + return this.inner.getQueryTimeout(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -253,18 +226,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int executeUpdate(final String a) throws SQLException { │ │ │ │ │ │ + public final void setQueryTimeout(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeUpdate(a); │ │ │ │ │ │ + this.inner.setQueryTimeout(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -273,18 +246,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int executeUpdate(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public final SQLWarning getWarnings() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeUpdate(a, b); │ │ │ │ │ │ + return this.inner.getWarnings(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -293,18 +266,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int executeUpdate(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ + public final void clearWarnings() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeUpdate(a, b); │ │ │ │ │ │ + this.inner.clearWarnings(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -313,18 +286,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getMaxFieldSize() throws SQLException { │ │ │ │ │ │ + public final void setCursorName(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getMaxFieldSize(); │ │ │ │ │ │ + this.inner.setCursorName(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -333,18 +306,23 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setMaxFieldSize(final int a) throws SQLException { │ │ │ │ │ │ + public final ResultSet getResultSet() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setMaxFieldSize(a); │ │ │ │ │ │ + final ResultSet innerResultSet = this.inner.getResultSet(); │ │ │ │ │ │ + if (innerResultSet == null) { │ │ │ │ │ │ + return null; │ │ │ │ │ │ + } │ │ │ │ │ │ + this.parentPooledConnection.markActiveResultSetForStatement(this.inner, innerResultSet); │ │ │ │ │ │ + return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -353,18 +331,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getMaxRows() throws SQLException { │ │ │ │ │ │ + public final int getUpdateCount() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getMaxRows(); │ │ │ │ │ │ + return this.inner.getUpdateCount(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -373,18 +351,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setMaxRows(final int a) throws SQLException { │ │ │ │ │ │ + public final boolean getMoreResults() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setMaxRows(a); │ │ │ │ │ │ + return this.inner.getMoreResults(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -393,18 +371,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setEscapeProcessing(final boolean a) throws SQLException { │ │ │ │ │ │ + public final boolean getMoreResults(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setEscapeProcessing(a); │ │ │ │ │ │ + return this.inner.getMoreResults(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -413,18 +391,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getQueryTimeout() throws SQLException { │ │ │ │ │ │ + public final void setFetchDirection(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getQueryTimeout(); │ │ │ │ │ │ + this.inner.setFetchDirection(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -433,18 +411,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setQueryTimeout(final int a) throws SQLException { │ │ │ │ │ │ + public final int getFetchDirection() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setQueryTimeout(a); │ │ │ │ │ │ + return this.inner.getFetchDirection(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -453,18 +431,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final SQLWarning getWarnings() throws SQLException { │ │ │ │ │ │ + public final void setFetchSize(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getWarnings(); │ │ │ │ │ │ + this.inner.setFetchSize(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -473,18 +451,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void clearWarnings() throws SQLException { │ │ │ │ │ │ + public final int getFetchSize() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.clearWarnings(); │ │ │ │ │ │ + return this.inner.getFetchSize(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -493,18 +471,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setCursorName(final String a) throws SQLException { │ │ │ │ │ │ + public final int getResultSetConcurrency() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setCursorName(a); │ │ │ │ │ │ + return this.inner.getResultSetConcurrency(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -513,23 +491,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final ResultSet getResultSet() throws SQLException { │ │ │ │ │ │ + public final int getResultSetType() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - final ResultSet innerResultSet = this.inner.getResultSet(); │ │ │ │ │ │ - if (innerResultSet == null) { │ │ │ │ │ │ - return null; │ │ │ │ │ │ - } │ │ │ │ │ │ - this.parentPooledConnection.markActiveResultSetForStatement(this.inner, innerResultSet); │ │ │ │ │ │ - return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ + return this.inner.getResultSetType(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -538,18 +511,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getUpdateCount() throws SQLException { │ │ │ │ │ │ + public final void addBatch(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getUpdateCount(); │ │ │ │ │ │ + this.inner.addBatch(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -558,18 +531,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean getMoreResults() throws SQLException { │ │ │ │ │ │ + public final void clearBatch() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getMoreResults(); │ │ │ │ │ │ + this.inner.clearBatch(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -578,18 +551,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean getMoreResults(final int a) throws SQLException { │ │ │ │ │ │ + public final int[] executeBatch() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getMoreResults(a); │ │ │ │ │ │ + return this.inner.executeBatch(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -598,18 +571,23 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setFetchDirection(final int a) throws SQLException { │ │ │ │ │ │ + public final ResultSet getGeneratedKeys() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setFetchDirection(a); │ │ │ │ │ │ + final ResultSet innerResultSet = this.inner.getGeneratedKeys(); │ │ │ │ │ │ + if (innerResultSet == null) { │ │ │ │ │ │ + return null; │ │ │ │ │ │ + } │ │ │ │ │ │ + this.parentPooledConnection.markActiveResultSetForStatement(this.inner, innerResultSet); │ │ │ │ │ │ + return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -618,18 +596,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getFetchDirection() throws SQLException { │ │ │ │ │ │ + public final int getResultSetHoldability() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getFetchDirection(); │ │ │ │ │ │ + return this.inner.getResultSetHoldability(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -638,18 +616,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setFetchSize(final int a) throws SQLException { │ │ │ │ │ │ + public final void setPoolable(final boolean a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setFetchSize(a); │ │ │ │ │ │ + this.inner.setPoolable(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -658,18 +636,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getFetchSize() throws SQLException { │ │ │ │ │ │ + public final boolean isPoolable() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getFetchSize(); │ │ │ │ │ │ + return this.inner.isPoolable(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -678,18 +656,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getResultSetConcurrency() throws SQLException { │ │ │ │ │ │ + public final void closeOnCompletion() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getResultSetConcurrency(); │ │ │ │ │ │ + this.inner.closeOnCompletion(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -698,18 +676,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getResultSetType() throws SQLException { │ │ │ │ │ │ + public final boolean isCloseOnCompletion() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getResultSetType(); │ │ │ │ │ │ + return this.inner.isCloseOnCompletion(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -718,18 +696,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void addBatch(final String a) throws SQLException { │ │ │ │ │ │ + public final long getLargeUpdateCount() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.addBatch(a); │ │ │ │ │ │ + return this.inner.getLargeUpdateCount(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -738,18 +716,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void clearBatch() throws SQLException { │ │ │ │ │ │ + public final void setLargeMaxRows(final long a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.clearBatch(); │ │ │ │ │ │ + this.inner.setLargeMaxRows(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -758,18 +736,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int[] executeBatch() throws SQLException { │ │ │ │ │ │ + public final long getLargeMaxRows() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeBatch(); │ │ │ │ │ │ + return this.inner.getLargeMaxRows(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -778,23 +756,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final ResultSet getGeneratedKeys() throws SQLException { │ │ │ │ │ │ + public final long[] executeLargeBatch() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - final ResultSet innerResultSet = this.inner.getGeneratedKeys(); │ │ │ │ │ │ - if (innerResultSet == null) { │ │ │ │ │ │ - return null; │ │ │ │ │ │ - } │ │ │ │ │ │ - this.parentPooledConnection.markActiveResultSetForStatement(this.inner, innerResultSet); │ │ │ │ │ │ - return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ + return this.inner.executeLargeBatch(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -803,18 +776,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getResultSetHoldability() throws SQLException { │ │ │ │ │ │ + public final long executeLargeUpdate(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getResultSetHoldability(); │ │ │ │ │ │ + return this.inner.executeLargeUpdate(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -823,18 +796,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setPoolable(final boolean a) throws SQLException { │ │ │ │ │ │ + public final long executeLargeUpdate(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setPoolable(a); │ │ │ │ │ │ + return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -843,18 +816,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean isPoolable() throws SQLException { │ │ │ │ │ │ + public final long executeLargeUpdate(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.isPoolable(); │ │ │ │ │ │ + return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -863,18 +836,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void closeOnCompletion() throws SQLException { │ │ │ │ │ │ + public final long executeLargeUpdate(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.closeOnCompletion(); │ │ │ │ │ │ + return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -883,18 +856,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean isCloseOnCompletion() throws SQLException { │ │ │ │ │ │ + public final String enquoteLiteral(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.isCloseOnCompletion(); │ │ │ │ │ │ + return this.inner.enquoteLiteral(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -903,18 +876,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final long getLargeUpdateCount() throws SQLException { │ │ │ │ │ │ + public final String enquoteIdentifier(final String a, final boolean b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getLargeUpdateCount(); │ │ │ │ │ │ + return this.inner.enquoteIdentifier(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -923,18 +896,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setLargeMaxRows(final long a) throws SQLException { │ │ │ │ │ │ + public final boolean isSimpleIdentifier(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setLargeMaxRows(a); │ │ │ │ │ │ + return this.inner.isSimpleIdentifier(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -943,18 +916,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final long getLargeMaxRows() throws SQLException { │ │ │ │ │ │ + public final String enquoteNCharLiteral(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getLargeMaxRows(); │ │ │ │ │ │ + return this.inner.enquoteNCharLiteral(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -963,18 +936,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final long[] executeLargeBatch() throws SQLException { │ │ │ │ │ │ + public final boolean execute(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeBatch(); │ │ │ │ │ │ + return this.inner.execute(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -983,18 +956,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final long executeLargeUpdate(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ + public final boolean execute(final String a, final String[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ + return this.inner.execute(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1003,18 +976,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final long executeLargeUpdate(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ + public final boolean execute(final String a, final int[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ + return this.inner.execute(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1023,18 +996,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final long executeLargeUpdate(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public final boolean execute(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeUpdate(a, b); │ │ │ │ │ │ + return this.inner.execute(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1043,38 +1016,57 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final long executeLargeUpdate(final String a) throws SQLException { │ │ │ │ │ │ + public final void close() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.executeLargeUpdate(a); │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + if (this.is_cached) { │ │ │ │ │ │ + this.parentPooledConnection.checkinStatement(this.inner); │ │ │ │ │ │ + } │ │ │ │ │ │ + else { │ │ │ │ │ │ + this.parentPooledConnection.markInactiveUncachedStatement(this.inner); │ │ │ │ │ │ + try { │ │ │ │ │ │ + this.inner.close(); │ │ │ │ │ │ + } │ │ │ │ │ │ + catch (final Exception e) { │ │ │ │ │ │ + if (NewProxyStatement.logger.isLoggable(MLevel.WARNING)) { │ │ │ │ │ │ + NewProxyStatement.logger.log(MLevel.WARNING, "Exception on close of inner statement.", (Throwable)e); │ │ │ │ │ │ + } │ │ │ │ │ │ + final SQLException sqle = SqlUtils.toSQLException((Throwable)e); │ │ │ │ │ │ + throw sqle; │ │ │ │ │ │ + } │ │ │ │ │ │ + } │ │ │ │ │ │ + this.detach(); │ │ │ │ │ │ + this.inner = null; │ │ │ │ │ │ + this.creatorProxy = null; │ │ │ │ │ │ + } │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ - if (this.isDetached()) { │ │ │ │ │ │ - throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ - throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ catch (final Exception exc2) { │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String enquoteLiteral(final String a) throws SQLException { │ │ │ │ │ │ + public final void cancel() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.enquoteLiteral(a); │ │ │ │ │ │ + this.inner.cancel(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1083,18 +1075,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String enquoteIdentifier(final String a, final boolean b) throws SQLException { │ │ │ │ │ │ + public final boolean isClosed() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.enquoteIdentifier(a, b); │ │ │ │ │ │ + return this.isDetached(); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1103,18 +1095,21 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean isSimpleIdentifier(final String a) throws SQLException { │ │ │ │ │ │ + public final Connection getConnection() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.isSimpleIdentifier(a); │ │ │ │ │ │ + if (!this.isDetached()) { │ │ │ │ │ │ + return (Connection)this.creatorProxy; │ │ │ │ │ │ + } │ │ │ │ │ │ + throw new SQLException("You cannot operate on a closed Statement!"); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1123,18 +1118,23 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String enquoteNCharLiteral(final String a) throws SQLException { │ │ │ │ │ │ + public final ResultSet executeQuery(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.enquoteNCharLiteral(a); │ │ │ │ │ │ + final ResultSet innerResultSet = this.inner.executeQuery(a); │ │ │ │ │ │ + if (innerResultSet == null) { │ │ │ │ │ │ + return null; │ │ │ │ │ │ + } │ │ │ │ │ │ + this.parentPooledConnection.markActiveResultSetForStatement(this.inner, innerResultSet); │ │ │ │ │ │ + return (ResultSet)new NewProxyResultSet(innerResultSet, this.parentPooledConnection, (Object)this.inner, (Object)this); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1142,18 +1142,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final Object unwrap(final Class a) throws SQLException { │ │ │ │ │ │ + public final boolean isWrapperFor(final Class a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.unwrap((Class)a); │ │ │ │ │ │ + return this.inner.isWrapperFor(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1161,18 +1161,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean isWrapperFor(final Class a) throws SQLException { │ │ │ │ │ │ + public final Object unwrap(final Class a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.isWrapperFor(a); │ │ │ │ │ │ + return this.inner.unwrap((Class)a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ if (this.isDetached()) { │ │ │ │ │ │ throw new IllegalStateException("You can't operate on a closed Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ }