activerecord-jdbc-alt-adapter 52.4.0-java → 61.0.0-java

data/src/java/arjdbc/jdbc/RubyJdbcConnection.java

@@ -73,7 +73,6 @@ import org.jruby.RubyBoolean;
 import org.jruby.RubyClass;
 import org.jruby.RubyException;
 import org.jruby.RubyFixnum;
-import org.jruby.RubyFloat;
 import org.jruby.RubyHash;
 import org.jruby.RubyIO;
 import org.jruby.RubyInteger;
@@ -86,6 +85,8 @@ import org.jruby.RubyTime;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.ext.bigdecimal.RubyBigDecimal;
+import org.jruby.ext.date.RubyDate;
+import org.jruby.ext.date.RubyDateTime;
 import org.jruby.javasupport.JavaEmbedUtils;
 import org.jruby.javasupport.JavaUtil;
 import org.jruby.runtime.Block;
@@ -124,6 +125,7 @@ public class RubyJdbcConnection extends RubyObject {
     private IRubyObject config;
     private IRubyObject adapter; // the AbstractAdapter instance we belong to
     private volatile boolean connected = true;
+    private RubyClass attributeClass;
 
     private boolean lazy = false; // final once set on initialize
     private boolean jndi; // final once set on initialize
@@ -132,6 +134,7 @@ public class RubyJdbcConnection extends RubyObject {
 
     protected RubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
+        attributeClass = runtime.getModule("ActiveModel").getClass("Attribute");
     }
 
     private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
@@ -147,11 +150,6 @@ public class RubyJdbcConnection extends RubyObject {
         return JdbcConnection;
     }
 
-    @Deprecated
-    public static RubyClass getJdbcConnectionClass(final Ruby runtime) {
-        return getConnectionAdapters(runtime).getClass("JdbcConnection");
-    }
-
     public static RubyClass getJdbcConnection(final Ruby runtime) {
         return (RubyClass) getConnectionAdapters(runtime).getConstantAt("JdbcConnection");
     }
@@ -231,34 +229,30 @@ public class RubyJdbcConnection extends RubyObject {
 
     @JRubyMethod(name = "transaction_isolation", alias = "get_transaction_isolation")
     public IRubyObject get_transaction_isolation(final ThreadContext context) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                final int level = connection.getTransactionIsolation();
-                final String isolationSymbol = formatTransactionIsolationLevel(level);
-                if ( isolationSymbol == null ) return context.nil;
-                return context.runtime.newSymbol(isolationSymbol);
-            }
+        return withConnection(context, connection -> {
+            final int level = connection.getTransactionIsolation();
+            final String isolationSymbol = formatTransactionIsolationLevel(level);
+            if ( isolationSymbol == null ) return context.nil;
+            return context.runtime.newSymbol(isolationSymbol);
         });
     }
 
     @JRubyMethod(name = "transaction_isolation=", alias = "set_transaction_isolation")
     public IRubyObject set_transaction_isolation(final ThreadContext context, final IRubyObject isolation) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                final int level;
-                if ( isolation.isNil() ) {
-                    level = connection.getMetaData().getDefaultTransactionIsolation();
-                }
-                else {
-                    level = mapTransactionIsolationLevel(isolation);
-                }
+        return withConnection(context, connection -> {
+            final int level;
+            if ( isolation.isNil() ) {
+                level = connection.getMetaData().getDefaultTransactionIsolation();
+            }
+            else {
+                level = mapTransactionIsolationLevel(isolation);
+            }
 
-                connection.setTransactionIsolation(level);
+            connection.setTransactionIsolation(level);
 
-                final String isolationSymbol = formatTransactionIsolationLevel(level);
-                if ( isolationSymbol == null ) return context.nil;
-                return context.runtime.newSymbol(isolationSymbol);
-            }
+            final String isolationSymbol = formatTransactionIsolationLevel(level);
+            if ( isolationSymbol == null ) return context.nil;
+            return context.runtime.newSymbol(isolationSymbol);
         });
     }
 
