--- /srv/reproducible-results/rbuild-debian/r-b-build.1r12PyBl/b1/c3p0_0.9.1.2-10_arm64.changes +++ /srv/reproducible-results/rbuild-debian/r-b-build.1r12PyBl/b2/c3p0_0.9.1.2-10_arm64.changes ├── Files │ @@ -1,3 +1,3 @@ │ │ 6c92b77bc1609e8d36366f88ebbdfa3e 303584 doc optional libc3p0-java-doc_0.9.1.2-10_all.deb │ - 66ee5993be216b01d17d2cf3e08a5911 599852 java optional libc3p0-java_0.9.1.2-10_all.deb │ + 0a1768a7aae93c213ad3d5e9eb573900 599884 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 812 2018-12-25 14:16:25.000000 control.tar.xz │ │ --rw-r--r-- 0 0 0 598848 2018-12-25 14:16:25.000000 data.tar.xz │ │ +-rw-r--r-- 0 0 0 808 2018-12-25 14:16:25.000000 control.tar.xz │ │ +-rw-r--r-- 0 0 0 598884 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) 1916 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) 629198 2018-12-25 14:16:25.000000 ./usr/share/java/c3p0-0.9.1.2.jar │ │ │ │ +-rw-r--r-- 0 root (0) root (0) 629190 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: 629198 bytes, number of entries: 434 │ │ │ │ │ +Zip file size: 629190 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 348 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 │ │ │ │ │ @@ -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, 1481382 bytes uncompressed, 554728 bytes compressed: 62.6% │ │ │ │ │ +434 files, 1481382 bytes uncompressed, 554720 bytes compressed: 62.6% │ │ │ │ ├── com/mchange/v2/c3p0/impl/NewProxyCallableStatement.class │ │ │ │ │ ├── procyon -ec {} │ │ │ │ │ │ @@ -19,21 +19,21 @@ │ │ │ │ │ │ import java.sql.Blob; │ │ │ │ │ │ import java.io.Reader; │ │ │ │ │ │ import java.sql.SQLType; │ │ │ │ │ │ import java.io.InputStream; │ │ │ │ │ │ import java.sql.Time; │ │ │ │ │ │ import java.sql.Date; │ │ │ │ │ │ import java.math.BigDecimal; │ │ │ │ │ │ -import java.sql.Array; │ │ │ │ │ │ -import java.net.URL; │ │ │ │ │ │ import java.util.Calendar; │ │ │ │ │ │ import java.sql.Timestamp; │ │ │ │ │ │ import java.sql.Ref; │ │ │ │ │ │ -import java.sql.SQLException; │ │ │ │ │ │ import java.util.Map; │ │ │ │ │ │ +import java.sql.Array; │ │ │ │ │ │ +import java.net.URL; │ │ │ │ │ │ +import java.sql.SQLException; │ │ │ │ │ │ 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 Object getObject(final String a, final Map b) throws SQLException { │ │ │ │ │ │ + public final String getString(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getObject(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -66,18 +66,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final int a, final Class b) throws SQLException { │ │ │ │ │ │ + public final String getString(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getObject(a, (Class)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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -86,18 +86,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final int a, final Map b) throws SQLException { │ │ │ │ │ │ + public final URL getURL(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getObject(a, b); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -106,18 +106,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final int a) throws SQLException { │ │ │ │ │ │ + public final URL getURL(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getObject(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -126,18 +126,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final String a) throws SQLException { │ │ │ │ │ │ + public final void setURL(final String a, final URL b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getObject(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -146,18 +146,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final String a, final Class b) throws SQLException { │ │ │ │ │ │ + public final Array getArray(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getObject(a, (Class)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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -166,18 +166,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean getBoolean(final String a) throws SQLException { │ │ │ │ │ │ + public final Array getArray(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getBoolean(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -186,18 +186,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean getBoolean(final int a) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final String a, final Map b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getBoolean(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -206,18 +206,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte getByte(final String a) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final int a, final Class b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getByte(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 Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -226,18 +226,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte getByte(final int a) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getByte(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -246,18 +246,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final short getShort(final int a) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getShort(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -266,18 +266,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final short getShort(final String a) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final int a, final Map b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getShort(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -286,18 +286,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getInt(final String a) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final String a, final Class b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getInt(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 Statement!!!", exc); │ │ │ │ │ │ } │ │ │ │ │ │ throw exc; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -306,18 +306,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getInt(final int a) throws SQLException { │ │ │ │ │ │ + public final boolean getBoolean(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getInt(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -326,18 +326,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final long getLong(final int a) throws SQLException { │ │ │ │ │ │ + public final boolean getBoolean(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getLong(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -346,18 +346,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final long getLong(final String a) throws SQLException { │ │ │ │ │ │ + public final byte getByte(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getLong(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -366,18 +366,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final float getFloat(final String a) throws SQLException { │ │ │ │ │ │ + public final byte getByte(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getFloat(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -386,18 +386,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final float getFloat(final int a) throws SQLException { │ │ │ │ │ │ + public final short getShort(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getFloat(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -406,18 +406,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final double getDouble(final String a) throws SQLException { │ │ │ │ │ │ + public final short getShort(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getDouble(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -426,18 +426,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final double getDouble(final int a) throws SQLException { │ │ │ │ │ │ + public final int getInt(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getDouble(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -446,18 +446,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte[] getBytes(final int a) throws SQLException { │ │ │ │ │ │ + public final int getInt(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getBytes(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -466,18 +466,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte[] getBytes(final String a) throws SQLException { │ │ │ │ │ │ + public final long getLong(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getBytes(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -486,18 +486,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setBoolean(final String a, final boolean b) throws SQLException { │ │ │ │ │ │ + public final long getLong(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBoolean(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -506,18 +506,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setByte(final String a, final byte b) throws SQLException { │ │ │ │ │ │ + public final float getFloat(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setByte(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -526,18 +526,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setShort(final String a, final short b) throws SQLException { │ │ │ │ │ │ + public final float getFloat(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setShort(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -546,18 +546,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setInt(final String a, final int b) throws SQLException { │ │ │ │ │ │ + public final double getDouble(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setInt(a, b); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -566,18 +566,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setLong(final String a, final long b) throws SQLException { │ │ │ │ │ │ + public final double getDouble(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setLong(a, b); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -586,18 +586,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setFloat(final String a, final float b) throws SQLException { │ │ │ │ │ │ + public final byte[] getBytes(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setFloat(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -606,18 +606,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setDouble(final String a, final double b) throws SQLException { │ │ │ │ │ │ + public final byte[] getBytes(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDouble(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -626,18 +626,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Ref getRef(final int a) throws SQLException { │ │ │ │ │ │ + public final void setBoolean(final String a, final boolean b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getRef(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -646,18 +646,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Ref getRef(final String a) throws SQLException { │ │ │ │ │ │ + public final void setByte(final String a, final byte b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getRef(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -666,18 +666,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 void setShort(final String a, final short b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTimestamp(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -686,18 +686,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void setTimestamp(final String a, final Timestamp b) throws SQLException { │ │ │ │ │ │ + public final void setInt(final String a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTimestamp(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -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 setLong(final String a, final long b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setURL(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -726,18 +726,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Array getArray(final String a) throws SQLException { │ │ │ │ │ │ + public final void setFloat(final String a, final float b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getArray(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -746,18 +746,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Array getArray(final int a) throws SQLException { │ │ │ │ │ │ + public final void setDouble(final String a, final double b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getArray(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -766,18 +766,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getString(final String a) throws SQLException { │ │ │ │ │ │ + public final Ref getRef(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getString(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -786,18 +786,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getString(final int a) throws SQLException { │ │ │ │ │ │ + public final Ref getRef(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getString(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -806,18 +806,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final URL getURL(final String a) throws SQLException { │ │ │ │ │ │ + public final void setTimestamp(final String a, final Timestamp b, final Calendar c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getURL(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -826,18 +826,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final URL getURL(final int a) throws SQLException { │ │ │ │ │ │ + public final void setTimestamp(final String a, final Timestamp b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.getURL(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2465,18 +2465,18 @@ │ │ │ │ │ │ if (!this.isDetached()) { │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ - public final boolean execute() throws SQLException { │ │ │ │ │ │ + public final void setURL(final int a, final URL b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.execute(); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -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 setArray(final int a, final Array b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBoolean(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -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 boolean execute() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setByte(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -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 setBoolean(final int a, final boolean b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setShort(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -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 setByte(final int a, final byte b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setInt(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -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 setShort(final int a, final short b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setLong(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -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 setInt(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setFloat(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -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 setLong(final int a, final long b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDouble(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2617,18 +2617,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 setFloat(final int a, final float b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTimestamp(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2636,18 +2636,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 setDouble(final int a, final double b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTimestamp(a, b, c); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2655,18 +2655,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 setTimestamp(final int a, final Timestamp b, final Calendar c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setURL(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2674,18 +2674,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 setTimestamp(final int a, final Timestamp b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setArray(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; │ │ │ │ │ │ } │ │ │ │ ├── com/mchange/v2/c3p0/impl/NewProxyConnection.class │ │ │ │ │ ├── procyon -ec {} │ │ │ │ │ │ @@ -18,16 +18,16 @@ │ │ │ │ │ │ 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.util.concurrent.Executor; │ │ │ │ │ │ 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 void abort(final Executor a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.inner.setReadOnly(a); │ │ │ │ │ │ - this.parentPooledConnection.markNewReadOnly(a); │ │ │ │ │ │ + this.txn_known_resolved = false; │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -63,61 +63,61 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized void close() throws SQLException { │ │ │ │ │ │ + public synchronized void setReadOnly(final boolean a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - if (!this.isDetached()) { │ │ │ │ │ │ - final NewPooledConnection npc = this.parentPooledConnection; │ │ │ │ │ │ - this.detach(); │ │ │ │ │ │ - npc.markClosedProxyConnection(this, this.txn_known_resolved); │ │ │ │ │ │ - this.inner = null; │ │ │ │ │ │ - } │ │ │ │ │ │ + this.inner.setReadOnly(a); │ │ │ │ │ │ + this.parentPooledConnection.markNewReadOnly(a); │ │ │ │ │ │ } │ │ │ │ │ │ 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 void close() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - this.txn_known_resolved = false; │ │ │ │ │ │ - return this.inner.isReadOnly(); │ │ │ │ │ │ + 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 void abort(final Executor a) throws SQLException { │ │ │ │ │ │ + public synchronized boolean isReadOnly() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - this.inner.abort(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -126,18 +126,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized Statement createStatement() throws SQLException { │ │ │ │ │ │ + public synchronized Statement createStatement(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - final Statement innerStmt = this.inner.createStatement(); │ │ │ │ │ │ + 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); │ │ │ │ │ │ } │ │ │ │ │ │ @@ -148,18 +148,18 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public synchronized Statement createStatement(final int a, final int b) throws SQLException { │ │ │ │ │ │ + public synchronized Statement createStatement() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.txn_known_resolved = false; │ │ │ │ │ │ - final Statement innerStmt = this.inner.createStatement(a, b); │ │ │ │ │ │ + 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); │ │ │ │ │ │ } │ │ │ │ ├── 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.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,21 +20,17 @@ │ │ │ │ │ │ │ │ │ │ │ │ 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 { │ │ │ │ │ │ + public final String getURL() 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); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -43,17 +39,21 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean isReadOnly() throws SQLException { │ │ │ │ │ │ + public final ResultSet getAttributes(final String a, final String b, final String c, final String d) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - return this.inner.isReadOnly(); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -62,17 +62,17 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getURL() throws SQLException { │ │ │ │ │ │ + public final boolean isReadOnly() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ - return this.inner.getURL(); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ ├── com/mchange/v2/c3p0/impl/NewProxyPreparedStatement.class │ │ │ │ │ ├── procyon -ec {} │ │ │ │ │ │ @@ -20,19 +20,19 @@ │ │ │ │ │ │ import java.io.InputStream; │ │ │ │ │ │ import java.sql.Time; │ │ │ │ │ │ import java.sql.Date; │ │ │ │ │ │ import java.math.BigDecimal; │ │ │ │ │ │ import java.sql.Statement; │ │ │ │ │ │ import java.sql.ResultSet; │ │ │ │ │ │ import java.sql.ResultSetMetaData; │ │ │ │ │ │ -import java.sql.Array; │ │ │ │ │ │ -import java.net.URL; │ │ │ │ │ │ import java.util.Calendar; │ │ │ │ │ │ import java.sql.Timestamp; │ │ │ │ │ │ +import java.sql.Array; │ │ │ │ │ │ import java.sql.SQLException; │ │ │ │ │ │ +import java.net.URL; │ │ │ │ │ │ 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 void setURL(final int a, final URL b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - return this.inner.execute(); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -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 setArray(final int a, final Array b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setBoolean(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -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 boolean execute() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setByte(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -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 setBoolean(final int a, final boolean b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setShort(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -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 setByte(final int a, final byte b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setInt(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -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 setShort(final int a, final short b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setLong(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -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 setInt(final int a, final int b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setFloat(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -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 setLong(final int a, final long b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setDouble(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -205,18 +205,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 setFloat(final int a, final float b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTimestamp(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -225,18 +225,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 setDouble(final int a, final double b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setTimestamp(a, b, c); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -245,18 +245,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 setTimestamp(final int a, final Timestamp b, final Calendar c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setURL(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -265,18 +265,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 setTimestamp(final int a, final Timestamp b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ this.maybeDirtyTransaction(); │ │ │ │ │ │ - this.inner.setArray(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; │ │ │ │ │ │ } │ │ │ │ ├── com/mchange/v2/c3p0/impl/NewProxyResultSet.class │ │ │ │ │ ├── procyon -ec {} │ │ │ │ │ │ @@ -13,21 +13,21 @@ │ │ │ │ │ │ import java.sql.Timestamp; │ │ │ │ │ │ import java.sql.Time; │ │ │ │ │ │ import java.sql.Date; │ │ │ │ │ │ import java.util.Calendar; │ │ │ │ │ │ import java.math.BigDecimal; │ │ │ │ │ │ import java.sql.SQLWarning; │ │ │ │ │ │ import java.sql.ResultSetMetaData; │ │ │ │ │ │ -import java.net.URL; │ │ │ │ │ │ -import java.sql.Array; │ │ │ │ │ │ import java.sql.Ref; │ │ │ │ │ │ import java.sql.Connection; │ │ │ │ │ │ import java.sql.DatabaseMetaData; │ │ │ │ │ │ import java.sql.Statement; │ │ │ │ │ │ import java.util.Map; │ │ │ │ │ │ +import java.sql.Array; │ │ │ │ │ │ +import java.net.URL; │ │ │ │ │ │ import java.sql.SQLException; │ │ │ │ │ │ import javax.sql.ConnectionEventListener; │ │ │ │ │ │ import com.mchange.v2.log.MLogger; │ │ │ │ │ │ import java.sql.ResultSet; │ │ │ │ │ │ │ │ │ │ │ │ public final class NewProxyResultSet implements ResultSet │ │ │ │ │ │ { │ │ │ │ │ │ @@ -41,20 +41,20 @@ │ │ │ │ │ │ │ │ │ │ │ │ public NewProxyResultSet(final ResultSet inner) { │ │ │ │ │ │ this.cel = (ConnectionEventListener)new NewProxyResultSet.NewProxyResultSet$1(this); │ │ │ │ │ │ this.inner = inner; │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBytes(final int a, final byte[] b) throws SQLException { │ │ │ │ │ │ + public final String getString(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBytes(a, b); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -63,20 +63,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBytes(final String a, final byte[] b) throws SQLException { │ │ │ │ │ │ + public final String getString(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBytes(a, b); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -85,20 +85,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(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.getObject(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -107,20 +107,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final int a, final Map b) throws SQLException { │ │ │ │ │ │ + public final URL getURL(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getObject(a, b); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -129,20 +129,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final String a) throws SQLException { │ │ │ │ │ │ + public final Array getArray(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getObject(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -151,20 +151,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Object getObject(final int a, final Class b) throws SQLException { │ │ │ │ │ │ + public final Array getArray(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getObject(a, (Class)b); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -173,20 +173,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 updateBytes(final int a, final byte[] b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getObject(a, (Class)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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -195,20 +195,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 String 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -217,20 +217,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean getBoolean(final int a) 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.getBoolean(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -239,20 +239,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean getBoolean(final String a) 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.getBoolean(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -261,20 +261,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte getByte(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.getByte(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -283,20 +283,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte getByte(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.getByte(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -305,20 +305,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final short getShort(final String 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.getShort(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -327,20 +327,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final short getShort(final int a) throws SQLException { │ │ │ │ │ │ + public final Object getObject(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getShort(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -349,20 +349,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getInt(final int a) throws SQLException { │ │ │ │ │ │ + public final boolean getBoolean(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getInt(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -371,20 +371,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final int getInt(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.getInt(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -393,20 +393,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final long getLong(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.getLong(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -415,20 +415,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final long getLong(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.getLong(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -437,20 +437,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final float getFloat(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.getFloat(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -459,20 +459,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final float getFloat(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.getFloat(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -481,20 +481,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final double getDouble(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.getDouble(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -503,20 +503,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final double getDouble(final String a) throws SQLException { │ │ │ │ │ │ + public final int getInt(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getDouble(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -525,20 +525,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte[] getBytes(final int a) throws SQLException { │ │ │ │ │ │ + public final long getLong(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBytes(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -547,20 +547,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final byte[] getBytes(final String a) throws SQLException { │ │ │ │ │ │ + public final long getLong(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBytes(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -569,20 +569,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean last() throws SQLException { │ │ │ │ │ │ + public final float getFloat(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.last(); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -591,20 +591,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean next() throws SQLException { │ │ │ │ │ │ + public final float getFloat(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.next(); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -613,20 +613,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean first() throws SQLException { │ │ │ │ │ │ + public final double getDouble(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.first(); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -635,57 +635,42 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void close() throws SQLException { │ │ │ │ │ │ + public final double getDouble(final String a) 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; │ │ │ │ │ │ - } │ │ │ │ │ │ + return this.inner.getDouble(a); │ │ │ │ │ │ } │ │ │ │ │ │ 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 byte[] getBytes(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getType(); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -694,20 +679,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Ref getRef(final int a) throws SQLException { │ │ │ │ │ │ + public final byte[] getBytes(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getRef(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -716,20 +701,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Ref getRef(final String a) throws SQLException { │ │ │ │ │ │ + public final boolean last() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getRef(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -738,20 +723,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final boolean previous() throws SQLException { │ │ │ │ │ │ + public final boolean next() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.previous(); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -760,20 +745,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Array getArray(final int a) throws SQLException { │ │ │ │ │ │ + public final boolean first() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getArray(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -782,42 +767,57 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Array getArray(final String a) throws SQLException { │ │ │ │ │ │ + public final void close() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getArray(a); │ │ │ │ │ │ + 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 boolean absolute(final int a) throws SQLException { │ │ │ │ │ │ + public final int getType() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.absolute(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -826,20 +826,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getString(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.getString(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -848,20 +848,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final String getString(final String a) throws SQLException { │ │ │ │ │ │ + public final Ref getRef(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getString(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -870,20 +870,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final URL getURL(final int a) throws SQLException { │ │ │ │ │ │ + public final boolean previous() throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getURL(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -892,20 +892,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final URL getURL(final String a) throws SQLException { │ │ │ │ │ │ + public final boolean absolute(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getURL(a); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1206,20 +1206,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final BigDecimal getBigDecimal(final String 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.getBigDecimal(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1250,20 +1250,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final BigDecimal getBigDecimal(final int a, final int b) throws SQLException { │ │ │ │ │ │ + public final BigDecimal getBigDecimal(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getBigDecimal(a, b); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1272,15 +1272,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final int a, final Calendar b) 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.getDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -1316,20 +1316,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final String 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.getDate(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1338,20 +1338,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Date getDate(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Date getDate(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getDate(a, b); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1382,20 +1382,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Time getTime(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getTime(a, b); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1404,20 +1404,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Time getTime(final int 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.getTime(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1448,20 +1448,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Timestamp getTimestamp(final String a) throws SQLException { │ │ │ │ │ │ + public final Timestamp getTimestamp(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getTimestamp(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1470,20 +1470,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Timestamp getTimestamp(final String a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Timestamp getTimestamp(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getTimestamp(a, b); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1492,20 +1492,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Timestamp getTimestamp(final int a) 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.getTimestamp(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1514,20 +1514,20 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Timestamp getTimestamp(final int a, final Calendar b) throws SQLException { │ │ │ │ │ │ + public final Timestamp getTimestamp(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - return this.inner.getTimestamp(a, b); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -1536,15 +1536,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Blob getBlob(final String a) throws SQLException { │ │ │ │ │ │ + public final Blob getBlob(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ return this.inner.getBlob(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -1558,15 +1558,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final Blob getBlob(final int a) throws SQLException { │ │ │ │ │ │ + public final Blob getBlob(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ return this.inner.getBlob(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -1976,15 +1976,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final InputStream getUnicodeStream(final int a) throws SQLException { │ │ │ │ │ │ + public final InputStream getUnicodeStream(final String a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ return this.inner.getUnicodeStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -1998,15 +1998,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final InputStream getUnicodeStream(final String a) throws SQLException { │ │ │ │ │ │ + public final InputStream getUnicodeStream(final int a) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ return this.inner.getUnicodeStream(a); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2438,15 +2438,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateShort(final String a, final short b) throws SQLException { │ │ │ │ │ │ + public final void updateShort(final int a, final short b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateShort(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2460,15 +2460,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateShort(final int a, final short b) throws SQLException { │ │ │ │ │ │ + public final void updateShort(final String a, final short b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateShort(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2570,15 +2570,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateFloat(final String a, final float b) throws SQLException { │ │ │ │ │ │ + public final void updateFloat(final int a, final float b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateFloat(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2592,15 +2592,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateFloat(final int a, final float b) throws SQLException { │ │ │ │ │ │ + public final void updateFloat(final String a, final float b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateFloat(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2614,15 +2614,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateDouble(final String a, final double 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.updateDouble(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2636,15 +2636,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateDouble(final int a, final double 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.updateDouble(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2658,15 +2658,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBigDecimal(final String a, final BigDecimal b) throws SQLException { │ │ │ │ │ │ + public final void updateBigDecimal(final int a, final BigDecimal b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateBigDecimal(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2680,15 +2680,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBigDecimal(final int a, final BigDecimal b) throws SQLException { │ │ │ │ │ │ + public final void updateBigDecimal(final String a, final BigDecimal b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateBigDecimal(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2746,15 +2746,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateDate(final int a, final Date b) throws SQLException { │ │ │ │ │ │ + public final void updateDate(final String a, final Date b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2768,15 +2768,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateDate(final String a, final Date b) throws SQLException { │ │ │ │ │ │ + public final void updateDate(final int a, final Date b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateDate(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2790,15 +2790,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateTime(final int a, final Time b) throws SQLException { │ │ │ │ │ │ + public final void updateTime(final String a, final Time b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateTime(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2812,15 +2812,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateTime(final String a, final Time b) throws SQLException { │ │ │ │ │ │ + public final void updateTime(final int a, final Time b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateTime(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2834,15 +2834,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateTimestamp(final int a, final Timestamp b) throws SQLException { │ │ │ │ │ │ + public final void updateTimestamp(final String a, final Timestamp b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateTimestamp(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2856,15 +2856,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateTimestamp(final String a, final Timestamp b) throws SQLException { │ │ │ │ │ │ + public final void updateTimestamp(final int a, final Timestamp b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateTimestamp(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -2922,20 +2922,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 updateAsciiStream(final int a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateAsciiStream(a, b, c); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2966,20 +2966,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 updateAsciiStream(final String a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateAsciiStream(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -2988,15 +2988,15 @@ │ │ │ │ │ │ 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 void updateAsciiStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateAsciiStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3010,15 +3010,15 @@ │ │ │ │ │ │ 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 updateBinaryStream(final int a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3032,15 +3032,15 @@ │ │ │ │ │ │ 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 updateBinaryStream(final int a, final InputStream b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateBinaryStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3054,20 +3054,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 updateBinaryStream(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBinaryStream(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3076,20 +3076,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 updateBinaryStream(final String a, final InputStream b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateBinaryStream(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3120,15 +3120,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBinaryStream(final String 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.updateBinaryStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3164,15 +3164,15 @@ │ │ │ │ │ │ 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 updateCharacterStream(final String a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateCharacterStream(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3186,15 +3186,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateCharacterStream(final String 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.updateCharacterStream(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3208,20 +3208,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 updateCharacterStream(final int a, final Reader b, final long c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateCharacterStream(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3252,20 +3252,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 updateCharacterStream(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateCharacterStream(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3274,15 +3274,15 @@ │ │ │ │ │ │ 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 updateObject(final String a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3296,20 +3296,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 updateObject(final int a, final Object b, final SQLType c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateObject(a, b, c, d); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3318,15 +3318,15 @@ │ │ │ │ │ │ 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 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.updateObject(a, b, c, d); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3340,20 +3340,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 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.updateObject(a, b, c); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3362,15 +3362,15 @@ │ │ │ │ │ │ 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 updateObject(final int a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateObject(a, b, c); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3384,15 +3384,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateObject(final String a, final Object 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.updateObject(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3406,20 +3406,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 updateObject(final String a, final Object b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateObject(a, b, c); │ │ │ │ │ │ + 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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3428,20 +3428,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 updateObject(final String a, final Object b, final int c) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ - this.inner.updateObject(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; │ │ │ │ │ │ } │ │ │ │ │ │ @@ -3604,15 +3604,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateRef(final String a, final Ref b) throws SQLException { │ │ │ │ │ │ + public final void updateRef(final int a, final Ref b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateRef(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3626,15 +3626,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateRef(final int a, final Ref b) throws SQLException { │ │ │ │ │ │ + public final void updateRef(final String a, final Ref b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateRef(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3714,15 +3714,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBlob(final String a, final Blob b) throws SQLException { │ │ │ │ │ │ + public final void updateBlob(final String a, final InputStream b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateBlob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3758,15 +3758,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateBlob(final String a, final InputStream 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.updateBlob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3780,15 +3780,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateClob(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void updateClob(final String a, final Clob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3802,15 +3802,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void updateClob(final String a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3824,15 +3824,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateClob(final String a, final Clob b) throws SQLException { │ │ │ │ │ │ + public final void updateClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3956,15 +3956,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateRowId(final String a, final RowId b) throws SQLException { │ │ │ │ │ │ + public final void updateRowId(final int a, final RowId b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateRowId(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -3978,15 +3978,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateRowId(final int a, final RowId b) throws SQLException { │ │ │ │ │ │ + public final void updateRowId(final String a, final RowId b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateRowId(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -4000,15 +4000,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNString(final int a, final String b) throws SQLException { │ │ │ │ │ │ + public final void updateNString(final String a, final String b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateNString(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -4022,15 +4022,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNString(final String a, final String b) throws SQLException { │ │ │ │ │ │ + public final void updateNString(final int a, final String b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateNString(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -4044,15 +4044,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ + public final void updateNClob(final String a, final NClob b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) { │ │ │ │ │ │ @@ -4088,15 +4088,15 @@ │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ throw new RuntimeException(exc2); │ │ │ │ │ │ } │ │ │ │ │ │ } │ │ │ │ │ │ │ │ │ │ │ │ @Override │ │ │ │ │ │ - public final void updateNClob(final String a, final NClob b) throws SQLException { │ │ │ │ │ │ + public final void updateNClob(final int a, final Reader b) throws SQLException { │ │ │ │ │ │ try { │ │ │ │ │ │ if (this.proxyConn != null) { │ │ │ │ │ │ this.proxyConn.maybeDirtyTransaction(); │ │ │ │ │ │ } │ │ │ │ │ │ this.inner.updateNClob(a, b); │ │ │ │ │ │ } │ │ │ │ │ │ catch (final NullPointerException exc) {