@@ -306,31 +300,25 @@ public class RubyJdbcConnection extends RubyObject {
         final IRubyObject[] args) throws SQLException {
         final IRubyObject isolation = args.length > 0 ? args[0] : null;
 
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                final DatabaseMetaData metaData = connection.getMetaData();
-                final boolean supported;
-                if ( isolation != null && ! isolation.isNil() ) {
-                    final int level = mapTransactionIsolationLevel(isolation);
-                    supported = metaData.supportsTransactionIsolationLevel(level);
-                }
-                else {
-                    final int level = metaData.getDefaultTransactionIsolation();
-                    supported = level > Connection.TRANSACTION_NONE; // > 0
-                }
-                return context.runtime.newBoolean(supported);
+        return withConnection(context, (Callable<IRubyObject>) connection -> {
+            final DatabaseMetaData metaData = connection.getMetaData();
+            final boolean supported;
+            if ( isolation != null && ! isolation.isNil() ) {
+                final int level = mapTransactionIsolationLevel(isolation);
+                supported = metaData.supportsTransactionIsolationLevel(level);
             }
+            else {
+                final int level = metaData.getDefaultTransactionIsolation();
+                supported = level > Connection.TRANSACTION_NONE; // > 0
+            }
+            return context.runtime.newBoolean(supported);
         });
     }
 
     @JRubyMethod(name = {"begin", "transaction"}, required = 1) // optional isolation argument for AR-4.0
     public IRubyObject begin(final ThreadContext context, final IRubyObject isolation) {
         try { // handleException == false so we can handle setTXIsolation
-            return withConnection(context, false, new Callable<IRubyObject>() {
-                public IRubyObject call(final Connection connection) throws SQLException {
-                    return beginTransaction(context, connection, isolation == context.nil ? null : isolation);
-                }
-            });
+            return withConnection(context, false, connection -> beginTransaction(context, connection, isolation == context.nil ? null : isolation));
         } catch (SQLException e) {
             return handleException(context, e);
         }
@@ -339,11 +327,7 @@ public class RubyJdbcConnection extends RubyObject {
     @JRubyMethod(name = {"begin", "transaction"}) // optional isolation argument for AR-4.0
     public IRubyObject begin(final ThreadContext context) {
         try { // handleException == false so we can handle setTXIsolation
-            return withConnection(context, false, new Callable<IRubyObject>() {
-                public IRubyObject call(final Connection connection) throws SQLException {
-                    return beginTransaction(context, connection, null);
-                }
-            });
+            return withConnection(context, false, connection -> beginTransaction(context, connection, null));
         } catch (SQLException e) {
             return handleException(context, e);
         }
@@ -373,12 +357,12 @@ public class RubyJdbcConnection extends RubyObject {
 
     @JRubyMethod(name = "commit")
     public IRubyObject commit(final ThreadContext context) {
-        final Connection connection = getConnection(true);
         try {
+            final Connection connection = getConnectionInternal(true);
             if ( ! connection.getAutoCommit() ) {
                 try {
                     connection.commit();
-                    resetSavepoints(context); // if any
+                    resetSavepoints(context, connection); // if any
                     return context.runtime.newBoolean(true);
                 }
                 finally {
@@ -394,13 +378,13 @@ public class RubyJdbcConnection extends RubyObject {
 
     @JRubyMethod(name = "rollback")
     public IRubyObject rollback(final ThreadContext context) {
-        final Connection connection = getConnection(true);
         try {
+            final Connection connection = getConnectionInternal(true);
             if ( ! connection.getAutoCommit() ) {
                 try {
                     connection.rollback();
-                    resetSavepoints(context); // if any
-                    return context.runtime.getTrue();
+                    resetSavepoints(context, connection); // if any
+                    return context.tru;
                 } finally {
                     connection.setAutoCommit(true);
                 }
@@ -414,11 +398,9 @@ public class RubyJdbcConnection extends RubyObject {
 
     @JRubyMethod(name = "supports_savepoints?")
     public IRubyObject supports_savepoints_p(final ThreadContext context) throws SQLException {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                final DatabaseMetaData metaData = connection.getMetaData();
-                return context.runtime.newBoolean( metaData.supportsSavepoints() );
-            }
+        return withConnection(context, (Callable<IRubyObject>) connection -> {
+            final DatabaseMetaData metaData = connection.getMetaData();
+            return context.runtime.newBoolean( metaData.supportsSavepoints() );
         });
     }
 
@@ -429,8 +411,8 @@ public class RubyJdbcConnection extends RubyObject {
 
     @JRubyMethod(name = "create_savepoint", required = 1)
     public IRubyObject create_savepoint(final ThreadContext context, IRubyObject name) {
-        final Connection connection = getConnection(true);
         try {
+            final Connection connection = getConnectionInternal(true);
             connection.setAutoCommit(false);
 
             final Savepoint savepoint ;
@@ -458,8 +440,8 @@ public class RubyJdbcConnection extends RubyObject {
     public IRubyObject rollback_savepoint(final ThreadContext context, final IRubyObject name) {
         if (name == context.nil) throw context.runtime.newArgumentError("nil savepoint name given");
 
-        final Connection connection = getConnection(true);
         try {
+            final Connection connection = getConnectionInternal(true);
             Savepoint savepoint = getSavepoints(context).get(name);
             if ( savepoint == null ) {
                 throw context.runtime.newRuntimeError("could not rollback savepoint: '" + name + "' (not set)");
@@ -476,7 +458,6 @@ public class RubyJdbcConnection extends RubyObject {
     public IRubyObject release_savepoint(final ThreadContext context, final IRubyObject name) {
         if (name == context.nil) throw context.runtime.newArgumentError("nil savepoint name given");
 
-        final Connection connection = getConnection(true);
         try {
             Object savepoint = getSavepoints(context).remove(name);
 
@@ -487,6 +468,7 @@ public class RubyJdbcConnection extends RubyObject {
                 savepoint = ((IRubyObject) savepoint).toJava(Savepoint.class);
             }
 
+            final Connection connection = getConnectionInternal(true);
             releaseSavepoint(connection, (Savepoint) savepoint);
             return context.nil;
         }
@@ -525,7 +507,7 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     @SuppressWarnings("unchecked")
-    private final Map<IRubyObject, Savepoint> getSavepoints(final boolean init) {
+    private Map<IRubyObject, Savepoint> getSavepoints(final boolean init) {
         if ( hasInternalVariable("savepoints") ) {
             return (Map<IRubyObject, Savepoint>) getInternalVariable("savepoints");
         }
@@ -537,7 +519,7 @@ public class RubyJdbcConnection extends RubyObject {
         return null;
     }
 
-    protected boolean resetSavepoints(final ThreadContext context) {
+    protected boolean resetSavepoints(final ThreadContext context, final Connection connection) throws SQLException {
         if ( hasInternalVariable("savepoints") ) {
             removeInternalVariable("savepoints");
             return true;
@@ -545,13 +527,6 @@ public class RubyJdbcConnection extends RubyObject {
         return false;
     }
 
-    @Deprecated // second argument is now mandatory - only kept for compatibility
-    @JRubyMethod(required = 1)
-    public final IRubyObject initialize(final ThreadContext context, final IRubyObject config) {
-        doInitialize(context, config, context.nil);
-        return this;
-    }
-
     @JRubyMethod(required = 2)
     public final IRubyObject initialize(final ThreadContext context, final IRubyObject config, final IRubyObject adapter) {
         doInitialize(context, config, adapter);
@@ -559,12 +534,17 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     protected void doInitialize(final ThreadContext context, final IRubyObject config, final IRubyObject adapter) {
-        this.config = config; this.adapter = adapter;
+        this.config = config;
+        this.adapter = adapter;
 
         this.jndi = setupConnectionFactory(context);
         this.lazy = jndi; // JNDIs are lazy by default otherwise eager
         try {
-            initConnection(context);
+            if (adapter == null || adapter == context.nil) {
+                warn(context, "adapter not set, please pass adapter on JdbcConnection#initialize(config, adapter)");
+            }
+
+            if (!lazy) setConnection(newConnection());
         }
         catch (SQLException e) {
             String message = e.getMessage();
@@ -575,7 +555,7 @@ public class RubyJdbcConnection extends RubyObject {
         IRubyObject value = getConfigValue(context, "configure_connection");
         if ( value == context.nil ) this.configureConnection = true;
         else {
-            this.configureConnection = value != context.runtime.getFalse();
+            this.configureConnection = value != context.fals;
         }
 
         IRubyObject jdbcFetchSize = getConfigValue(context, "jdbc_fetch_size");
@@ -586,7 +566,6 @@ public class RubyJdbcConnection extends RubyObject {
 
     @JRubyMethod(name = "adapter")
     public IRubyObject adapter(final ThreadContext context) {
-        final IRubyObject adapter = getAdapter();
         return adapter == null ? context.nil : adapter;
     }
 
@@ -601,43 +580,9 @@ public class RubyJdbcConnection extends RubyObject {
         return factory;
     }
 
-    /**
-     * Called during <code>initialize</code> after the connection factory
-     * has been set to check if we can connect and/or perform any initialization
-     * necessary.
-     * <br/>
-     * NOTE: connection has not been configured at this point,
-     * nor should we retry - we're creating a brand new JDBC connection
-     *
-     * @param context
-     * @return connection
-     */
-    @Deprecated
-    @JRubyMethod(name = "init_connection")
-    public synchronized IRubyObject init_connection(final ThreadContext context) {
-        try {
-            return initConnection(context);
-        }
-        catch (SQLException e) {
-            return handleException(context, e); // throws
-        }
-    }
-
-    private IRubyObject initConnection(final ThreadContext context) throws SQLException {
-        final IRubyObject adapter = getAdapter(); // self.adapter
-        if ( adapter == null || adapter == context.nil ) {
-            warn(context, "adapter not set, please pass adapter on JdbcConnection#initialize(config, adapter)");
-        }
-
-        if ( ! lazy ) setConnection( newConnection() );
-
-        return context.nil;
-    }
-
     private void configureConnection() {
         if ( ! configureConnection ) return; // return false;
 
-        final IRubyObject adapter = getAdapter(); // self.adapter
         if ( adapter != null && ! adapter.isNil() ) {
             if ( adapter.respondsTo("configure_connection") ) {
                 final ThreadContext context = getRuntime().getCurrentContext();
@@ -659,7 +604,7 @@ public class RubyJdbcConnection extends RubyObject {
 
     @JRubyMethod(name = "jdbc_connection", alias = "connection", required = 1)
     public final IRubyObject connection(final ThreadContext context, final IRubyObject unwrap) {
-        if ( unwrap == context.nil || unwrap == context.runtime.getFalse() ) {
+        if ( unwrap == context.nil || unwrap == context.fals ) {
             return connection(context);
         }
         Connection connection = connectionImpl(context);
@@ -668,11 +613,7 @@ public class RubyJdbcConnection extends RubyObject {
                 return convertJavaToRuby( connection.unwrap(Connection.class) );
             }
         }
-        catch (AbstractMethodError e) {
-            debugStackTrace(context, e);
-            warn(context, "driver/pool connection does not support unwrapping: " + e);
-        }
-        catch (SQLException e) {
+        catch (AbstractMethodError | SQLException e) {
             debugStackTrace(context, e);
             warn(context, "driver/pool connection does not support unwrapping: " + e);
         }
@@ -695,18 +636,25 @@ public class RubyJdbcConnection extends RubyObject {
 
     @JRubyMethod(name = "active?", alias = "valid?")
     public RubyBoolean active_p(final ThreadContext context) {
-        if ( ! connected ) return context.runtime.getFalse();
-        if ( isJndi() ) {
+        if ( ! connected ) return context.fals;
+        if (jndi) {
             // for JNDI the data-source / pool is supposed to
             // manage connections for us thus no valid check!
             boolean active = getConnectionFactory() != null;
             return context.runtime.newBoolean( active );
         }
-        final Connection connection = getConnection();
-        if ( connection == null ) return context.runtime.getFalse(); // unlikely
+        final Connection connection = getConnection(false);
+        if ( connection == null ) return context.fals; // unlikely
         return context.runtime.newBoolean( isConnectionValid(context, connection) );
     }
 
+    @JRubyMethod(name = "really_valid?")
+    public RubyBoolean really_valid_p(final ThreadContext context) {
+        final Connection connection = getConnection(true);
+        if (connection == null) return context.fals;
+        return context.runtime.newBoolean(isConnectionValid(context, connection));
+    }
+
     @JRubyMethod(name = "disconnect!")
     public synchronized IRubyObject disconnect(final ThreadContext context) {
         setConnection(null); connected = false;
@@ -727,38 +675,43 @@ public class RubyJdbcConnection extends RubyObject {
 
     private void connectImpl(final boolean forceConnection) throws SQLException {
         setConnection( forceConnection ? newConnection() : null );
-        if ( forceConnection ) configureConnection();
+        if (forceConnection) {
+            if (getConnectionImpl() == null) throw new SQLException("Didn't get a connection. Wrong URL?");
+            configureConnection();
+        }
     }
 
     @JRubyMethod(name = "read_only?")
     public IRubyObject is_read_only(final ThreadContext context) {
-        final Connection connection = getConnection(false);
-        if ( connection != null ) {
-            try {
-                return context.runtime.newBoolean( connection.isReadOnly() );
+        try {
+        final Connection connection = getConnectionInternal(false);
+            if (connection != null) {
+                return context.runtime.newBoolean(connection.isReadOnly());
             }
-            catch (SQLException e) { return handleException(context, e); }
+        } catch (SQLException e) {
+            return handleException(context, e);
         }
         return context.nil;
     }
 
     @JRubyMethod(name = "read_only=")
     public IRubyObject set_read_only(final ThreadContext context, final IRubyObject flag) {
-        final Connection connection = getConnection(true);
         try {
+            final Connection connection = getConnectionInternal(true);
             connection.setReadOnly( flag.isTrue() );
             return context.runtime.newBoolean( connection.isReadOnly() );
+        } catch (SQLException e) {
+            return handleException(context, e);
         }
-        catch (SQLException e) { return handleException(context, e); }
     }
 
     @JRubyMethod(name = { "open?" /* "conn?" */ })
     public IRubyObject open_p(final ThreadContext context) {
-        final Connection connection = getConnection(false);
+        try {
+            final Connection connection = getConnectionInternal(false);
 
-        if (connection == null) return context.runtime.getFalse();
+            if (connection == null) return context.fals;
 
-        try {
             // NOTE: isClosed method generally cannot be called to determine
             // whether a connection to a database is valid or invalid ...
             return context.runtime.newBoolean(!connection.isClosed());
@@ -771,10 +724,10 @@ public class RubyJdbcConnection extends RubyObject {
     public IRubyObject close(final ThreadContext context) {
         final Connection connection = getConnection(false);
 
-        if (connection == null) return context.runtime.getFalse();
+        if (connection == null) return context.fals;
 
         try {
-            if (connection.isClosed()) return context.runtime.getFalse();
+            if (connection.isClosed()) return context.fals;
 
             setConnection(null); // does connection.close();
         } catch (Exception e) {
@@ -784,69 +737,65 @@ public class RubyJdbcConnection extends RubyObject {
 
         // ActiveRecord expects a closed connection to not try and re-open a connection
         // whereas JNDI expects that.
-        if (!isJndi()) disconnect(context);
+        if (!jndi) disconnect(context);
 
-        return context.runtime.getTrue();
+        return context.tru;
     }
 
     @JRubyMethod(name = "database_name")
     public IRubyObject database_name(final ThreadContext context) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                String name = connection.getCatalog();
-                if ( name == null ) {
-                    name = connection.getMetaData().getUserName();
-                    if ( name == null ) return context.nil;
-                }
-                return context.runtime.newString(name);
+        return withConnection(context, connection -> {
+            String name = connection.getCatalog();
+            if ( name == null ) {
+                name = connection.getMetaData().getUserName();
+                if ( name == null ) return context.nil;
             }
+            return context.runtime.newString(name);
         });
     }
 
     @JRubyMethod(name = "execute", required = 1)
     public IRubyObject execute(final ThreadContext context, final IRubyObject sql) {
         final String query = sqlString(sql);
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                Statement statement = null;
-                try {
-                    statement = createStatement(context, connection);
-
-                    // For DBs that do support multiple statements, lets return the last result set
-                    // to be consistent with AR
-                    boolean hasResultSet = doExecute(statement, query);
-                    int updateCount = statement.getUpdateCount();
+        return withConnection(context, connection -> {
+            Statement statement = null;
+            try {
+                statement = createStatement(context, connection);
 
-                    IRubyObject result = context.nil; // If no results, return nil
-                    ResultSet resultSet;
+                // For DBs that do support multiple statements, lets return the last result set
+                // to be consistent with AR
+                boolean hasResultSet = doExecute(statement, query);
+                int updateCount = statement.getUpdateCount();
 
-                    while (hasResultSet || updateCount != -1) {
+                IRubyObject result = context.nil; // If no results, return nil
+                ResultSet resultSet;
 
-                        if (hasResultSet) {
-                            resultSet = statement.getResultSet();
+                while (hasResultSet || updateCount != -1) {
 
-                            // Unfortunately the result set gets closed when getMoreResults()
-                            // is called, so we have to process the result sets as we get them
-                            // this shouldn't be an issue in most cases since we're only getting 1 result set anyways
-                            result = mapExecuteResult(context, connection, resultSet);
-                            resultSet.close();
-                        } else {
-                            result = context.runtime.newFixnum(updateCount);
-                        }
+                    if (hasResultSet) {
+                        resultSet = statement.getResultSet();
 
-                        // Check to see if there is another result set
-                        hasResultSet = statement.getMoreResults();
-                        updateCount = statement.getUpdateCount();
+                        // Unfortunately the result set gets closed when getMoreResults()
+                        // is called, so we have to process the result sets as we get them
+                        // this shouldn't be an issue in most cases since we're only getting 1 result set anyways
+                        result = mapExecuteResult(context, connection, resultSet);
+                        resultSet.close();
+                    } else {
+                        result = context.runtime.newFixnum(updateCount);
                     }
 
-                    return result;
-
-                } catch (final SQLException e) {
-                    debugErrorSQL(context, query);
-                    throw e;
-                } finally {
-                    close(statement);
+                    // Check to see if there is another result set
+                    hasResultSet = statement.getMoreResults();
+                    updateCount = statement.getUpdateCount();
                 }
+
+                return result;
+
+            } catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                close(statement);
             }
         });
     }
@@ -885,66 +834,100 @@ public class RubyJdbcConnection extends RubyObject {
         return mapQueryResult(context, connection, resultSet);
     }
 
+    private static String[] createStatementPk(IRubyObject pk) {
+        String[] statementPk;
+        if (pk instanceof RubyArray) {
+            RubyArray ary = (RubyArray) pk;
+            int size = ary.size();
+            statementPk = new String[size];
+            for (int i = 0; i < size; i++) {
+                statementPk[i] = sqlString(ary.eltInternal(i));
+            }
+        } else {
+            statementPk = new String[] { sqlString(pk) };
+        }
+        return statementPk;
+    }
+
     /**
      * Executes an INSERT SQL statement
      * @param context
      * @param sql
+     * @param pk Rails PK
      * @return ActiveRecord::Result
      * @throws SQLException
      */
-    @JRubyMethod(name = "execute_insert", required = 1)
-    public IRubyObject execute_insert(final ThreadContext context, final IRubyObject sql) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                Statement statement = null;
-                final String query = sqlString(sql);
-                try {
+    @JRubyMethod(name = "execute_insert_pk", required = 2)
+    public IRubyObject execute_insert_pk(final ThreadContext context, final IRubyObject sql, final IRubyObject pk) {
+        return withConnection(context, connection -> {
+            Statement statement = null;
+            final String query = sqlString(sql);
+            try {
 
-                    statement = createStatement(context, connection);
-                    statement.executeUpdate(query, Statement.RETURN_GENERATED_KEYS);
-                    return mapGeneratedKeys(context, connection, statement);
+                statement = createStatement(context, connection);
 
-                } catch (final SQLException e) {
-                    debugErrorSQL(context, query);
-                    throw e;
-                } finally {
-                    close(statement);
+                if (pk == context.nil || pk == context.fals || !supportsGeneratedKeys(connection)) {
+                    statement.executeUpdate(query, Statement.RETURN_GENERATED_KEYS);
+                } else {
+                    statement.executeUpdate(query, createStatementPk(pk));
                 }
+
+                return mapGeneratedKeys(context, connection, statement);
+            } catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                close(statement);
             }
         });
     }
 
+    @Deprecated
+    @JRubyMethod(name = "execute_insert", required = 1)
+    public IRubyObject execute_insert(final ThreadContext context, final IRubyObject sql) {
+        return execute_insert_pk(context, sql, context.nil);
+    }
+
     /**
      * Executes an INSERT SQL statement using a prepared statement
      * @param context
      * @param sql
      * @param binds RubyArray of values to be bound to the query
+     * @param pk Rails PK
      * @return ActiveRecord::Result
      * @throws SQLException
      */
-    @JRubyMethod(name = "execute_insert", required = 2)
-    public IRubyObject execute_insert(final ThreadContext context, final IRubyObject sql, final IRubyObject binds) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                PreparedStatement statement = null;
-                final String query = sqlString(sql);
-                try {
-
+    @JRubyMethod(name = "execute_insert_pk", required = 3)
+    public IRubyObject execute_insert_pk(final ThreadContext context, final IRubyObject sql, final IRubyObject binds,
+                                         final IRubyObject pk) {
+        return withConnection(context, connection -> {
+            PreparedStatement statement = null;
+            final String query = sqlString(sql);
+            try {
+                if (pk == context.nil || pk == context.fals || !supportsGeneratedKeys(connection)) {
                     statement = connection.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);
-                    setStatementParameters(context, connection, statement, (RubyArray) binds);
-                    statement.executeUpdate();
-                    return mapGeneratedKeys(context, connection, statement);
-
-                } catch (final SQLException e) {
-                    debugErrorSQL(context, query);
-                    throw e;
-                } finally {
-                    close(statement);
+                } else {
+                    statement = connection.prepareStatement(query, createStatementPk(pk));
                 }
+
+                setStatementParameters(context, connection, statement, (RubyArray) binds);
+                statement.executeUpdate();
+                return mapGeneratedKeys(context, connection, statement);
+            } catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                close(statement);
             }
         });
     }
 
+    @Deprecated
+    @JRubyMethod(name = "execute_insert", required = 2)
+    public IRubyObject execute_insert(final ThreadContext context, final IRubyObject binds, final IRubyObject sql) {
+        return execute_insert_pk(context, sql, binds, context.nil);
+    }
+
     /**
      * Executes an UPDATE (DELETE) SQL statement
      * @param context
@@ -954,22 +937,20 @@ public class RubyJdbcConnection extends RubyObject {
      */
     @JRubyMethod(name = {"execute_update", "execute_delete"}, required = 1)
     public IRubyObject execute_update(final ThreadContext context, final IRubyObject sql) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                Statement statement = null;
-                final String query = sqlString(sql);
+        return withConnection(context, (Callable<IRubyObject>) connection -> {
+            Statement statement = null;
+            final String query = sqlString(sql);
 
-                try {
-                    statement = createStatement(context, connection);
+            try {
+                statement = createStatement(context, connection);
 
-                    final int rowCount = statement.executeUpdate(query);
-                    return context.runtime.newFixnum(rowCount);
-                } catch (final SQLException e) {
-                    debugErrorSQL(context, query);
-                    throw e;
-                } finally {
-                    close(statement);
-                }
+                final int rowCount = statement.executeUpdate(query);
+                return context.runtime.newFixnum(rowCount);
+            } catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                close(statement);
             }
         });
     }
@@ -985,21 +966,19 @@ public class RubyJdbcConnection extends RubyObject {
      */
     @JRubyMethod(name = {"execute_prepared_update", "execute_prepared_delete"}, required = 2)
     public IRubyObject execute_prepared_update(final ThreadContext context, final IRubyObject sql, final IRubyObject binds) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                PreparedStatement statement = null;
-                final String query = sqlString(sql);
-                try {
-                    statement = connection.prepareStatement(query);
-                    setStatementParameters(context, connection, statement, (RubyArray) binds);
-                    final int rowCount = statement.executeUpdate();
-                    return context.runtime.newFixnum(rowCount);
-                } catch (final SQLException e) {
-                    debugErrorSQL(context, query);
-                    throw e;
-                } finally {
-                    close(statement);
-                }
+        return withConnection(context, (Callable<IRubyObject>) connection -> {
+            PreparedStatement statement = null;
+            final String query = sqlString(sql);
+            try {
+                statement = connection.prepareStatement(query);
+                setStatementParameters(context, connection, statement, (RubyArray) binds);
+                final int rowCount = statement.executeUpdate();
+                return context.runtime.newFixnum(rowCount);
+            } catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                close(statement);
             }
         });
     }
@@ -1028,12 +1007,12 @@ public class RubyJdbcConnection extends RubyObject {
                     binds = null;
                 } else {                              // (sql, binds)
                     maxRows = 0;
-                    binds = (RubyArray) TypeConverter.checkArrayType(args[1]);
+                    binds = (RubyArray) TypeConverter.checkArrayType(context, args[1]);
                 }
                 break;
             case 3:                                   // (sql, max_rows, binds)
                 maxRows = RubyNumeric.fix2int(args[1]);
-                binds = (RubyArray) TypeConverter.checkArrayType(args[2]);
+                binds = (RubyArray) TypeConverter.checkArrayType(context, args[2]);
                 break;
             default:                                  // (sql) 1-arg
                 maxRows = 0;
@@ -1046,50 +1025,48 @@ public class RubyJdbcConnection extends RubyObject {
 
     private IRubyObject doExecuteQueryRaw(final ThreadContext context,
         final String query, final int maxRows, final Block block, final RubyArray binds) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                Statement statement = null; boolean hasResult;
-                try {
-                    if ( binds == null || binds.isEmpty()) { // plain statement
-                        statement = createStatement(context, connection);
-                        statement.setMaxRows(maxRows); // zero means there is no limit
-                        hasResult = statement.execute(query);
-                    }
-                    else {
-                        final PreparedStatement prepStatement;
-                        statement = prepStatement = connection.prepareStatement(query);
-                        if (fetchSize != 0) statement.setFetchSize(fetchSize);
-                        statement.setMaxRows(maxRows); // zero means there is no limit
-                        setStatementParameters(context, connection, prepStatement, binds);
-                        hasResult = prepStatement.execute();
-                    }
+        return withConnection(context, connection -> {
+            Statement statement = null; boolean hasResult;
+            try {
+                if ( binds == null || binds.isEmpty()) { // plain statement
+                    statement = createStatement(context, connection);
+                    statement.setMaxRows(maxRows); // zero means there is no limit
+                    hasResult = statement.execute(query);
+                }
+                else {
+                    final PreparedStatement prepStatement;
+                    statement = prepStatement = connection.prepareStatement(query);
+                    if (fetchSize != 0) statement.setFetchSize(fetchSize);
+                    statement.setMaxRows(maxRows); // zero means there is no limit
+                    setStatementParameters(context, connection, prepStatement, binds);
+                    hasResult = prepStatement.execute();
+                }
 
-                    if (block.isGiven()) {
-                        if (hasResult) {
-                            // yield(id1, name1) ... row 1 result data
-                            // yield(id2, name2) ... row 2 result data
-                            return yieldResultRows(context, connection, statement.getResultSet(), block);
-                        }
-                        return context.nil;
-                    }
+                if (block.isGiven()) {
                     if (hasResult) {
-                        return mapToRawResult(context, connection, statement.getResultSet(), false);
+                        // yield(id1, name1) ... row 1 result data
+                        // yield(id2, name2) ... row 2 result data
+                        return yieldResultRows(context, connection, statement.getResultSet(), block);
                     }
-                    return context.runtime.newEmptyArray();
-                }
-                catch (final SQLException e) {
-                    debugErrorSQL(context, query);
-                    throw e;
+                    return context.nil;
                 }
-                finally {
-                    close(statement);
+                if (hasResult) {
+                    return mapToRawResult(context, connection, statement.getResultSet(), false);
                 }
+                return context.runtime.newEmptyArray();
+            }
+            catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            }
+            finally {
+                close(statement);
             }
         });
     }
 
     protected static String sqlString(final IRubyObject sql) {
-        return sql instanceof RubyString ? ((RubyString) sql).decodeString() : sql.convertToString().decodeString();
+        return sql.convertToString().decodeString();
     }
 
     /**
@@ -1102,26 +1079,46 @@ public class RubyJdbcConnection extends RubyObject {
      */
     @JRubyMethod(required = 1)
     public IRubyObject execute_query(final ThreadContext context, final IRubyObject sql) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                Statement statement = null;
-                final String query = sqlString(sql);
-                try {
-                    statement = createStatement(context, connection);
+        return withConnection(context, connection -> {
+            Statement statement = null;
+            final String query = sqlString(sql);
+            try {
+                statement = createStatement(context, connection);
 
-                    // At least until AR 5.1 #exec_query still gets called for things that don't return results in some cases :(
-                    if (statement.execute(query)) {
-                        return mapQueryResult(context, connection, statement.getResultSet());
-                    }
+                // At least until AR 5.1 #exec_query still gets called for things that don't return results in some cases :(
+                if (statement.execute(query)) {
+                    return mapQueryResult(context, connection, statement.getResultSet());
+                }
 
-                    return context.nil;
+                return newEmptyResult(context);
 
-                } catch (final SQLException e) {
-                    debugErrorSQL(context, query);
-                    throw e;
-                } finally {
-                    close(statement);
-                }
+            } catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                close(statement);
+            }
+        });
+    }
+
+    @JRubyMethod(required = 1)
+    public IRubyObject get_first_value(final ThreadContext context, final IRubyObject sql) {
+        return withConnection(context, connection -> {
+            Statement statement = null;
+            final String query = sqlString(sql);
+            try {
+                statement = createStatement(context, connection);
+                statement.execute(query);
+                ResultSet rs = statement.getResultSet();
+                if (rs == null || !rs.next()) return context.nil;
+
+                return jdbcToRuby(context, context.getRuntime(), 1, rs.getMetaData().getColumnType(1), rs);
+
+            } catch (final SQLException e) {
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                close(statement);
             }
         });
     }
@@ -1134,13 +1131,11 @@ public class RubyJdbcConnection extends RubyObject {
      */
     @JRubyMethod(required = 1)
     public IRubyObject prepare_statement(final ThreadContext context, final IRubyObject sql) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(Connection connection) throws SQLException {
-                final String query = sql.convertToString().getUnicodeValue();
-                PreparedStatement statement = connection.prepareStatement(query);
-                if (fetchSize != 0) statement.setFetchSize(fetchSize);
-                return JavaUtil.convertJavaToRuby(context.runtime, statement);
-            }
+        return withConnection(context, connection -> {
+            final String query = sql.convertToString().getUnicodeValue();
+            PreparedStatement statement = connection.prepareStatement(query);
+            if (fetchSize != 0) statement.setFetchSize(fetchSize);
+            return JavaUtil.convertJavaToRuby(context.runtime, statement);
         });
     }
 
@@ -1163,40 +1158,40 @@ public class RubyJdbcConnection extends RubyObject {
     @JRubyMethod(required = 3)
     public IRubyObject execute_prepared_query(final ThreadContext context, final IRubyObject sql,
         final IRubyObject binds, final IRubyObject cachedStatement) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                final boolean cached = !(cachedStatement == null || cachedStatement.isNil());
-                final String query = sql.convertToString().getUnicodeValue();
-                PreparedStatement statement = null;
+        return withConnection(context, connection -> {
+            final boolean cached = !(cachedStatement == null || cachedStatement.isNil());
+            String query = null;
+            PreparedStatement statement = null;
 
-                try {
-                    if (cached) {
-                        statement = (PreparedStatement) JavaEmbedUtils.rubyToJava(cachedStatement);
-                    } else {
-                        statement = connection.prepareStatement(query);
-                        if (fetchSize != 0) statement.setFetchSize(fetchSize);
-                    }
+            try {
+                if (cached) {
+                    statement = (PreparedStatement) JavaEmbedUtils.rubyToJava(cachedStatement);
+                } else {
+                    query = sql.convertToString().getUnicodeValue();
+                    statement = connection.prepareStatement(query);
+                    if (fetchSize != 0) statement.setFetchSize(fetchSize);
+                }
 
-                    setStatementParameters(context, connection, statement, (RubyArray) binds);
+                setStatementParameters(context, connection, statement, (RubyArray) binds);
 
-                    if (statement.execute()) {
-                        ResultSet resultSet = statement.getResultSet();
-                        IRubyObject results = mapQueryResult(context, connection, resultSet);
-                        resultSet.close();
+                if (statement.execute()) {
+                    ResultSet resultSet = statement.getResultSet();
+                    IRubyObject results = mapQueryResult(context, connection, resultSet);
+                    resultSet.close();
 
-                        return results;
-                    } else {
-                        return context.nil;
-                    }
-                } catch (final SQLException e) {
-                    debugErrorSQL(context, query);
-                    throw e;
-                } finally {
-                    if ( cached ) {
-                        statement.clearParameters();
-                    } else {
-                        close(statement);
-                    }
+                    return results;
+                } else {
+                    return newEmptyResult(context);
+                }
+            } catch (final SQLException e) {
+                if (query == null) query = sql.convertToString().getUnicodeValue();
+                debugErrorSQL(context, query);
+                throw e;
+            } finally {
+                if ( cached ) {
+                    statement.clearParameters();
+                } else {
+                    close(statement);
                 }
             }
         });
@@ -1208,35 +1203,6 @@ public class RubyJdbcConnection extends RubyObject {
         return mapToResult(context, connection, resultSet, columns);
     }
 
-    /**
-     * @deprecated please do not use this method
-     */
-    @Deprecated // only used by Oracle adapter - also it's really a bad idea
-    @JRubyMethod(name = "execute_id_insert", required = 2)
-    public IRubyObject execute_id_insert(final ThreadContext context, final IRubyObject sql, final IRubyObject id) {
-        final Ruby runtime = context.runtime;
-
-        callMethod("warn", RubyString.newUnicodeString(runtime, "DEPRECATED: execute_id_insert(sql, id) will be removed"));
-
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                PreparedStatement statement = null;
-                final String insertSQL = sql.convertToString().getUnicodeValue();
-                try {
-                    statement = connection.prepareStatement(insertSQL);
-                    statement.setLong(1, RubyNumeric.fix2long(id));
-                    statement.executeUpdate();
-                }
-                catch (final SQLException e) {
-                    debugErrorSQL(context, insertSQL);
-                    throw e;
-                }
-                finally { close(statement); }
-                return id;
-            }
-        });
-    }
-
     @JRubyMethod(name = "supported_data_types")
     public IRubyObject supported_data_types(final ThreadContext context) throws SQLException {
         final Connection connection = getConnection(true);
@@ -1260,12 +1226,10 @@ public class RubyJdbcConnection extends RubyObject {
     protected static final int PRIMARY_KEYS_COLUMN_NAME = 4;
 
     private List<RubyString> primaryKeys(final ThreadContext context, final String tableName) {
-        return withConnection(context, new Callable<List<RubyString>>() {
-            public List<RubyString> call(final Connection connection) throws SQLException {
-                final String _tableName = caseConvertIdentifierForJdbc(connection, tableName);
-                final TableName table = extractTableName(connection, null, null, _tableName);
-                return primaryKeys(context, connection, table);
-            }
+        return withConnection(context, connection -> {
+            final String _tableName = caseConvertIdentifierForJdbc(connection, tableName);
+            final TableName table = extractTableName(connection, null, null, _tableName);
+            return primaryKeys(context, connection, table);
         });
     }
 
@@ -1273,7 +1237,7 @@ public class RubyJdbcConnection extends RubyObject {
         final Connection connection, final TableName table) throws SQLException {
         final DatabaseMetaData metaData = connection.getMetaData();
         ResultSet resultSet = null;
-        final List<RubyString> keyNames = new ArrayList<RubyString>();
+        final List<RubyString> keyNames = new ArrayList<>();
         try {
             resultSet = metaData.getPrimaryKeys(table.catalog, table.schema, table.name);
             final Ruby runtime = context.runtime;
@@ -1287,26 +1251,6 @@ public class RubyJdbcConnection extends RubyObject {
         return keyNames;
     }
 
-    @Deprecated //@JRubyMethod(name = "tables")
-    public IRubyObject tables(ThreadContext context) {
-        return tables(context, null, null, null, TABLE_TYPE);
-    }
-
-    @Deprecated //@JRubyMethod(name = "tables")
-    public IRubyObject tables(ThreadContext context, IRubyObject catalog) {
-        return tables(context, toStringOrNull(catalog), null, null, TABLE_TYPE);
-    }
-
-    @Deprecated //@JRubyMethod(name = "tables")
-    public IRubyObject tables(ThreadContext context, IRubyObject catalog, IRubyObject schemaPattern) {
-        return tables(context, toStringOrNull(catalog), toStringOrNull(schemaPattern), null, TABLE_TYPE);
-    }
-
-    @Deprecated //@JRubyMethod(name = "tables")
-    public IRubyObject tables(ThreadContext context, IRubyObject catalog, IRubyObject schemaPattern, IRubyObject tablePattern) {
-        return tables(context, toStringOrNull(catalog), toStringOrNull(schemaPattern), toStringOrNull(tablePattern), TABLE_TYPE);
-    }
-
     @JRubyMethod(name = "tables", required = 0, optional = 4)
     public IRubyObject tables(final ThreadContext context, final IRubyObject[] args) {
         switch ( args.length ) {
@@ -1324,11 +1268,7 @@ public class RubyJdbcConnection extends RubyObject {
 
     protected IRubyObject tables(final ThreadContext context,
         final String catalog, final String schemaPattern, final String tablePattern, final String[] types) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                return matchTables(context, connection, catalog, schemaPattern, tablePattern, types, false);
-            }
-        });
+        return withConnection(context, connection -> matchTables(context, connection, catalog, schemaPattern, tablePattern, types, false));
     }
 
     protected String[] getTableTypes() {
@@ -1358,40 +1298,36 @@ public class RubyJdbcConnection extends RubyObject {
 
     protected IRubyObject tableExists(final ThreadContext context,
         final String defaultSchema, final String tableName) {
-        return withConnection(context, new Callable<RubyBoolean>() {
-            public RubyBoolean call(final Connection connection) throws SQLException {
-                final TableName components = extractTableName(connection, defaultSchema, tableName);
-                return context.runtime.newBoolean( tableExists(context, connection, components) );
-            }
+        return withConnection(context, connection -> {
+            final TableName components = extractTableName(connection, defaultSchema, tableName);
+            return context.runtime.newBoolean( tableExists(context, connection, components) );
         });
     }
 
     @JRubyMethod(name = {"columns", "columns_internal"}, required = 1, optional = 2)
     public RubyArray columns_internal(final ThreadContext context, final IRubyObject[] args)
         throws SQLException {
-        return withConnection(context, new Callable<RubyArray>() {
-            public RubyArray call(final Connection connection) throws SQLException {
-                ResultSet columns = null;
-                try {
-                    final String tableName = args[0].toString();
-                    // optionals (NOTE: catalog argumnet was never used before 1.3.0) :
-                    final String catalog = args.length > 1 ? toStringOrNull(args[1]) : null;
-                    final String defaultSchema = args.length > 2 ? toStringOrNull(args[2]) : null;
-
-                    final TableName components;
-                    components = extractTableName(connection, catalog, defaultSchema, tableName);
+        return withConnection(context, connection -> {
+            ResultSet columns = null;
+            try {
+                final String tableName = args[0].toString();
+                // optionals (NOTE: catalog argumnet was never used before 1.3.0) :
+                final String catalog = args.length > 1 ? toStringOrNull(args[1]) : null;
+                final String defaultSchema = args.length > 2 ? toStringOrNull(args[2]) : null;
 
-                    if ( ! tableExists(context, connection, components) ) {
-                        throw new SQLException("table: " + tableName + " does not exist");
-                    }
+                final TableName components;
+                components = extractTableName(connection, catalog, defaultSchema, tableName);
 
-                    final DatabaseMetaData metaData = connection.getMetaData();
-                    columns = metaData.getColumns(components.catalog, components.schema, components.name, null);
-                    return mapColumnsResult(context, metaData, components, columns);
-                }
-                finally {
-                    close(columns);
+                if ( ! tableExists(context, connection, components) ) {
+                    throw new SQLException("table: " + tableName + " does not exist");
                 }
+
+                final DatabaseMetaData metaData = connection.getMetaData();
+                columns = metaData.getColumns(components.catalog, components.schema, components.name, null);
+                return mapColumnsResult(context, metaData, components, columns);
+            }
+            finally {
+                close(columns);
             }
         });
     }
@@ -1421,70 +1357,68 @@ public class RubyJdbcConnection extends RubyObject {
      * should filter the return from this method instead.
      */
     protected IRubyObject indexes(final ThreadContext context, final String tableName, final String name, final String schemaName) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                final Ruby runtime = context.runtime;
-                final RubyClass IndexDefinition = getIndexDefinition(context);
-
-                String _tableName = caseConvertIdentifierForJdbc(connection, tableName);
-                String _schemaName = caseConvertIdentifierForJdbc(connection, schemaName);
-                final TableName table = extractTableName(connection, null, _schemaName, _tableName);
+        return withConnection(context, (Callable<IRubyObject>) connection -> {
+            final Ruby runtime = context.runtime;
+            final RubyClass IndexDefinition = getIndexDefinition(context);
 
-                final List<RubyString> primaryKeys = primaryKeys(context, connection, table);
+            String _tableName = caseConvertIdentifierForJdbc(connection, tableName);
+            String _schemaName = caseConvertIdentifierForJdbc(connection, schemaName);
+            final TableName table = extractTableName(connection, null, _schemaName, _tableName);
 
-                ResultSet indexInfoSet = null;
-                final RubyArray indexes = RubyArray.newArray(runtime, 8);
-                try {
-                    final DatabaseMetaData metaData = connection.getMetaData();
-                    indexInfoSet = metaData.getIndexInfo(table.catalog, table.schema, table.name, false, true);
-                    String currentIndex = null;
-                    RubyArray currentColumns = null;
+            final List<RubyString> primaryKeys = primaryKeys(context, connection, table);
 
-                    while ( indexInfoSet.next() ) {
-                        String indexName = indexInfoSet.getString(INDEX_INFO_NAME);
-                        if ( indexName == null ) continue;
+            ResultSet indexInfoSet = null;
+            final RubyArray indexes = RubyArray.newArray(runtime, 8);
+            try {
+                final DatabaseMetaData metaData = connection.getMetaData();
+                indexInfoSet = metaData.getIndexInfo(table.catalog, table.schema, table.name, false, true);
+                String currentIndex = null;
 
-                        indexName = caseConvertIdentifierForRails(metaData, indexName);
+                while ( indexInfoSet.next() ) {
+                    String indexName = indexInfoSet.getString(INDEX_INFO_NAME);
+                    if ( indexName == null ) continue;
+                    RubyArray currentColumns = null;
 
-                        final String columnName = indexInfoSet.getString(INDEX_INFO_COLUMN_NAME);
-                        final RubyString rubyColumnName = cachedString(
-                                context, caseConvertIdentifierForRails(metaData, columnName)
-                        );
-                        if ( primaryKeys.contains(rubyColumnName) ) continue;
+                    indexName = caseConvertIdentifierForRails(metaData, indexName);
 
-                        // We are working on a new index
-                        if ( ! indexName.equals(currentIndex) ) {
-                            currentIndex = indexName;
+                    final String columnName = indexInfoSet.getString(INDEX_INFO_COLUMN_NAME);
+                    final RubyString rubyColumnName = cachedString(
+                            context, caseConvertIdentifierForRails(metaData, columnName)
+                    );
+                    if ( primaryKeys.contains(rubyColumnName) ) continue;
 
-                            String indexTableName = indexInfoSet.getString(INDEX_INFO_TABLE_NAME);
-                            indexTableName = caseConvertIdentifierForRails(metaData, indexTableName);
+                    // We are working on a new index
+                    if ( ! indexName.equals(currentIndex) ) {
+                        currentIndex = indexName;
 
-                            final boolean nonUnique = indexInfoSet.getBoolean(INDEX_INFO_NON_UNIQUE);
+                        String indexTableName = indexInfoSet.getString(INDEX_INFO_TABLE_NAME);
+                        indexTableName = caseConvertIdentifierForRails(metaData, indexTableName);
 
-                            IRubyObject[] args = new IRubyObject[] {
-                                cachedString(context, indexTableName), // table_name
-                                cachedString(context, indexName), // index_name
-                                nonUnique ? runtime.getFalse() : runtime.getTrue(), // unique
-                                currentColumns = RubyArray.newArray(runtime, 4) // [] column names
-                                // orders, (since AR 3.2) where, type, using (AR 4.0)
-                            };
+                        final boolean nonUnique = indexInfoSet.getBoolean(INDEX_INFO_NON_UNIQUE);
 
-                            indexes.append( IndexDefinition.newInstance(context, args, Block.NULL_BLOCK) ); // IndexDefinition.new
-                        }
+                        IRubyObject[] args = new IRubyObject[] {
+                            cachedString(context, indexTableName), // table_name
+                            cachedString(context, indexName), // index_name
+                            nonUnique ? context.fals : context.tru, // unique
+                            currentColumns = RubyArray.newArray(runtime, 4) // [] column names
+                            // orders, (since AR 3.2) where, type, using (AR 4.0)
+                        };
 
-                        // one or more columns can be associated with an index
-                        if ( currentColumns != null ) currentColumns.append(rubyColumnName);
+                        indexes.append( IndexDefinition.newInstance(context, args, Block.NULL_BLOCK) ); // IndexDefinition.new
                     }
 
-                    return indexes;
+                    // one or more columns can be associated with an index
+                    if ( currentColumns != null ) currentColumns.append(rubyColumnName);
+                }
 
-                } finally { close(indexInfoSet); }
-            }
+                return indexes;
+
+            } finally { close(indexInfoSet); }
         });
     }
 
     protected RubyClass getIndexDefinition(final ThreadContext context) {
-        final RubyClass adapterClass = getAdapter().getMetaClass();
+        final RubyClass adapterClass = adapter.getMetaClass();
         IRubyObject IDef = adapterClass.getConstantAt("IndexDefinition");
         return IDef != null ? (RubyClass) IDef : getIndexDefinition(context.runtime);
     }
@@ -1495,57 +1429,55 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     protected IRubyObject foreignKeys(final ThreadContext context, final String tableName, final String schemaName, final String catalog) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                final Ruby runtime = context.runtime;
-                final RubyClass FKDefinition = getForeignKeyDefinition(context);
+        return withConnection(context, (Callable<IRubyObject>) connection -> {
+            final Ruby runtime = context.runtime;
+            final RubyClass FKDefinition = getForeignKeyDefinition(context);
 
-                String _tableName = caseConvertIdentifierForJdbc(connection, tableName);
-                String _schemaName = caseConvertIdentifierForJdbc(connection, schemaName);
-                final TableName table = extractTableName(connection, catalog, _schemaName, _tableName);
+            String _tableName = caseConvertIdentifierForJdbc(connection, tableName);
+            String _schemaName = caseConvertIdentifierForJdbc(connection, schemaName);
+            final TableName table = extractTableName(connection, catalog, _schemaName, _tableName);
 
-                ResultSet fkInfoSet = null;
-                final List<IRubyObject> fKeys = new ArrayList<IRubyObject>(8);
-                try {
-                    final DatabaseMetaData metaData = connection.getMetaData();
-                    fkInfoSet = metaData.getImportedKeys(table.catalog, table.schema, table.name);
+            ResultSet fkInfoSet = null;
+            final List<IRubyObject> fKeys = new ArrayList<>(8);
+            try {
+                final DatabaseMetaData metaData = connection.getMetaData();
+                fkInfoSet = metaData.getImportedKeys(table.catalog, table.schema, table.name);
 
-                    while ( fkInfoSet.next() ) {
-                        final RubyHash options = RubyHash.newHash(runtime);
+                while ( fkInfoSet.next() ) {
+                    final RubyHash options = RubyHash.newHash(runtime);
 
-                        String fkName = fkInfoSet.getString("FK_NAME");
-                        if (fkName != null) {
-                            fkName = caseConvertIdentifierForRails(metaData, fkName);
-                            options.put(runtime.newSymbol("name"), fkName);
-                        }
+                    String fkName = fkInfoSet.getString("FK_NAME");
+                    if (fkName != null) {
+                        fkName = caseConvertIdentifierForRails(metaData, fkName);
+                        options.put(runtime.newSymbol("name"), fkName);
+                    }
 
-                        String columnName = fkInfoSet.getString("FKCOLUMN_NAME");
-                        options.put(runtime.newSymbol("column"), caseConvertIdentifierForRails(metaData, columnName));
+                    String columnName = fkInfoSet.getString("FKCOLUMN_NAME");
+                    options.put(runtime.newSymbol("column"), caseConvertIdentifierForRails(metaData, columnName));
 
-                        columnName = fkInfoSet.getString("PKCOLUMN_NAME");
-                        options.put(runtime.newSymbol("primary_key"), caseConvertIdentifierForRails(metaData, columnName));
+                    columnName = fkInfoSet.getString("PKCOLUMN_NAME");
+                    options.put(runtime.newSymbol("primary_key"), caseConvertIdentifierForRails(metaData, columnName));
 
-                        String fkTableName = fkInfoSet.getString("FKTABLE_NAME");
-                        fkTableName = caseConvertIdentifierForRails(metaData, fkTableName);
+                    String fkTableName = fkInfoSet.getString("FKTABLE_NAME");
+                    fkTableName = caseConvertIdentifierForRails(metaData, fkTableName);
 
-                        String pkTableName = fkInfoSet.getString("PKTABLE_NAME");
-                        pkTableName = caseConvertIdentifierForRails(metaData, pkTableName);
+                    String pkTableName = fkInfoSet.getString("PKTABLE_NAME");
+                    pkTableName = caseConvertIdentifierForRails(metaData, pkTableName);
 
-                        final String onDelete = extractForeignKeyRule( fkInfoSet.getInt("DELETE_RULE") );
-                        if ( onDelete != null ) options.op_aset(context, runtime.newSymbol("on_delete"), runtime.newSymbol(onDelete));
+                    final String onDelete = extractForeignKeyRule( fkInfoSet.getInt("DELETE_RULE") );
+                    if ( onDelete != null ) options.op_aset(context, runtime.newSymbol("on_delete"), runtime.newSymbol(onDelete));
 
-                        final String onUpdate = extractForeignKeyRule( fkInfoSet.getInt("UPDATE_RULE") );
-                        if ( onUpdate != null ) options.op_aset(context, runtime.newSymbol("on_update"), runtime.newSymbol(onUpdate));
+                    final String onUpdate = extractForeignKeyRule( fkInfoSet.getInt("UPDATE_RULE") );
+                    if ( onUpdate != null ) options.op_aset(context, runtime.newSymbol("on_update"), runtime.newSymbol(onUpdate));
 
-                        IRubyObject from_table = cachedString(context, fkTableName);
-                        IRubyObject to_table = cachedString(context, pkTableName);
-                        fKeys.add( FKDefinition.newInstance(context, from_table, to_table, options, Block.NULL_BLOCK) ); // ForeignKeyDefinition.new
-                    }
+                    IRubyObject from_table = cachedString(context, fkTableName);
+                    IRubyObject to_table = cachedString(context, pkTableName);
+                    fKeys.add( FKDefinition.newInstance(context, from_table, to_table, options, Block.NULL_BLOCK) ); // ForeignKeyDefinition.new
+                }
 
-                    return runtime.newArray(fKeys);
+                return runtime.newArray(fKeys);
 
-                } finally { close(fkInfoSet); }
-            }
+            } finally { close(fkInfoSet); }
         });
     }
 
@@ -1560,7 +1492,7 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     protected RubyClass getForeignKeyDefinition(final ThreadContext context) {
-        final RubyClass adapterClass = getAdapter().getMetaClass();
+        final RubyClass adapterClass = adapter.getMetaClass();
         IRubyObject FKDef = adapterClass.getConstantAt("ForeignKeyDefinition");
         return FKDef != null ? (RubyClass) FKDef : getForeignKeyDefinition(context.runtime);
     }
@@ -1568,42 +1500,34 @@ public class RubyJdbcConnection extends RubyObject {
 
     @JRubyMethod(name = "supports_foreign_keys?")
     public IRubyObject supports_foreign_keys_p(final ThreadContext context) throws SQLException {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                final DatabaseMetaData metaData = connection.getMetaData();
-                return context.runtime.newBoolean( metaData.supportsIntegrityEnhancementFacility() );
-            }
+        return withConnection(context, (Callable<IRubyObject>) connection -> {
+            final DatabaseMetaData metaData = connection.getMetaData();
+            return context.runtime.newBoolean( metaData.supportsIntegrityEnhancementFacility() );
         });
     }
 
     @JRubyMethod(name = "supports_views?")
     public IRubyObject supports_views_p(final ThreadContext context) throws SQLException {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                final DatabaseMetaData metaData = connection.getMetaData();
-                final ResultSet tableTypes = metaData.getTableTypes();
-                try {
-                    while ( tableTypes.next() ) {
-                        if ( "VIEW".equalsIgnoreCase( tableTypes.getString(1) ) ) {
-                            return context.runtime.newBoolean( true );
-                        }
+        return withConnection(context, (Callable<IRubyObject>) connection -> {
+            final DatabaseMetaData metaData = connection.getMetaData();
+            final ResultSet tableTypes = metaData.getTableTypes();
+            try {
+                while ( tableTypes.next() ) {
+                    if ( "VIEW".equalsIgnoreCase( tableTypes.getString(1) ) ) {
+                        return context.runtime.newBoolean( true );
                     }
                 }
-                finally {
-                    close(tableTypes);
-                }
-                return context.runtime.newBoolean( false );
             }
+            finally {
+                close(tableTypes);
+            }
+            return context.runtime.newBoolean( false );
         });
     }
 
     @JRubyMethod(name = "with_jdbc_connection", alias = "with_connection_retry_guard", frame = true)
     public IRubyObject with_jdbc_connection(final ThreadContext context, final Block block) {
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                return block.call(context, convertJavaToRuby(connection));
-            }
-        });
+        return withConnection(context, connection -> block.call(context, convertJavaToRuby(connection)));
     }
 
     /*
@@ -1664,24 +1588,22 @@ public class RubyJdbcConnection extends RubyObject {
         // TODO: Fix this, the columns don't have the info needed to handle this anymore
         //       currently commented out so that it will compile
 
-        return withConnection(context, new Callable<Integer>() {
-            public Integer call(final Connection connection) throws SQLException {
-                PreparedStatement statement = null;
-                try {
-                    statement = connection.prepareStatement(sql);
-                    /*
-                    if ( binary ) { // blob
-                        setBlobParameter(context, connection, statement, 1, value, column, Types.BLOB);
-                    }
-                    else { // clob
-                        setClobParameter(context, connection, statement, 1, value, column, Types.CLOB);
-                    }
-                    setStatementParameter(context, context.runtime, connection, statement, 2, idValue, idColumn);
-                    */
-                    return statement.executeUpdate();
+        return withConnection(context, connection -> {
+            PreparedStatement statement = null;
+            try {
+                statement = connection.prepareStatement(sql);
+                /*
+                if ( binary ) { // blob
+                    setBlobParameter(context, connection, statement, 1, value, column, Types.BLOB);
+                }
+                else { // clob
+                    setClobParameter(context, connection, statement, 1, value, column, Types.CLOB);
                 }
-                finally { close(statement); }
+                setStatementParameter(context, context.runtime, connection, statement, 2, idValue, idColumn);
+                */
+                return statement.executeUpdate();
             }
+            finally { close(statement); }
         });
     }
 
@@ -1737,7 +1659,7 @@ public class RubyJdbcConnection extends RubyObject {
         final IRubyObject self, final IRubyObject config, final Block block) {
         final IRubyObject ds_or_name = rawDataSourceOrName(context, config);
 
-        if ( ds_or_name == null ) return context.runtime.getFalse();
+        if ( ds_or_name == null ) return context.fals;
 
         final javax.sql.DataSource dataSource;
         final Object dsOrName = ds_or_name.toJava(Object.class);
@@ -1793,7 +1715,7 @@ public class RubyJdbcConnection extends RubyObject {
             }
         }
 
-        if ( configValue == null || configValue == context.nil || configValue == runtime.getFalse() ) {
+        if ( configValue == null || configValue == context.nil || configValue == context.fals ) {
             return null;
         }
         return configValue;
@@ -1816,13 +1738,6 @@ public class RubyJdbcConnection extends RubyObject {
         }
     }
 
-    @Deprecated
-    @JRubyMethod(name = "setup_jdbc_factory", visibility = Visibility.PROTECTED)
-    public IRubyObject set_driver_factory(final ThreadContext context) {
-        setDriverFactory(context);
-        return get_connection_factory(context.runtime);
-    }
-
     private ConnectionFactory setDriverFactory(final ThreadContext context) {
 
         final IRubyObject url = getConfigValue(context, "url");
@@ -1922,12 +1837,6 @@ public class RubyJdbcConnection extends RubyObject {
         return props;
     }
 
-    @JRubyMethod(name = "setup_jndi_factory", visibility = Visibility.PROTECTED)
-    public IRubyObject set_data_source_factory(final ThreadContext context) {
-        setDataSourceFactory(context);
-        return get_connection_factory(context.runtime);
-    }
-
     private ConnectionFactory setDataSourceFactory(final ThreadContext context) {
         final javax.sql.DataSource dataSource; final String lookupName;
         IRubyObject value = getConfigValue(context, "data_source");
@@ -1949,28 +1858,10 @@ public class RubyJdbcConnection extends RubyObject {
     private static volatile boolean defaultConfigJndi;
     private static transient ConnectionFactory defaultConnectionFactory;
 
-    /**
-     * Sets the connection factory from the available configuration.
-     * @param context
-     * @see #initialize
-     */
-    @Deprecated
-    @JRubyMethod(name = "setup_connection_factory", visibility = Visibility.PROTECTED)
-    public IRubyObject setup_connection_factory(final ThreadContext context) {
-        setupConnectionFactory(context);
-        return get_connection_factory(context.runtime);
-    }
-
-    private IRubyObject get_connection_factory(final Ruby runtime) {
-        return JavaUtil.convertJavaToRuby(runtime, connectionFactory);
-    }
-
     /**
      * @return whether the connection factory is JNDI based
      */
     private boolean setupConnectionFactory(final ThreadContext context) {
-        final IRubyObject config = getConfig();
-
         if ( defaultConfig == null ) {
             synchronized(RubyJdbcConnection.class) {
                 if ( defaultConfig == null ) {
@@ -2002,18 +1893,17 @@ public class RubyJdbcConnection extends RubyObject {
 
     @JRubyMethod(name = "jndi?", alias = "jndi_connection?")
     public RubyBoolean jndi_p(final ThreadContext context) {
-        return context.runtime.newBoolean( isJndi() );
+        return context.runtime.newBoolean(jndi);
     }
 
     protected boolean isJndi() { return this.jndi; }
 
     @JRubyMethod(name = "config")
-    public IRubyObject config() { return getConfig(); }
+    public IRubyObject config() { return config; }
 
     public IRubyObject getConfig() { return this.config; }
 
     protected final IRubyObject getConfigValue(final ThreadContext context, final String key) {
-        final IRubyObject config = getConfig();
         final RubySymbol keySym = context.runtime.newSymbol(key);
         if ( config instanceof RubyHash ) {
             final IRubyObject value = ((RubyHash) config).fastARef(keySym);
@@ -2024,7 +1914,6 @@ public class RubyJdbcConnection extends RubyObject {
 
     protected final IRubyObject setConfigValue(final ThreadContext context,
                                                final String key, final IRubyObject value) {
-        final IRubyObject config = getConfig();
         final RubySymbol keySym = context.runtime.newSymbol(key);
         if ( config instanceof RubyHash ) {
             return ((RubyHash) config).op_aset(context, keySym, value);
@@ -2034,7 +1923,6 @@ public class RubyJdbcConnection extends RubyObject {
 
     protected final IRubyObject setConfigValueIfNotSet(final ThreadContext context,
                                                        final String key, final IRubyObject value) {
-        final IRubyObject config = getConfig();
         final RubySymbol keySym = context.runtime.newSymbol(key);
         if ( config instanceof RubyHash ) {
             final IRubyObject setValue = ((RubyHash) config).fastARef(keySym);
@@ -2054,7 +1942,7 @@ public class RubyJdbcConnection extends RubyObject {
     protected final IRubyObject getAdapter() { return this.adapter; }
 
     protected RubyClass getJdbcColumnClass(final ThreadContext context) {
-        return (RubyClass) getAdapter().callMethod(context, "jdbc_column_class");
+        return (RubyClass) adapter.callMethod(context, "jdbc_column_class");
     }
 
     protected ConnectionFactory getConnectionFactory() throws RaiseException {
@@ -2266,7 +2154,7 @@ public class RubyJdbcConnection extends RubyObject {
     @JRubyMethod(name = "raw_date_time?", meta = true)
     public static IRubyObject useRawDateTime(final ThreadContext context, final IRubyObject self) {
         if ( rawDateTime == null ) return context.nil;
-        return context.runtime.newBoolean( rawDateTime.booleanValue() );
+        return context.runtime.newBoolean(rawDateTime);
     }
 
     @JRubyMethod(name = "raw_date_time=", meta = true)
@@ -2280,17 +2168,6 @@ public class RubyJdbcConnection extends RubyObject {
         return value;
     }
 
-    /**
-     * @return AR::Type-casted value
-     * @since 1.3.18
-     */
-    @Deprecated
-    protected static IRubyObject typeCastFromDatabase(final ThreadContext context,
-        final IRubyObject adapter, final RubySymbol typeName, final RubyString value) {
-        final IRubyObject type = adapter.callMethod(context, "lookup_cast_type", typeName);
-        return type.callMethod(context, "deserialize", value);
-    }
-
     protected IRubyObject dateToRuby(final ThreadContext context,
         final Ruby runtime, final ResultSet resultSet, final int column)
         throws SQLException {
@@ -2301,11 +2178,11 @@ public class RubyJdbcConnection extends RubyObject {
             return resultSet.wasNull() ? context.nil : RubyString.newEmptyString(runtime);
         }
 
-        if ( rawDateTime != null && rawDateTime.booleanValue() ) {
+        if ( rawDateTime != null && rawDateTime) {
             return RubyString.newString(runtime, DateTimeUtils.dateToString(value));
         }
 
-        return DateTimeUtils.newDateAsTime(context, value, null).callMethod(context, "to_date");
+        return DateTimeUtils.newDateAsTime(context, value, DateTimeZone.UTC).callMethod(context, "to_date");
     }
 
     protected IRubyObject timeToRuby(final ThreadContext context,
@@ -2317,7 +2194,7 @@ public class RubyJdbcConnection extends RubyObject {
             return resultSet.wasNull() ? context.nil : RubyString.newEmptyString(runtime);
         }
 
-        if ( rawDateTime != null && rawDateTime.booleanValue() ) {
+        if ( rawDateTime != null && rawDateTime) {
             return RubyString.newString(runtime, DateTimeUtils.timeToString(value));
         }
 
@@ -2333,7 +2210,7 @@ public class RubyJdbcConnection extends RubyObject {
             return resultSet.wasNull() ? context.nil : RubyString.newEmptyString(runtime);
         }
 
-        if ( rawDateTime != null && rawDateTime.booleanValue() ) {
+        if ( rawDateTime != null && rawDateTime) {
             return RubyString.newString(runtime, DateTimeUtils.timestampToString(value));
         }
 
@@ -2345,19 +2222,6 @@ public class RubyJdbcConnection extends RubyObject {
         return DateTimeUtils.newTime(context, value, getDefaultTimeZone(context));
     }
 
-    @Deprecated
-    protected static RubyString timestampToRubyString(final Ruby runtime, String value) {
-        // Timestamp's format: yyyy-mm-dd hh:mm:ss.fffffffff
-        String suffix; // assumes java.sql.Timestamp internals :
-        if ( value.endsWith( suffix = " 00:00:00.0" ) ) {
-            value = value.substring( 0, value.length() - suffix.length() );
-        }
-        else if ( value.endsWith( suffix = ".0" ) ) {
-            value = value.substring( 0, value.length() - suffix.length() );
-        }
-        return RubyString.newUnicodeString(runtime, value);
-    }
-
     protected static Boolean rawBoolean;
     static {
         final String booleanRaw = SafePropertyAccessor.getProperty("arjdbc.boolean.raw");
@@ -2369,7 +2233,7 @@ public class RubyJdbcConnection extends RubyObject {
     @JRubyMethod(name = "raw_boolean?", meta = true)
     public static IRubyObject useRawBoolean(final ThreadContext context, final IRubyObject self) {
         if ( rawBoolean == null ) return context.nil;
-        return context.runtime.newBoolean( rawBoolean.booleanValue() );
+        return context.runtime.newBoolean(rawBoolean);
     }
 
     @JRubyMethod(name = "raw_boolean=", meta = true)
@@ -2401,13 +2265,13 @@ public class RubyJdbcConnection extends RubyObject {
     protected IRubyObject booleanToRuby(final ThreadContext context,
         final Ruby runtime, final ResultSet resultSet, final int column)
         throws SQLException {
-        if ( rawBoolean != null && rawBoolean.booleanValue() ) {
+        if ( rawBoolean != null && rawBoolean) {
             final String value = resultSet.getString(column);
             if ( value == null /* && resultSet.wasNull() */ ) return context.nil;
             return RubyString.newUnicodeString(runtime, value);
         }
         final boolean value = resultSet.getBoolean(column);
-        if ( value == false && resultSet.wasNull() ) return context.nil;
+        if (!value && resultSet.wasNull()) return context.nil;
         return runtime.newBoolean(value);
     }
 
@@ -2555,9 +2419,16 @@ public class RubyJdbcConnection extends RubyObject {
             final Connection connection, final PreparedStatement statement,
             final int index, IRubyObject attribute) throws SQLException {
 
-        //debugMessage(context, attribute);
-        final int type = jdbcTypeForAttribute(context, attribute);
-        IRubyObject value = valueForDatabase(context, attribute);
+        final IRubyObject value;
+        final int type;
+
+        if (attributeClass.isInstance(attribute)) {
+            type = jdbcTypeForAttribute(context, attribute);
+            value = valueForDatabase(context, attribute);
+        } else {
+            type = jdbcTypeForPrimitiveAttribute(context, attribute);
+            value = attribute;
+        }
 
         // All the set methods were calling this first so save a method call in the nil case
         if ( value == context.nil ) {
@@ -2625,7 +2496,7 @@ public class RubyJdbcConnection extends RubyObject {
         }
     }
 
-    protected static final Map<String, Integer> JDBC_TYPE_FOR = new HashMap<String, Integer>(32, 1);
+    protected static final Map<String, Integer> JDBC_TYPE_FOR = new HashMap<>(32, 1);
     static {
         JDBC_TYPE_FOR.put("string", Types.VARCHAR);
         JDBC_TYPE_FOR.put("text", Types.CLOB);
@@ -2667,12 +2538,40 @@ public class RubyJdbcConnection extends RubyObject {
         final String internedType = internedTypeFor(context, attribute);
         final Integer sqlType = jdbcTypeFor(internedType);
         if ( sqlType != null ) {
-            return sqlType.intValue();
+            return sqlType;
         }
 
         return Types.OTHER; // -1 as well as 0 are used in Types
     }
 
+    protected String internedTypeForPrimitive(final ThreadContext context, final IRubyObject value) throws SQLException {
+        if (value instanceof RubyString) {
+            return "string";
+        }
+        if (value instanceof RubyInteger) {
+            return "integer";
+        }
+        if (value instanceof RubyNumeric) {
+            return "float";
+        }
+        if (value instanceof RubyTime || value instanceof RubyDateTime) {
+            return "timestamp";
+        }
+        if (value instanceof RubyDate) {
+            return "date";
+        }
+        if (value instanceof RubyBoolean) {
+            return "boolean";
+        }
+        return "string";
+    }
+
+    protected Integer jdbcTypeForPrimitiveAttribute(final ThreadContext context,
+                                                    final IRubyObject attribute) throws SQLException {
+        final String internedType = internedTypeForPrimitive(context, attribute);
+        return jdbcTypeFor(internedType);
+    }
+
     protected Integer jdbcTypeFor(final String type) {
         return JDBC_TYPE_FOR.get(type);
     }
@@ -2684,7 +2583,9 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     protected static IRubyObject attributeSQLType(final ThreadContext context, final IRubyObject attribute) {
-        return attributeType(context, attribute).callMethod(context, "type");
+        final IRubyObject type = attributeType(context, attribute);
+        if (type != null) return type.callMethod(context, "type");
+        return context.nil;
     }
 
     private final CachingCallSite value_site = new FunctionalCachingCallSite("value"); // AR::Attribute#value
@@ -2699,23 +2600,7 @@ public class RubyJdbcConnection extends RubyObject {
 
         final IRubyObject value = value_site.call(context, attribute, attribute);
 
-        if (value instanceof RubyInteger) {
-            return "integer";
-        }
-
-        if (value instanceof RubyNumeric) {
-            return "float";
-        }
-
-        if (value instanceof RubyTime) {
-            return "timestamp";
-        }
-
-        if (value instanceof RubyBoolean) {
-            return "boolean";
-        }
-
-        return "string";
+        return internedTypeForPrimitive(context, value);
     }
 
     // to be overriden in child class for database specific types
@@ -2854,11 +2739,6 @@ public class RubyJdbcConnection extends RubyObject {
         statement.setTimestamp(index, timestamp, getCalendar(dateTime.getZone()));
     }
 
-    @Deprecated
-    protected static Timestamp convertToTimestamp(final RubyFloat value) {
-        return DateTimeUtils.convertToTimestamp(value);
-    }
-
     protected static Calendar getCalendar(final DateTimeZone zone) { // final java.util.Date hint
         if (DateTimeZone.UTC == zone) return getCalendarUTC();
         if (DateTimeZone.getDefault() == zone) return new GregorianCalendar();
@@ -2904,9 +2784,14 @@ public class RubyJdbcConnection extends RubyObject {
             value = value.callMethod(context, "to_date");
         }
 
-        // NOTE: Here we rely in ActiveRecord (ActiveSupport) to get
-        // the date as a string in the database format.
-        statement.setDate(index, Date.valueOf(value.callMethod(context, "to_s", context.runtime.newSymbol("db")).toString()));
+        if (value instanceof RubyDate) {
+            RubyDate rubyDate = (RubyDate) value;
+            statement.setDate(index, rubyDate.toJava(Date.class));
+            return;
+        }
+
+        // NOTE: assuming Date#to_s does right ...
+        statement.setDate(index, Date.valueOf(value.toString()));
     }
 
     protected void setBooleanParameter(final ThreadContext context,
@@ -2943,7 +2828,7 @@ public class RubyJdbcConnection extends RubyObject {
         // For some reason the driver doesn't like "character varying" as a type
         if ( type.eql(context.runtime.newSymbol("string")) ) return "varchar";
 
-        final RubyHash nativeTypes = (RubyHash) getAdapter().callMethod(context, "native_database_types");
+        final RubyHash nativeTypes = (RubyHash) adapter.callMethod(context, "native_database_types");
         // e.g. `integer: { name: 'integer' }`
         final RubyHash typeInfo = (RubyHash) nativeTypes.op_aref(context, type);
 
@@ -3004,16 +2889,7 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     /**
-     * Always returns a connection (might cause a reconnect if there's none).
-     * @return connection
-     * @throws <code>ActiveRecord::ConnectionNotEstablished</code>, <code>ActiveRecord::JDBCError</code>
-     */
-    protected Connection getConnection() throws RaiseException {
-        return getConnection(false);
-    }
-
-    /**
-     * @see #getConnection()
+     * Returns a connection (might cause a reconnect if there's none).
      * @param required set to true if a connection is required to exists (e.g. on commit)
      * @return connection
      * @throws <code>ActiveRecord::ConnectionNotEstablished</code> if disconnected
@@ -3028,17 +2904,15 @@ public class RubyJdbcConnection extends RubyObject {
         }
     }
 
-    private Connection getConnectionInternal(final boolean required) throws SQLException {
+    protected Connection getConnectionInternal(final boolean required) throws SQLException {
         Connection connection = getConnectionImpl();
-        if ( connection == null ) {
-            if ( required ) {
-                if ( ! connected ) handleNotConnected(); // raise ConnectionNotEstablished
-                synchronized (this) {
+        if (connection == null && required) {
+            if (!connected) handleNotConnected(); // raise ConnectionNotEstablished
+            synchronized (this) {
+                connection = getConnectionImpl();
+                if ( connection == null ) {
+                    connectImpl(true); // throws SQLException
                     connection = getConnectionImpl();
-                    if ( connection == null ) {
-                        connectImpl( true ); // throws SQLException
-                        connection = getConnectionImpl();
-                    }
                 }
             }
         }
@@ -3169,7 +3043,7 @@ public class RubyJdbcConnection extends RubyObject {
         try {
             tablesSet = metaData.getTables(catalog, _schemaPattern, _tablePattern, types);
             if ( checkExistsOnly ) { // only check if given table exists
-                return tablesSet.next() ? context.runtime.getTrue() : null;
+                return tablesSet.next() ? context.tru : null;
             }
             else {
                 return mapTables(context, connection, catalog, _schemaPattern, _tablePattern, tablesSet);
@@ -3178,15 +3052,6 @@ public class RubyJdbcConnection extends RubyObject {
         finally { close(tablesSet); }
     }
 
-    @Deprecated
-    protected IRubyObject matchTables(final Ruby runtime,
-          final Connection connection,
-          final String catalog, final String schemaPattern,
-          final String tablePattern, final String[] types,
-          final boolean checkExistsOnly) throws SQLException {
-        return matchTables(runtime.getCurrentContext(), connection, catalog, schemaPattern, tablePattern, types, checkExistsOnly);
-    }
-
     // NOTE java.sql.DatabaseMetaData.getTables :
     protected final static int TABLES_TABLE_CAT = 1;
     protected final static int TABLES_TABLE_SCHEM = 2;
@@ -3275,7 +3140,7 @@ public class RubyJdbcConnection extends RubyObject {
             final String tabName = results.getString(TABLE_NAME);
             final RubyString tableName = cachedString(context, caseConvertIdentifierForRails(metaData, tabName));
 
-            final IRubyObject type_metadata = getAdapter().callMethod(context, "fetch_type_metadata", sqlType);
+            final IRubyObject type_metadata = adapter.callMethod(context, "fetch_type_metadata", sqlType);
 
             // (name, default, sql_type_metadata = nil, null = true, table_name = nil, default_function = nil, collation = nil, comment: nil)
             final IRubyObject[] args = new IRubyObject[] {
@@ -3291,7 +3156,7 @@ public class RubyJdbcConnection extends RubyObject {
         ResultSet primaryKeys = null;
         try {
             primaryKeys = metaData.getPrimaryKeys(components.catalog, components.schema, components.name);
-            final List<String> primaryKeyNames = new ArrayList<String>(4);
+            final List<String> primaryKeyNames = new ArrayList<>(4);
             while ( primaryKeys.next() ) {
                 primaryKeyNames.add( primaryKeys.getString(COLUMN_NAME) );
             }
@@ -3340,7 +3205,7 @@ public class RubyJdbcConnection extends RubyObject {
         // not have and auto-generated ID column :
         boolean next = genKeys.next() && genKeys.getMetaData().getColumnCount() > 0;
         // singleResult == null - guess if only single key returned
-        if ( singleResult == null || singleResult.booleanValue() ) {
+        if ( singleResult == null || singleResult) {
             if ( next ) {
                 firstKey = mapGeneratedKey(runtime, genKeys);
                 if ( singleResult != null || ! genKeys.next() ) {
@@ -3373,7 +3238,7 @@ public class RubyJdbcConnection extends RubyObject {
         if (supportsGeneratedKeys == null) {
             supportsGeneratedKeys = this.supportsGeneratedKeys = connection.getMetaData().supportsGetGeneratedKeys();
         }
-        return supportsGeneratedKeys.booleanValue();
+        return supportsGeneratedKeys;
     }
 
     /**
@@ -3405,8 +3270,8 @@ public class RubyJdbcConnection extends RubyObject {
         final ColumnData[] columns = extractColumns(context, connection, resultSet, false);
 
         final Ruby runtime = context.runtime;
-        final IRubyObject[] blockArgs = new IRubyObject[columns.length];
         while ( resultSet.next() ) {
+            final IRubyObject[] blockArgs = new IRubyObject[columns.length];
             for ( int i = 0; i < columns.length; i++ ) {
                 final ColumnData column = columns[i];
                 blockArgs[i] = jdbcToRuby(context, runtime, column.index, column.type, resultSet);
@@ -3432,16 +3297,6 @@ public class RubyJdbcConnection extends RubyObject {
         return setupColumns(context, connection, resultSet.getMetaData(), downCase);
     }
 
-    /**
-     * @deprecated use {@link #extractColumns(ThreadContext, Connection, ResultSet, boolean)}
-     */
-    @Deprecated
-    protected ColumnData[] extractColumns(final Ruby runtime,
-        final Connection connection, final ResultSet resultSet,
-        final boolean downCase) throws SQLException {
-        return extractColumns(runtime.getCurrentContext(), connection, resultSet, downCase);
-    }
-
     protected <T> T withConnection(final ThreadContext context, final Callable<T> block)
             throws RaiseException {
         try {
@@ -3547,13 +3402,12 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     protected boolean isTransient(final Exception exception) {
-        if ( exception instanceof SQLTransientException ) return true;
-        return false;
+        return exception instanceof SQLTransientException;
     }
 
     protected boolean isRecoverable(final Exception exception) {
-        if ( exception instanceof SQLRecoverableException) return true;
-        return false; // exception instanceof SQLException; // pre JDBC 4.0 drivers?
+        return exception instanceof SQLRecoverableException;
+        // exception instanceof SQLException; // pre JDBC 4.0 drivers?
     }
 
     private static Throwable getCause(Throwable exception) {
@@ -3711,6 +3565,11 @@ public class RubyJdbcConnection extends RubyObject {
         return Result.newInstance(context, columnsToArray(context, columns), rows, Block.NULL_BLOCK); // Result.new
     }
 
+    protected static IRubyObject newEmptyResult(final ThreadContext context) {
+        final RubyClass Result = getResult(context.runtime);
+        return Result.newInstance(context, RubyArray.newEmptyArray(context.runtime), RubyArray.newEmptyArray(context.runtime), Block.NULL_BLOCK); // Result.new
+    }
+
     private static RubyArray columnsToArray(ThreadContext context, ColumnData[] columns) {
         final IRubyObject[] cols = new IRubyObject[columns.length];
 
@@ -3963,7 +3822,7 @@ public class RubyJdbcConnection extends RubyObject {
     public static void debugStackTrace(final ThreadContext context, final Throwable e) {
         if ( debug || ( context != null && context.runtime.isDebug() ) ) {
             final PrintStream out = context != null ? context.runtime.getOut() : System.out;
-            if ( debugStackTrace == null || debugStackTrace.booleanValue() ) {
+            if ( debugStackTrace == null || debugStackTrace) {
                 e.printStackTrace(out);
             }
             else {
@@ -3979,8 +3838,7 @@ public class RubyJdbcConnection extends RubyObject {
     private static boolean driverUsedLogged;
 
     private void logDriverUsed(final Connection connection) {
-        if ( isDebug() ) {
-            if ( driverUsedLogged ) return;
+        if (debug && !driverUsedLogged) {
             driverUsedLogged = true;
             try {
                 final DatabaseMetaData meta = connection.getMetaData();