activerecord-jdbc-adapter 5.0.pre1 → 50.0

data/rakelib/rails.rake

@@ -1,77 +1,80 @@
-namespace :rails do
-  
-  task :test do
-    raise "need a DRIVER e.g. DRIVER=mysql" unless driver = ENV['DRIVER'] || ENV['ADAPTER']
-    raise "need location of RAILS source code e.g. RAILS=../rails" unless rails_dir = ENV['RAILS']
-    rails_dir = File.join(rails_dir, '..') if rails_dir =~ /activerecord$/
-    activerecord_dir = File.join(rails_dir, 'activerecord') # rails/activerecord
+DEFAULT_RAILS_DIR = File.join('..', 'rails')
+DEFAULT_ADAPTERS = %w(MySQL SQLite3 Postgres)
 
-    ar_jdbc_dir = File.expand_path('..', File.dirname(__FILE__))
-    
-    ruby_lib = [ 
-      "#{ar_jdbc_dir}/lib",
-      "#{ar_jdbc_dir}/test/rails",
-      "#{ar_jdbc_dir}/jdbc-#{_driver(driver)}/lib",
-      "#{ar_jdbc_dir}/activerecord-jdbc#{_adapter(driver)}-adapter/lib"
-    ]
-    ruby_lib << File.expand_path('activesupport/lib', rails_dir)
-    ruby_lib << File.expand_path('activemodel/lib', rails_dir)
-    ruby_lib << File.expand_path(File.join(activerecord_dir, 'lib'))
-    requires = _requires(driver) || []
+namespace :rails do
+  namespace :test do
+    task :all do
+      driver = ENV['DRIVER'] || ENV['ADAPTER']
+      raise "need a DRIVER (DRIVER=mysql)" unless driver
+      rails_dir = _rails_dir
+      ENV['ARCONFIG'] = File.join(_ar_jdbc_dir, 'test', 'rails', 'config.yml')
 
-    Dir.chdir(activerecord_dir) do
-      ruby = FileUtils::RUBY
-      rubylib = ruby_lib.join(':') # i_lib = "-I#{rubylib}"
-      r_requires = requires.map { |feat| "-r#{feat}" }.join(' ')
-      sh "#{ruby} -S rake RUBYLIB=#{rubylib} RUBYOPT=\"#{r_requires}\" #{_target(driver)}"
+      Dir.chdir(File.join(rails_dir, 'activerecord')) do
+        sh FileUtils::RUBY, '-S', 'rake',
+           "RUBYLIB=#{_ruby_lib(rails_dir, driver)}",
+           _target(driver)
+      end
     end
-  end
-  
-  %w(MySQL SQLite3 Postgres).each do |adapter|
-    desc "Run Rails' ActiveRecord tests with #{adapter} (JDBC)"
-    task "test_#{adapter.downcase}" do
-      ENV['ADAPTER'] = adapter; Rake::Task['rails:test'].invoke
+
+    DEFAULT_ADAPTERS.each do |adapter|
+      desc "Run Rails ActiveRecord tests with #{adapter} (JDBC)"
+      task adapter.downcase do
+        ENV['ADAPTER'] = adapter
+        Rake::Task['rails:test:all'].invoke
+      end
+
+      namespace adapter.downcase do
+        desc "Runs Rails ActiveRecord base_test.rb with #{adapter}"
+        task "base_test" do
+          ENV['TEST'] ||= "test/cases/base_test.rb"
+          ENV['ADAPTER'] = adapter
+          Rake::Task['rails:test:all'].invoke
+        end
+      end
     end
-  end
-  
-  private
-  
-  def _adapter(name)
-    case name
-    when /postgres/i
-      'postgresql'
-    else
-      name.downcase
+
+    private
+
+    def _ar_jdbc_dir
+      @ar_jdbc_dir ||= File.expand_path('..', File.dirname(__FILE__))
     end
-  end
 
-  def _driver(name)
-    case name
-    when /postgres/i
-      'postgres'
-    else
-      name.downcase
+    def _rails_dir
+      rails_dir = ENV['RAILS'] || DEFAULT_RAILS_DIR
+      unless File.directory? rails_dir
+        raise "can't find RAILS source '#{rails_dir}' (maybe set ENV['RAILS'])"
+      end
+      rails_dir = File.join(rails_dir, '..') if rails_dir =~ /activerecord$/
+      rails_dir
     end
-  end
 
-  def _target(name)
-    case name
-    when /postgres/i
-      'test_jdbcpostgresql'
-    else
-      "test_jdbc#{name.downcase}"
+    def _ruby_lib(rails_dir, driver)
+      ar_jdbc_dir = _ar_jdbc_dir
+
+      if driver =~ /postgres/i
+        adapter, driver = 'postgresql', 'postgres'
+      else
+        adapter = driver.downcase
+        driver = adapter
+      end
+
+      [File.join(ar_jdbc_dir, 'lib'),
+       File.join(ar_jdbc_dir, 'test', 'rails'),
+       File.join(ar_jdbc_dir, "jdbc-#{driver}", 'lib'),
+       File.join(ar_jdbc_dir, "activerecord-jdbc#{adapter}-adapter", 'lib'),
+       File.expand_path('activesupport/lib', rails_dir),
+       File.expand_path('activemodel/lib', rails_dir),
+       File.expand_path('activerecord/lib', rails_dir)
+      ].join(':')
     end
-  end
 
-  def _requires(name)
-    requires = []
-    requires << 'ubygems'
-    requires << 'active_support/json' # avoid uninitialized constant BasicsTest::JSON
-    case name
-    when /mysql/i
-      requires << 'mysql' # -rmysql - so Rails tests do not complain about Mysql
+    def _target(name)
+      case name
+      when /postgres/i
+        'test_postgresql'
+      else
+        "test_jdbc#{name.downcase}"
+      end
     end
-    requires
   end
-  
 end

data/src/java/arjdbc/firebird/FirebirdRubyJdbcConnection.java

@@ -70,27 +70,11 @@ public class FirebirdRubyJdbcConnection extends RubyJdbcConnection {
         return RubyString.newUnicodeString(runtime, value);
     }
 
-    @Override // booleans are emulated can not setNull(index, Types.BOOLEAN)
-    protected void setBooleanParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, final Object value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value instanceof IRubyObject ) {
-            setBooleanParameter(context, connection, statement, index, (IRubyObject) value, column, type);
-        }
-        else {
-            if ( value == null ) statement.setNull(index, Types.CHAR);
-            else {
-                statement.setBoolean(index, ((Boolean) value).booleanValue());
-            }
-        }
-    }
-
     @Override // booleans are emulated can not setNull(index, Types.BOOLEAN)
     protected void setBooleanParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
         final int index, final IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
+        final IRubyObject attribute, final int type) throws SQLException {
         if ( value.isNil() ) statement.setNull(index, Types.CHAR);
         else {
             statement.setBoolean(index, value.isTrue());

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

@@ -25,7 +25,6 @@
  ***** END LICENSE BLOCK *****/
 package arjdbc.jdbc;
 
-import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
@@ -80,15 +79,17 @@ import org.jruby.RubySymbol;
 import org.jruby.RubyTime;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.exceptions.RaiseException;
+import org.jruby.ext.bigdecimal.RubyBigDecimal;
 import org.jruby.javasupport.JavaEmbedUtils;
 import org.jruby.javasupport.JavaUtil;
-import org.jruby.runtime.Arity;
 import org.jruby.runtime.Block;
+import org.jruby.runtime.Helpers;
 import org.jruby.runtime.ObjectAllocator;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.backtrace.RubyStackTraceElement;
 import org.jruby.runtime.builtin.IRubyObject;
 import org.jruby.util.ByteList;
+import org.jruby.util.TypeConverter;
 
 /**
  * Most of our ActiveRecord::ConnectionAdapters::JdbcConnection implementation.
@@ -121,6 +122,10 @@ public class RubyJdbcConnection extends RubyObject {
         return getConnectionAdapters(runtime).getClass("JdbcConnection");
     }
 
+    protected static RubyModule ActiveRecord(ThreadContext context) {
+        return context.runtime.getModule("ActiveRecord");
+    }
+
     /**
      * @param runtime
      * @return <code>ActiveRecord::ConnectionAdapters</code>
@@ -129,22 +134,6 @@ public class RubyJdbcConnection extends RubyObject {
         return (RubyModule) runtime.getModule("ActiveRecord").getConstant("ConnectionAdapters");
     }
 
-    /**
-     * @param runtime
-     * @return <code>ActiveRecord::Result</code>
-     */
-    static RubyClass getResult(final Ruby runtime) {
-        return runtime.getModule("ActiveRecord").getClass("Result");
-    }
-
-    /**
-     * @param runtime
-     * @return <code>ActiveRecord::Base</code>
-     */
-    protected static RubyClass getBase(final Ruby runtime) {
-        return runtime.getModule("ActiveRecord").getClass("Base");
-    }
-
     /**
      * @param runtime
      * @return <code>ActiveRecord::ConnectionAdapters::IndexDefinition</code>
@@ -170,42 +159,6 @@ public class RubyJdbcConnection extends RubyObject {
         return runtime.getModule("ActiveRecord").getClass("JDBCError");
     }
 
-    /**
-     * @param runtime
-     * @return <code>ActiveRecord::ConnectionNotEstablished</code>
-     */
-    protected static RubyClass getConnectionNotEstablished(final Ruby runtime) {
-        return runtime.getModule("ActiveRecord").getClass("ConnectionNotEstablished");
-    }
-
-    /**
-     * NOTE: Only available since AR-4.0
-     * @param runtime
-     * @return <code>ActiveRecord::TransactionIsolationError</code>
-     */
-    protected static RubyClass getTransactionIsolationError(final Ruby runtime) {
-        return (RubyClass) runtime.getModule("ActiveRecord").getConstant("TransactionIsolationError");
-    }
-
-    /**
-     * @param runtime
-     * @return <code>ActiveRecord::ConnectionAdapters::JdbcTypeConverter</code>
-     */
-    private static RubyClass getJdbcTypeConverter(final Ruby runtime) {
-        return getConnectionAdapters(runtime).getClass("JdbcTypeConverter");
-    }
-
-    /*
-      def transaction_isolation_levels
-        {
-          read_uncommitted: "READ UNCOMMITTED",
-          read_committed:   "READ COMMITTED",
-          repeatable_read:  "REPEATABLE READ",
-          serializable:     "SERIALIZABLE"
-        }
-      end
-    */
-
     public static int mapTransactionIsolationLevel(IRubyObject isolation) {
         if ( ! ( isolation instanceof RubySymbol ) ) {
             isolation = isolation.asString().callMethod("intern");
@@ -244,37 +197,57 @@ public class RubyJdbcConnection extends RubyObject {
         });
     }
 
-    @JRubyMethod(name = {"begin", "transaction"}, optional = 1) // optional isolation argument for AR-4.0
-    public IRubyObject begin(final ThreadContext context, final IRubyObject[] args) {
-        final IRubyObject isolation = args.length > 0 ? args[0] : null;
+    @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 {
-                    connection.setAutoCommit(false);
+                    return beginTransaction(context, connection, isolation.isNil() ? null : isolation);
+                }
+            });
+        } catch (SQLException e) {
+            return handleException(context, e);
+        }
+    }
 
-                    if ( isolation != null && ! isolation.isNil() ) {
-                        final int level = mapTransactionIsolationLevel(isolation);
-                        try {
-                            connection.setTransactionIsolation(level);
-                        }
-                        catch (SQLException e) {
-                            RubyClass txError = getTransactionIsolationError(context.getRuntime());
-                            if ( txError != null ) throw wrapException(context, txError, e);
-                            throw e; // let it roll - will be wrapped into a JDBCError (non 4.0)
-                        }
-                    }
-                    return context.getRuntime().getNil();
+    @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);
                 }
             });
+        } catch (SQLException e) {
+            return handleException(context, e);
+        }
+    }
+
+    protected IRubyObject beginTransaction(final ThreadContext context, final Connection connection,
+        final IRubyObject isolation) throws SQLException {
+        if ( isolation != null ) {
+            setTransactionIsolation(context, connection, isolation);
+        }
+        if ( connection.getAutoCommit() ) connection.setAutoCommit(false);
+        return context.nil;
+    }
+
+    protected final void setTransactionIsolation(final ThreadContext context, final Connection connection,
+        final IRubyObject isolation) throws SQLException {
+        final int level = mapTransactionIsolationLevel(isolation);
+        try {
+            connection.setTransactionIsolation(level);
         }
         catch (SQLException e) {
-            return handleException(context, e);
+            RubyClass txError = ActiveRecord(context).getClass("TransactionIsolationError");
+            if ( txError != null ) throw wrapException(context, txError, e);
+            throw e; // let it roll - will be wrapped into a JDBCError (non 4.0)
         }
     }
 
     @JRubyMethod(name = "commit")
     public IRubyObject commit(final ThreadContext context) {
-        final Connection connection = getConnection(true);
+        final Connection connection = getConnection(context, true);
         try {
             if ( ! connection.getAutoCommit() ) {
                 try {
@@ -295,13 +268,13 @@ public class RubyJdbcConnection extends RubyObject {
 
     @JRubyMethod(name = "rollback")
     public IRubyObject rollback(final ThreadContext context) {
-        final Connection connection = getConnection(true);
+        final Connection connection = getConnection(context, true);
         try {
             if ( ! connection.getAutoCommit() ) {
                 try {
                     connection.rollback();
                     resetSavepoints(context); // if any
-                    return context.getRuntime().newBoolean(true);
+                    return context.runtime.getTrue();
                 } finally {
                     connection.setAutoCommit(true);
                 }
@@ -326,7 +299,8 @@ public class RubyJdbcConnection extends RubyObject {
     @JRubyMethod(name = "create_savepoint", optional = 1)
     public IRubyObject create_savepoint(final ThreadContext context, final IRubyObject[] args) {
         IRubyObject name = args.length > 0 ? args[0] : null;
-        final Connection connection = getConnection(true);
+        final Connection connection = getConnection(context, true);
+
         try {
             connection.setAutoCommit(false);
 
@@ -358,7 +332,7 @@ public class RubyJdbcConnection extends RubyObject {
         if ( name == null || name.isNil() ) {
             throw context.getRuntime().newArgumentError("nil savepoint name given");
         }
-        final Connection connection = getConnection(true);
+        final Connection connection = getConnection(context, true);
         try {
             Savepoint savepoint = getSavepoints(context).get(name);
             if ( savepoint == null ) {
@@ -374,40 +348,27 @@ public class RubyJdbcConnection extends RubyObject {
 
     @JRubyMethod(name = "release_savepoint", required = 1)
     public IRubyObject release_savepoint(final ThreadContext context, final IRubyObject name) {
-        if ( name == null || name.isNil() ) {
-            throw context.getRuntime().newArgumentError("nil savepoint name given");
-        }
-        final Connection connection = getConnection(true);
+        Ruby runtime = context.runtime;
+
+        if ( name == null || name.isNil() ) throw runtime.newArgumentError("nil savepoint name given");
+
         try {
             Object savepoint = getSavepoints(context).remove(name);
-            if ( savepoint == null ) {
-                throw context.getRuntime().newRuntimeError("could not release savepoint: '" + name + "' (not set)");
+
+            if (savepoint == null) {
+                RubyClass invalidStatement = ActiveRecord(context).getClass("StatementInvalid");
+                throw runtime.newRaiseException(invalidStatement, "could not release savepoint: '" + name + "' (not set)");
             }
+
             // NOTE: RubyHash.remove does not convert to Java as get does :
-            if ( ! ( savepoint instanceof Savepoint ) ) {
+            if (!( savepoint instanceof Savepoint )) {
                 savepoint = ((IRubyObject) savepoint).toJava(Savepoint.class);
             }
-            connection.releaseSavepoint((Savepoint) savepoint);
-            return context.getRuntime().getNil();
-        }
-        catch (SQLException e) {
-            return handleException(context, e);
-        }
-    }
 
-    // NOTE: this is iternal API - not to be used by user-code !
-    @JRubyMethod(name = "marked_savepoint_names")
-    public IRubyObject marked_savepoint_names(final ThreadContext context) {
-        if ( hasInstanceVariable("@savepoints") ) {
-            Map<IRubyObject, Savepoint> savepoints = getSavepoints(context);
-            final RubyArray names = context.getRuntime().newArray();
-            for ( Map.Entry<IRubyObject, ?> entry : savepoints.entrySet() ) {
-                names.add( entry.getKey() ); // keys are RubyString instances
-            }
-            return names;
-        }
-        else {
-            return context.getRuntime().newEmptyArray();
+            getConnection(context, true).releaseSavepoint((Savepoint) savepoint);
+            return runtime.getNil();
+        } catch (SQLException e) {
+            return handleException(context, e);
         }
     }
 
@@ -465,7 +426,7 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     private IRubyObject initConnection(final ThreadContext context) throws SQLException {
-        final IRubyObject jdbcConnection = setConnection( newConnection() );
+        final IRubyObject jdbcConnection = setConnection(context, newConnection());
         final IRubyObject adapter = callMethod("adapter"); // self.adapter
         if ( ! adapter.isNil() ) {
             if ( adapter.respondsTo("init_connection") ) {
@@ -481,24 +442,24 @@ public class RubyJdbcConnection extends RubyObject {
 
     @JRubyMethod(name = "connection")
     public IRubyObject connection(final ThreadContext context) {
-        if ( getConnection(false) == null ) {
+        if (getConnection(context, false) == null) {
             synchronized (this) {
-                if ( getConnection(false) == null ) {
-                    reconnect(context);
-                }
+                if (getConnection(context, false) == null) reconnect(context);
             }
         }
+
         return getInstanceVariable("@connection");
     }
 
     @JRubyMethod(name = "active?", alias = "valid?")
     public IRubyObject active_p(final ThreadContext context) {
         IRubyObject connection = getInstanceVariable("@connection");
-        if ( connection != null && ! connection.isNil() ) {
-            return isConnectionValid(context, getConnection(false)) ?
-                context.getRuntime().getTrue() : context.getRuntime().getFalse();
+
+        if (connection != null && ! connection.isNil()) {
+            return context.runtime.newBoolean(isConnectionValid(context, getConnection(context, false)));
         }
-        return context.getRuntime().getFalse();
+
+        return context.runtime.getFalse();
     }
 
     @JRubyMethod(name = "disconnect!")
@@ -515,14 +476,14 @@ public class RubyJdbcConnection extends RubyObject {
             }
             runtime.getOut().flush();
         }
-        return setConnection(null);
+        return setConnection(context, null);
     }
 
     @JRubyMethod(name = "reconnect!")
     public synchronized IRubyObject reconnect(final ThreadContext context) {
         try {
             final Connection connection = newConnection();
-            final IRubyObject result = setConnection( connection );
+            final IRubyObject result = setConnection(context, connection);
             final IRubyObject adapter = callMethod("adapter");
             if ( ! adapter.isNil() ) {
                 if ( adapter.respondsTo("configure_connection") ) {
@@ -541,37 +502,40 @@ public class RubyJdbcConnection extends RubyObject {
 
     @JRubyMethod(name = { "open?" /* "conn?" */ })
     public IRubyObject open_p(final ThreadContext context) {
-        final Connection connection = getConnection(false);
-        if ( connection == null ) return context.getRuntime().getFalse();
+        final Connection connection = getConnection(context, false);
+
+        if (connection == null) return context.runtime.getFalse();
+
         try {
             // NOTE: isClosed method generally cannot be called to determine
             // whether a connection to a database is valid or invalid ...
-            return context.getRuntime().newBoolean( ! connection.isClosed() );
-        }
-        catch (SQLException e) {
+            return context.getRuntime().newBoolean(!connection.isClosed());
+        } catch (SQLException e) {
             return handleException(context, e);
         }
     }
 
     @JRubyMethod(name = "close")
     public IRubyObject close(final ThreadContext context) {
-        final Connection connection = getConnection(false);
-        if ( connection == null ) return context.getRuntime().getFalse();
+        final Connection connection = getConnection(context, false);
+
+        if (connection == null) return context.runtime.getFalse();
+
         try {
-            final boolean closed = connection.isClosed();
-            if ( closed ) return context.getRuntime().getFalse();
-            setConnection(null); // does connection.close();
-            return context.getRuntime().getTrue();
-        }
-        catch (Exception e) {
+            if (connection.isClosed()) return context.runtime.getFalse();
+
+            setConnection(context, null); // does connection.close();
+        } catch (Exception e) {
             debugStackTrace(context, e);
-            return context.getRuntime().getNil();
+            return context.runtime.getNil();
         }
+
+        return context.runtime.getTrue();
     }
 
     @JRubyMethod(name = "database_name")
     public IRubyObject database_name(final ThreadContext context) throws SQLException {
-        final Connection connection = getConnection(true);
+        final Connection connection = getConnection(context, true);
         String name = connection.getCatalog();
 
         if (name == null) {
@@ -591,15 +555,41 @@ public class RubyJdbcConnection extends RubyObject {
 
                 try {
                     statement = createStatement(context, connection);
-                    if ( doExecute(statement, query) ) {
-                        ResultSet resultSet = statement.getResultSet();
-                        ColumnData[] columns = extractColumns(context.runtime, connection, resultSet, false);
 
-                        return mapToResult(context, context.runtime, connection, resultSet, columns);
-                    } else {
-                        //return context.runtime.newFixnum( statement.getUpdateCount());
+                    // 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();
+
+                    ColumnData[] columns = null;
+                    IRubyObject result = null;
+                    ResultSet resultSet = null;
+
+                    while (hasResultSet || updateCount != -1) {
+
+                        if (hasResultSet) {
+                            resultSet = statement.getResultSet();
+
+                            // 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
+                            columns = extractColumns(context.runtime, connection, resultSet, false);
+                            result = mapToResult(context, context.runtime, connection, resultSet, columns);
+                        } else {
+                            resultSet = null;
+                        }
+
+                        // Check to see if there is another result set
+                        hasResultSet = statement.getMoreResults();
+                        updateCount = statement.getUpdateCount();
+                    }
+
+                    // Need to check resultSet instead of result because result
+                    // may have been populated in a previous iteration of the loop
+                    if (resultSet == null) {
                         return context.runtime.newEmptyArray();
-                        //return mapGeneratedKeysOrUpdateCount(context, connection, statement);
+                    } else {
+                        return result;
                     }
                 } catch (final SQLException e) {
                     debugErrorSQL(context, query);
@@ -635,15 +625,7 @@ public class RubyJdbcConnection extends RubyObject {
      * @throws SQLException
      */
     protected boolean doExecute(final Statement statement, final String query) throws SQLException {
-        return genericExecute(statement, query);
-    }
-
-    /**
-     * @deprecated renamed to {@link #doExecute(Statement, String)}
-     */
-    @Deprecated
-    protected boolean genericExecute(final Statement statement, final String query) throws SQLException {
-        return statement.execute(query); // Statement.RETURN_GENERATED_KEYS
+        return statement.execute(query);
     }
 
     @JRubyMethod(name = "execute_insert", required = 1)
@@ -661,7 +643,7 @@ public class RubyJdbcConnection extends RubyObject {
             return executeUpdate(context, query, true);
         }
         else { // we allow prepared statements with empty binds parameters
-            return executePreparedUpdate(context, query, (List) binds, true);
+            return executePreparedUpdate(context, query, (RubyArray) binds, true);
         }
     }
 
@@ -697,16 +679,16 @@ public class RubyJdbcConnection extends RubyObject {
             return executeUpdate(context, query, false);
         }
         else { // we allow prepared statements with empty binds parameters
-            return executePreparedUpdate(context, query, (List) binds, false);
+            return executePreparedUpdate(context, query, (RubyArray) binds, false);
         }
     }
 
     @JRubyMethod(name = {"execute_prepared_update"}, required = 2)
     public IRubyObject execute_prepared_update(final ThreadContext context,
-                                               final IRubyObject sql, final IRubyObject binds) throws SQLException {
+        final IRubyObject sql, final IRubyObject binds) throws SQLException {
 
         final String query = sql.convertToString().getUnicodeValue();
-        return executePreparedUpdate(context, query, (List) binds, false);
+        return executePreparedUpdate(context, query, (RubyArray) binds, false);
     }
 
     /**
@@ -745,7 +727,7 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     private IRubyObject executePreparedUpdate(final ThreadContext context, final String query,
-        final List<?> binds, final boolean returnGeneratedKeys) {
+        final RubyArray binds, final boolean returnGeneratedKeys) {
         return withConnection(context, new Callable<IRubyObject>() {
             public IRubyObject call(final Connection connection) throws SQLException {
                 PreparedStatement statement = null;
@@ -774,172 +756,143 @@ public class RubyJdbcConnection extends RubyObject {
     }
 
     /**
-     * NOTE: since 1.3 this behaves like <code>execute_query</code> in AR-JDBC 1.2
-     * @param context
-     * @param sql
-     * @param block (optional) block to yield row values
-     * @return raw query result as a name => value Hash (unless block given)
-     * @throws SQLException
-     * @see #execute_query_raw(ThreadContext, IRubyObject[], Block)
-     */
-    @JRubyMethod(name = "execute_query_raw", required = 1) // optional block
-    public IRubyObject execute_query_raw(final ThreadContext context,
-        final IRubyObject sql, final Block block) throws SQLException {
-        final String query = sql.convertToString().getUnicodeValue();
-        return executeQueryRaw(context, query, 0, block);
-    }
-
-    /**
-     * NOTE: since 1.3 this behaves like <code>execute_query</code> in AR-JDBC 1.2
-     * @param context
-     * @param args
-     * @param block (optional) block to yield row values
-     * @return raw query result as a name => value Hash (unless block given)
-     * @throws SQLException
+     * This is the same as execute_query but it will return a list of hashes.
+     *
+     * @see RubyJdbcConnection#execute_query(ThreadContext, IRubyObject[])
+     * @param context which context this method is executing on.
+     * @param args arguments being supplied to this method.
+     * @param block (optional) block to yield row values (Hash(name: value))
+     * @return List of Hash(name: value) unless block is given.
+     * @throws SQLException when a database error occurs<
      */
-    @JRubyMethod(name = "execute_query_raw", required = 2, optional = 1)
-    // @JRubyMethod(name = "execute_query_raw", required = 1, optional = 2)
+    @JRubyMethod(required = 1, optional = 2)
     public IRubyObject execute_query_raw(final ThreadContext context,
         final IRubyObject[] args, final Block block) throws SQLException {
-        // args: (sql), (sql, max_rows), (sql, binds), (sql, max_rows, binds)
         final String query = args[0].convertToString().getUnicodeValue(); // sql
-        IRubyObject max_rows = args.length > 1 ? args[1] : null;
-        IRubyObject binds = args.length > 2 ? args[2] : null;
+        final RubyArray binds;
         final int maxRows;
-        if ( max_rows == null || max_rows.isNil() ) maxRows = 0;
-        else {
-            if ( binds instanceof RubyNumeric ) { // (sql, max_rows)
-                maxRows = RubyNumeric.fix2int(binds); binds = null;
-            }
-            else {
-                if ( max_rows instanceof RubyNumeric ) {
-                    maxRows = RubyNumeric.fix2int(max_rows);
-                }
-                else {
-                    if ( binds == null ) binds = max_rows; // (sql, binds)
+
+        // args: (sql), (sql, max_rows), (sql, binds), (sql, max_rows, binds)
+        switch (args.length) {
+            case 2:
+                if (args[1] instanceof RubyNumeric) { // (sql, max_rows)
+                    maxRows = RubyNumeric.fix2int(args[1]);
+                    binds = null;
+                } else {                              // (sql, binds)
                     maxRows = 0;
+                    binds = (RubyArray) TypeConverter.checkArrayType(args[1]);
                 }
-            }
-        }
-
-        if ( binds == null || binds.isNil() ) { // no prepared statements
-            return executeQueryRaw(context, query, maxRows, block);
-        }
-        else { // we allow prepared statements with empty binds parameters
-            return executePreparedQueryRaw(context, query, (List) binds, maxRows, block);
+                break;
+            case 3:                                   // (sql, max_rows, binds)
+                maxRows = RubyNumeric.fix2int(args[1]);
+                binds = (RubyArray) TypeConverter.checkArrayType(args[2]);
+                break;
+            default:                                  // (sql) 1-arg
+                maxRows = 0;
+                binds = null;
+                break;
         }
-    }
-
-    /**
-     * @param context
-     * @param query
-     * @param maxRows
-     * @param block
-     * @return raw query result (in case no block was given)
-     *
-     * @see #execute_query_raw(ThreadContext, IRubyObject[], Block)
-     */
-    protected IRubyObject executeQueryRaw(final ThreadContext context,
-        final String query, final int maxRows, final Block block) {
-        return doExecuteQueryRaw(context, query, maxRows, block, null); // binds == null
-    }
 
-    protected IRubyObject executePreparedQueryRaw(final ThreadContext context,
-        final String query, final List<?> binds, final int maxRows, final Block block) {
         return doExecuteQueryRaw(context, query, maxRows, block, binds);
     }
 
     private IRubyObject doExecuteQueryRaw(final ThreadContext context,
-        final String query, final int maxRows, final Block block, final List<?> binds) {
+        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 {
                 final Ruby runtime = context.getRuntime();
 
-                Statement statement = null; ResultSet resultSet = null;
+                Statement statement = null;
+                boolean hasResult = false;
                 try {
-                    if ( binds == null ) { // plain statement
+                    if ( binds == null || binds.isEmpty()) { // plain statement
                         statement = createStatement(context, connection);
                         statement.setMaxRows(maxRows); // zero means there is no limit
-                        resultSet = statement.executeQuery(query);
+                        hasResult = statement.execute(query);
                     }
                     else {
                         final PreparedStatement prepStatement;
                         statement = prepStatement = connection.prepareStatement(query);
                         statement.setMaxRows(maxRows); // zero means there is no limit
                         setStatementParameters(context, connection, prepStatement, binds);
-                        resultSet = prepStatement.executeQuery();
+                        hasResult = prepStatement.execute();
                     }
 
-                    if ( block != null && block.isGiven() ) {
-                        // yield(id1, name1) ... row 1 result data
-                        // yield(id2, name2) ... row 2 result data
-                        return yieldResultRows(context, runtime, connection, resultSet, block);
+                    if (block.isGiven()) {
+                        if (hasResult) {
+                            // yield(id1, name1) ... row 1 result data
+                            // yield(id2, name2) ... row 2 result data
+                            return yieldResultRows(context, runtime, connection, statement.getResultSet(), block);
+                        } else {
+                            return runtime.getNil();
+                        }
+                    } else if (hasResult) {
+                        return mapToRawResult(context, runtime, connection, statement.getResultSet(), false);
+                    } else {
+                        return runtime.newEmptyArray();
                     }
-
-                    return mapToRawResult(context, runtime, connection, resultSet, false);
                 }
                 catch (final SQLException e) {
                     debugErrorSQL(context, query);
                     throw e;
                 }
-                finally { close(resultSet); close(statement); }
+                finally {
+                    close(statement);
+                }
             }
         });
     }
 
     /**
-     * Executes a query and returns the (AR) result.
-     * @param context
-     * @param sql
-     * @return raw query result as a name => value Hash (unless block given)
-     * @throws SQLException
-     */
-    @JRubyMethod(name = "execute_query", required = 1)
-    public IRubyObject execute_query(final ThreadContext context,
-        final IRubyObject sql) throws SQLException {
-        final String query = sql.convertToString().getUnicodeValue();
-        return executeQuery(context, query, 0);
-    }
-
-    /**
-     * Executes a query and returns the (AR) result.
-     * @param context
-     * @param args
-     * @return and <code>ActiveRecord::Result</code>
-     * @throws SQLException
+     * Executes a query and returns the (AR) result.  There are three parameters:
+     * <ul>
+     *     <li>sql - String of sql</li>
+     *     <li>max_rows - Integer of how many rows to return</li>
+     *     <li>binds - Array of bindings for a prepared statement</li>
+     * </ul>
+     *
+     * In true Ruby fashion if there are only two arguments then the last argument
+     * may be either max_rows or binds.  Note: If you want to force the query to be
+     * done using a prepared statement then you must provide an empty array to binds.
+     *
+     * @param context which context this method is executing on.
+     * @param args arguments being supplied to this method.
+     * @return a Ruby <code>ActiveRecord::Result</code> instance
+     * @throws SQLException when a database error occurs
      *
      */
-    @JRubyMethod(name = "execute_query", required = 2, optional = 1)
-    // @JRubyMethod(name = "execute_query", required = 1, optional = 2)
-    public IRubyObject execute_query(final ThreadContext context,
-        final IRubyObject[] args) throws SQLException {
-        // args: (sql), (sql, max_rows), (sql, binds), (sql, max_rows, binds)
+    @JRubyMethod(required = 1, optional = 2)
+    public IRubyObject execute_query(final ThreadContext context, final IRubyObject[] args) throws SQLException {
         final String query = args[0].convertToString().getUnicodeValue(); // sql
-        IRubyObject max_rows = args.length > 1 ? args[1] : null;
-        IRubyObject binds = args.length > 2 ? args[2] : null;
+        final RubyArray binds;
         final int maxRows;
-        if ( max_rows == null || max_rows.isNil() ) maxRows = 0;
-        else {
-            if ( binds instanceof RubyNumeric ) { // (sql, max_rows)
-                maxRows = RubyNumeric.fix2int(binds); binds = null;
-            }
-            else {
-                if ( max_rows instanceof RubyNumeric ) {
-                    maxRows = RubyNumeric.fix2int(max_rows);
-                }
-                else {
-                    if ( binds == null ) binds = max_rows; // (sql, binds)
+
+        // args: (sql), (sql, max_rows), (sql, binds), (sql, max_rows, binds)
+        switch (args.length) {
+            case 2:
+                if (args[1] instanceof RubyNumeric) { // (sql, max_rows)
+                    maxRows = RubyNumeric.fix2int(args[1]);
+                    binds = null;
+                } else {                              // (sql, binds)
                     maxRows = 0;
+                    binds = (RubyArray) TypeConverter.checkArrayType(args[1]);
                 }
-            }
+                break;
+            case 3:                                   // (sql, max_rows, binds)
+                maxRows = RubyNumeric.fix2int(args[1]);
+                binds = (RubyArray) TypeConverter.checkArrayType(args[2]);
+                break;
+            default:                                  // (sql) 1-arg
+                maxRows = 0;
+                binds = null;
+                break;
         }
 
-        if ( binds == null || binds.isNil() ) { // no prepared statements
+        if (binds != null) { // prepared statement
+            return executePreparedQuery(context, query, binds, maxRows);
+        } else {
             return executeQuery(context, query, maxRows);
         }
-        else { // we allow prepared statements with empty binds parameters
-            return executePreparedQuery(context, query, (List) binds, maxRows);
-        }
     }
 
     @JRubyMethod(name = "execute_prepared_query")
@@ -951,12 +904,10 @@ public class RubyJdbcConnection extends RubyObject {
             throw context.runtime.newArgumentError("binds exptected to an instance of Array");
         }
 
-        return executePreparedQuery(context, query, (List) binds, 0);
+        return executePreparedQuery(context, query, (RubyArray) binds, 0);
     }
 
     /**
-     * NOTE: This methods behavior changed in AR-JDBC 1.3 the old behavior is
-     * achievable using {@link #executeQueryRaw(ThreadContext, String, int, Block)}.
      *
      * @param context
      * @param query
@@ -986,42 +937,58 @@ public class RubyJdbcConnection extends RubyObject {
         });
     }
 
-    @JRubyMethod
-    public IRubyObject execute_prepared(final ThreadContext context, final IRubyObject sql, final IRubyObject binds) {
+    // Called from exec_query in abstract/database_statements
+    @JRubyMethod(required = 3)
+    public IRubyObject execute_prepared(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 {
-                PreparedStatement statement = null;
+                final boolean cached = !(cachedStatement == null || cachedStatement.isNil());
                 final String query = sql.convertToString().getUnicodeValue();
-
-                // FIXME: array type check for binds
+                PreparedStatement statement = null;
 
                 try {
-                    statement = connection.prepareStatement(query);
-                    setStatementParameters(context, connection, statement, (List) binds);
+                    if (cached) {
+                        statement = (PreparedStatement) JavaEmbedUtils.rubyToJava(cachedStatement);
+                    } else {
+                        statement = connection.prepareStatement(query);
+                    }
+
+                    setStatementParameters(context, connection, statement, (RubyArray) binds);
                     boolean hasResultSet = statement.execute();
 
                     if (hasResultSet) {
                         ResultSet resultSet = statement.getResultSet();
                         ColumnData[] columns = extractColumns(context.runtime, connection, resultSet, false);
 
-                        return mapToResult(context, context.runtime, connection, resultSet, columns);
+                        IRubyObject results = mapToResult(context, context.runtime, connection, resultSet, columns);
+
+                        if (cached) {
+                            // Make sure we free the result set if we are caching the statement
+                            // It gets closed automatically when the statement is closed if we aren't caching
+                            resultSet.close();
+                        }
+
+                        return results;
                     } else {
                         return context.runtime.newEmptyArray();
-                        //return context.runtime.newFixnum( statement.getUpdateCount());
-//                        return mapGeneratedKeysOrUpdateCount(context, connection, statement);
                     }
                 } catch (final SQLException e) {
                     debugErrorSQL(context, query);
                     throw e;
                 } finally {
-                    close(statement);
+                    if ( cached ) {
+                        statement.clearParameters();
+                    } else {
+                        close(statement);
+                    }
                 }
             }
         });
     }
 
     protected IRubyObject executePreparedQuery(final ThreadContext context, final String query,
-        final List<?> binds, final int maxRows) {
+        final RubyArray binds, final int maxRows) {
         return withConnection(context, new Callable<IRubyObject>() {
             public IRubyObject call(final Connection connection) throws SQLException {
                 PreparedStatement statement = null; ResultSet resultSet = null;
@@ -1081,7 +1048,7 @@ public class RubyJdbcConnection extends RubyObject {
     @JRubyMethod(name = "supported_data_types")
     public IRubyObject supported_data_types(final ThreadContext context) throws SQLException {
         final Ruby runtime = context.getRuntime();
-        final Connection connection = getConnection(true);
+        final Connection connection = getConnection(context, true);
         final ResultSet typeDesc = connection.getMetaData().getTypeInfo();
         final IRubyObject types;
         try {
@@ -1106,7 +1073,7 @@ public class RubyJdbcConnection extends RubyObject {
         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, _tableName);
+                final TableName table = extractTableName(connection, null, null, _tableName);
                 return primaryKeys(context, connection, table);
             }
         });
@@ -1204,7 +1171,7 @@ public class RubyJdbcConnection extends RubyObject {
         final Ruby runtime = context.getRuntime();
         return withConnection(context, new Callable<RubyBoolean>() {
             public RubyBoolean call(final Connection connection) throws SQLException {
-                final TableName components = extractTableName(connection, defaultSchema, tableName);
+                final TableName components = extractTableName(connection, null, defaultSchema, tableName);
                 return runtime.newBoolean( tableExists(runtime, connection, components) );
             }
         });
@@ -1223,12 +1190,7 @@ public class RubyJdbcConnection extends RubyObject {
                     final String defaultSchema = args.length > 2 ? toStringOrNull(args[2]) : null;
 
                     final TableName components;
-                    if ( catalog == null ) { // backwards-compatibility with < 1.3.0
-                        components = extractTableName(connection, defaultSchema, tableName);
-                    }
-                    else {
-                        components = extractTableName(connection, catalog, defaultSchema, tableName);
-                    }
+                    components = extractTableName(connection, catalog, defaultSchema, tableName);
 
                     if ( ! tableExists(context.getRuntime(), connection, components) ) {
                         throw new SQLException("table: " + tableName + " does not exist");
@@ -1277,7 +1239,7 @@ public class RubyJdbcConnection extends RubyObject {
 
                 String _tableName = caseConvertIdentifierForJdbc(connection, tableName);
                 String _schemaName = caseConvertIdentifierForJdbc(connection, schemaName);
-                final TableName table = extractTableName(connection, _schemaName, _tableName);
+                final TableName table = extractTableName(connection, null, _schemaName, _tableName);
 
                 final List<RubyString> primaryKeys = primaryKeys(context, connection, table);
 
@@ -1451,53 +1413,6 @@ public class RubyJdbcConnection extends RubyObject {
         });
     }
 
-    // NOTE: this seems to be not used ... at all ?!
-    /*
-     * sql, values (array), types (column.type array), name = nil, pk = nil, id_value = nil, sequence_name = nil
-     */
-    @Deprecated
-    @JRubyMethod(name = "insert_bind", required = 3, rest = true)
-    public IRubyObject insert_bind(final ThreadContext context, final IRubyObject[] args) throws SQLException {
-        final Ruby runtime = context.getRuntime();
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                final String sql = args[0].convertToString().toString();
-                PreparedStatement statement = null;
-                try {
-                    statement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS);
-                    setPreparedStatementValues(context, connection, statement, args[1], args[2]);
-                    statement.executeUpdate();
-                    return mapGeneratedKeys(runtime, connection, statement);
-                }
-                finally { close(statement); }
-            }
-        });
-    }
-
-    // NOTE: this seems to be not used ... at all ?!
-    /*
-     * sql, values (array), types (column.type array), name = nil
-     */
-    @Deprecated
-    @JRubyMethod(name = "update_bind", required = 3, rest = true)
-    public IRubyObject update_bind(final ThreadContext context, final IRubyObject[] args) throws SQLException {
-        final Ruby runtime = context.getRuntime();
-        Arity.checkArgumentCount(runtime, args, 3, 4);
-        return withConnection(context, new Callable<IRubyObject>() {
-            public IRubyObject call(final Connection connection) throws SQLException {
-                final String sql = args[0].convertToString().toString();
-                PreparedStatement statement = null;
-                try {
-                    statement = connection.prepareStatement(sql);
-                    setPreparedStatementValues(context, connection, statement, args[1], args[2]);
-                    statement.executeUpdate();
-                }
-                finally { close(statement); }
-                return runtime.getNil();
-            }
-        });
-    }
-
     @JRubyMethod(name = "with_connection_retry_guard", frame = true)
     public IRubyObject with_connection_retry_guard(final ThreadContext context, final Block block) {
         return withConnection(context, new Callable<IRubyObject>() {
@@ -1562,11 +1477,15 @@ public class RubyJdbcConnection extends RubyObject {
 
         final String sql = "UPDATE "+ tableName +" SET "+ columnName +" = ? WHERE "+ idKey +" = ?" ;
 
+        // 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);
                     }
@@ -1574,6 +1493,7 @@ public class RubyJdbcConnection extends RubyObject {
                         setClobParameter(context, connection, statement, 1, value, column, Types.CLOB);
                     }
                     setStatementParameter(context, context.getRuntime(), connection, statement, 2, idValue, idColumn);
+                    */
                     return statement.executeUpdate();
                 }
                 finally { close(statement); }
@@ -1672,14 +1592,6 @@ public class RubyJdbcConnection extends RubyObject {
         return config.callMethod(context, "[]", keySym);
     }
 
-    /**
-     * @deprecated renamed to {@link #getConfigValue(ThreadContext, String)}
-     */
-    @Deprecated
-    protected IRubyObject config_value(ThreadContext context, String key) {
-        return getConfigValue(context, key);
-    }
-
     private static String toStringOrNull(final IRubyObject arg) {
         return arg.isNil() ? null : arg.toString();
     }
@@ -1736,9 +1648,8 @@ public class RubyJdbcConnection extends RubyObject {
             final ThreadContext context, final Ruby runtime,
             final List<IRubyObject> results, final ResultSet resultSet,
             final ColumnData[] columns) throws SQLException {
-        final ResultHandler resultHandler = ResultHandler.getInstance(runtime);
         while ( resultSet.next() ) {
-            results.add( resultHandler.mapRawRow(context, runtime, columns, resultSet, this) );
+            results.add(mapRawRow(context, runtime, columns, resultSet, this));
         }
     }
 
@@ -1756,14 +1667,13 @@ public class RubyJdbcConnection extends RubyObject {
             final Connection connection, final ResultSet resultSet,
             final ColumnData[] columns) throws SQLException {
 
-        final ResultHandler resultHandler = ResultHandler.getInstance(runtime);
         final RubyArray resultRows = runtime.newArray();
 
-        while ( resultSet.next() ) {
-            resultRows.append( resultHandler.mapRow(context, runtime, columns, resultSet, this) );
+        while (resultSet.next()) {
+            resultRows.append(mapRow(context, runtime, columns, resultSet, this));
         }
 
-        return resultHandler.newResult(context, runtime, columns, resultRows);
+        return newResult(context, columns, resultRows);
     }
 
     @Deprecated
@@ -1790,12 +1700,7 @@ public class RubyJdbcConnection extends RubyObject {
                 return readerToRuby(context, runtime, resultSet, column);
             case Types.LONGVARCHAR:
             case Types.LONGNVARCHAR: // JDBC 4.0
-                if ( runtime.is1_9() ) {
-                    return readerToRuby(context, runtime, resultSet, column);
-                }
-                else {
-                    return streamToRuby(context, runtime, resultSet, column);
-                }
+                return readerToRuby(context, runtime, resultSet, column);
             case Types.TINYINT:
             case Types.SMALLINT:
             case Types.INTEGER:
@@ -1852,16 +1757,7 @@ public class RubyJdbcConnection extends RubyObject {
         throws SQLException {
         final long value = resultSet.getLong(column);
         if ( value == 0 && resultSet.wasNull() ) return runtime.getNil();
-        return integerToRuby(runtime, resultSet, value);
-    }
-
-    @Deprecated
-    protected IRubyObject integerToRuby(
-        final Ruby runtime, final ResultSet resultSet, final long longValue)
-        throws SQLException {
-        if ( longValue == 0 && resultSet.wasNull() ) return runtime.getNil();
-
-        return runtime.newFixnum(longValue);
+        return runtime.newFixnum(value);
     }
 
     protected IRubyObject doubleToRuby(final ThreadContext context,
@@ -1869,58 +1765,29 @@ public class RubyJdbcConnection extends RubyObject {
         throws SQLException {
         final double value = resultSet.getDouble(column);
         if ( value == 0 && resultSet.wasNull() ) return runtime.getNil();
-        return doubleToRuby(runtime, resultSet, value);
+        return runtime.newFloat(value);
     }
 
-    @Deprecated
-    protected IRubyObject doubleToRuby(
-        final Ruby runtime, final ResultSet resultSet, double doubleValue)
-        throws SQLException {
-        if ( doubleValue == 0 && resultSet.wasNull() ) return runtime.getNil();
-        return runtime.newFloat(doubleValue);
+    protected IRubyObject stringToRuby(final ThreadContext context,
+        final Ruby runtime, final ResultSet resultSet, final int column) throws SQLException {
+        final String value = resultSet.getString(column);
+        if ( value == null && resultSet.wasNull() ) return runtime.getNil();
+        return RubyString.newInternalFromJavaExternal(runtime, value);
     }
 
-    protected IRubyObject stringToRuby(final ThreadContext context,
-        final Ruby runtime, final ResultSet resultSet, final int column)
-        throws SQLException {
+    protected IRubyObject bigIntegerToRuby(final ThreadContext context,
+        final Ruby runtime, final ResultSet resultSet, final int column) throws SQLException {
         final String value = resultSet.getString(column);
         if ( value == null && resultSet.wasNull() ) return runtime.getNil();
-        return stringToRuby(runtime, resultSet, value);
-    }
-
-    @Deprecated
-    protected IRubyObject stringToRuby(
-        final Ruby runtime, final ResultSet resultSet, final String string)
-        throws SQLException {
-        if ( string == null && resultSet.wasNull() ) return runtime.getNil();
-
-        return RubyString.newUnicodeString(runtime, string);
-    }
-
-    protected IRubyObject bigIntegerToRuby(final ThreadContext context,
-        final Ruby runtime, final ResultSet resultSet, final int column)
-        throws SQLException {
-        final String value = resultSet.getString(column);
-        if ( value == null && resultSet.wasNull() ) return runtime.getNil();
-        return bigIntegerToRuby(runtime, resultSet, value);
-    }
-
-    @Deprecated
-    protected IRubyObject bigIntegerToRuby(
-        final Ruby runtime, final ResultSet resultSet, final String intValue)
-        throws SQLException {
-        if ( intValue == null && resultSet.wasNull() ) return runtime.getNil();
-
-        return RubyBignum.bignorm(runtime, new BigInteger(intValue));
+        return RubyBignum.bignorm(runtime, new BigInteger(value));
     }
 
     protected IRubyObject decimalToRuby(final ThreadContext context,
-        final Ruby runtime, final ResultSet resultSet, final int column)
-        throws SQLException {
+        final Ruby runtime, final ResultSet resultSet, final int column) throws SQLException {
         final String value = resultSet.getString(column);
         if ( value == null && resultSet.wasNull() ) return runtime.getNil();
-        // NOTE: JRuby 1.6 -> 1.7 API change : moved org.jruby.RubyBigDecimal
-        return runtime.getKernel().callMethod("BigDecimal", runtime.newString(value));
+
+        return RubyBigDecimal.newInstance(context, runtime.getModule("BigDecimal"), runtime.newString(value));
     }
 
     protected static Boolean rawDateTime;
@@ -1957,7 +1824,7 @@ public class RubyJdbcConnection extends RubyObject {
     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, "type_cast_from_database", value);
+        return type.callMethod(context, "deserialize", value);
     }
 
     protected IRubyObject dateToRuby(final ThreadContext context,
@@ -1976,11 +1843,8 @@ public class RubyJdbcConnection extends RubyObject {
         final IRubyObject adapter = callMethod(context, "adapter"); // self.adapter
         if ( adapter.isNil() ) return strValue; // NOTE: we warn on init_connection
 
-        if ( usesType(runtime) ) {
-            // NOTE: this CAN NOT be 100% correct - as :date is just a type guess!
-            return typeCastFromDatabase(context, adapter, runtime.newSymbol("date"), strValue);
-        }
-        return adapter.callMethod(context, "_string_to_date", strValue);
+        // NOTE: this CAN NOT be 100% correct - as :date is just a type guess!
+        return typeCastFromDatabase(context, adapter, runtime.newSymbol("date"), strValue);
     }
 
     protected IRubyObject timeToRuby(final ThreadContext context,
@@ -1999,11 +1863,8 @@ public class RubyJdbcConnection extends RubyObject {
         final IRubyObject adapter = callMethod(context, "adapter"); // self.adapter
         if ( adapter.isNil() ) return strValue; // NOTE: we warn on init_connection
 
-        if ( usesType(runtime) ) {
-            // NOTE: this CAN NOT be 100% correct - as :time is just a type guess!
-            return typeCastFromDatabase(context, adapter, runtime.newSymbol("time"), strValue);
-        }
-        return adapter.callMethod(context, "_string_to_time", strValue);
+        // NOTE: this CAN NOT be 100% correct - as :time is just a type guess!
+        return typeCastFromDatabase(context, adapter, runtime.newSymbol("time"), strValue);
     }
 
     protected IRubyObject timestampToRuby(final ThreadContext context, // TODO
@@ -2022,11 +1883,8 @@ public class RubyJdbcConnection extends RubyObject {
         final IRubyObject adapter = callMethod(context, "adapter"); // self.adapter
         if ( adapter.isNil() ) return strValue; // NOTE: we warn on init_connection
 
-        if ( usesType(runtime) ) {
-            // NOTE: this CAN NOT be 100% correct - as :timestamp is just a type guess!
-            return typeCastFromDatabase(context, adapter, runtime.newSymbol("timestamp"), strValue);
-        }
-        return adapter.callMethod(context, "_string_to_timestamp", strValue);
+        // NOTE: this CAN NOT be 100% correct - as :timestamp is just a type guess!
+        return typeCastFromDatabase(context, adapter, runtime.newSymbol("timestamp"), strValue);
     }
 
     protected static RubyString timestampToRubyString(final Ruby runtime, String value) {
@@ -2041,14 +1899,6 @@ public class RubyJdbcConnection extends RubyObject {
         return RubyString.newUnicodeString(runtime, value);
     }
 
-    @Deprecated
-    protected IRubyObject timestampToRuby(
-        final Ruby runtime, final ResultSet resultSet, final Timestamp value)
-        throws SQLException {
-        if ( value == null && resultSet.wasNull() ) return runtime.getNil();
-
-        return timestampToRubyString(runtime, value.toString());
-    }
 
     protected static Boolean rawBoolean;
     static {
@@ -2151,7 +2001,7 @@ public class RubyJdbcConnection extends RubyObject {
             string.append(buf, 0, len);
         }
 
-        return RubyString.newUnicodeString(runtime, string.toString());
+        return RubyString.newInternalFromJavaExternal(runtime, string.toString());
     }
 
     protected IRubyObject objectToRuby(final ThreadContext context,
@@ -2190,161 +2040,93 @@ public class RubyJdbcConnection extends RubyObject {
         try {
             if ( xml == null || resultSet.wasNull() ) return runtime.getNil();
 
-            return RubyString.newUnicodeString(runtime, xml.getString());
+            return RubyString.newInternalFromJavaExternal(runtime, xml.getString());
         }
         finally { if ( xml != null ) xml.free(); }
     }
 
     protected void setStatementParameters(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
-        final List<?> binds) throws SQLException {
-
-        final Ruby runtime = context.getRuntime();
-
-        for ( int i = 0; i < binds.size(); i++ ) {
-            // [ [ column1, param1 ], [ column2, param2 ], ... ]
-            Object param = binds.get(i); IRubyObject column = null;
-            if ( param instanceof RubyArray ) {
-                final RubyArray _param = (RubyArray) param;
-                column = _param.eltInternal(0); param = _param.eltInternal(1);
-            }
-            else if ( param instanceof List ) {
-                final List<?> _param = (List<?>) param;
-                column = (IRubyObject) _param.get(0); param = _param.get(1);
-            }
-            else if ( param instanceof Object[] ) {
-                final Object[] _param = (Object[]) param;
-                column = (IRubyObject) _param[0]; param = _param[1];
-            }
+        final RubyArray binds) throws SQLException {
 
-            setStatementParameter(context, runtime, connection, statement, i + 1, param, column);
+        for ( int i = 0; i < binds.getLength(); i++ ) {
+            setStatementParameter(context, connection, statement, i + 1, binds.eltInternal(i));
         }
     }
 
-    // So far we have only examined the needs to Sqlite3 but for that adapter (and it is old JDBC adapter)
-    // we can pass all tests but binary column types with just the supplied value.  So we will leave it
-    // this way until we upgrade Sqlite adapter and get some more databases supported.
-    protected int typeHack(ThreadContext context, IRubyObject column, Object value) throws SQLException {
-        if (column != null) {
-            String columnType = column.asString().toString();
+    // Set the prepared statement attributes based on the passed in Attribute object
+    protected void setStatementParameter(final ThreadContext context,
+            final Connection connection, final PreparedStatement statement,
+            final int index, IRubyObject attribute) throws SQLException {
 
-            if (columnType.equals("binary")) return jdbcTypeFor(context, context.runtime, column, value);
+        //debugMessage(context, attribute);
+        int type = jdbcTypeForAttribute(context, attribute);
+        IRubyObject value = valueForDatabase(context, attribute);
 
-            column = null;
+        // All the set methods were calling this first so save a method call in the nil case
+        if ( value.isNil() ) {
+            statement.setNull(index, type);
+            return;
         }
 
-        return jdbcTypeFor(context, context.runtime, column, value);
-    }
-
-    protected void setStatementParameter(final ThreadContext context,
-            final Ruby runtime, final Connection connection,
-            final PreparedStatement statement, final int index,
-            final Object value, IRubyObject column) throws SQLException {
-        int type = typeHack(context, column, value);
-
         switch (type) {
             case Types.TINYINT:
             case Types.SMALLINT:
             case Types.INTEGER:
-                if ( value instanceof RubyBignum ) { // e.g. HSQLDB / H2 report JDBC type 4
-                    setBigIntegerParameter(context, connection, statement, index, (RubyBignum) value, column, type);
-                }
-                else {
-                    setIntegerParameter(context, connection, statement, index, value, column, type);
-                }
+                setIntegerParameter(context, connection, statement, index, value, attribute, type);
                 break;
             case Types.BIGINT:
-                setBigIntegerParameter(context, connection, statement, index, value, column, type);
+                setBigIntegerParameter(context, connection, statement, index, value, attribute, type);
                 break;
             case Types.REAL:
             case Types.FLOAT:
             case Types.DOUBLE:
-                setDoubleParameter(context, connection, statement, index, value, column, type);
+                setDoubleParameter(context, connection, statement, index, value, attribute, type);
                 break;
             case Types.NUMERIC:
             case Types.DECIMAL:
-                setDecimalParameter(context, connection, statement, index, value, column, type);
+                setDecimalParameter(context, connection, statement, index, value, attribute, type);
                 break;
             case Types.DATE:
-                setDateParameter(context, connection, statement, index, value, column, type);
+                setDateParameter(context, connection, statement, index, value, attribute, type);
                 break;
             case Types.TIME:
-                setTimeParameter(context, connection, statement, index, value, column, type);
+                setTimeParameter(context, connection, statement, index, value, attribute, type);
                 break;
             case Types.TIMESTAMP:
-                setTimestampParameter(context, connection, statement, index, value, column, type);
+                setTimestampParameter(context, connection, statement, index, value, attribute, type);
                 break;
             case Types.BIT:
             case Types.BOOLEAN:
-                setBooleanParameter(context, connection, statement, index, value, column, type);
+                setBooleanParameter(context, connection, statement, index, value, attribute, type);
                 break;
             case Types.SQLXML:
-                setXmlParameter(context, connection, statement, index, value, column, type);
+                setXmlParameter(context, connection, statement, index, value, attribute, type);
                 break;
             case Types.ARRAY:
-                setArrayParameter(context, connection, statement, index, value, column, type);
+                setArrayParameter(context, connection, statement, index, value, attribute, type);
                 break;
             case Types.JAVA_OBJECT:
             case Types.OTHER:
-                setObjectParameter(context, connection, statement, index, value, column, type);
+                setObjectParameter(context, connection, statement, index, value, attribute, type);
                 break;
             case Types.BINARY:
             case Types.VARBINARY:
             case Types.LONGVARBINARY:
             case Types.BLOB:
-                setBlobParameter(context, connection, statement, index, value, column, type);
+                setBlobParameter(context, connection, statement, index, value, attribute, type);
                 break;
             case Types.CLOB:
             case Types.NCLOB: // JDBC 4.0
-                setClobParameter(context, connection, statement, index, value, column, type);
+                setClobParameter(context, connection, statement, index, value, attribute, type);
                 break;
             case Types.CHAR:
             case Types.VARCHAR:
             case Types.NCHAR: // JDBC 4.0
             case Types.NVARCHAR: // JDBC 4.0
             default:
-                setStringParameter(context, connection, statement, index, value, column, type);
-        }
-    }
-
-    @Deprecated // NOTE: only used from deprecated methods
-    private void setPreparedStatementValues(final ThreadContext context,
-            final Connection connection, final PreparedStatement statement,
-            final IRubyObject valuesArg, final IRubyObject typesArg) throws SQLException {
-        final Ruby runtime = context.getRuntime();
-        final RubyArray values = (RubyArray) valuesArg;
-        final RubyArray types = (RubyArray) typesArg; // column types
-        for( int i = 0, j = values.getLength(); i < j; i++ ) {
-            setStatementParameter(
-                    context, runtime, connection, statement, i + 1,
-                    values.eltInternal(i), types.eltInternal(i)
-            );
-        }
-    }
-
-    private RubySymbol resolveColumnType(final ThreadContext context, final Ruby runtime,
-        final IRubyObject column) {
-        if ( column instanceof RubySymbol ) { // deprecated behavior
-            return (RubySymbol) column;
-        }
-        if ( column instanceof RubyString) { // deprecated behavior
-            if ( runtime.is1_9() ) {
-                return ( (RubyString) column ).intern19();
-            }
-            else {
-                return ( (RubyString) column ).intern();
-            }
-        }
-
-        if ( column == null || column.isNil() ) {
-            throw runtime.newArgumentError("nil column passed");
-        }
-
-        final IRubyObject type = column.callMethod(context, "type");
-        if ( type.isNil() || ! (type instanceof RubySymbol) ) {
-            throw new IllegalStateException("unexpected type = " + type.inspect() + " for " + column.inspect());
+                setStringParameter(context, connection, statement, index, value, attribute, type);
         }
-        return (RubySymbol) type;
     }
 
     protected static final Map<String, Integer> JDBC_TYPE_FOR = new HashMap<String, Integer>(32, 1);
@@ -2359,7 +2141,6 @@ public class RubyJdbcConnection extends RubyObject {
         JDBC_TYPE_FOR.put("time", Types.TIME);
         JDBC_TYPE_FOR.put("datetime", Types.TIMESTAMP);
         JDBC_TYPE_FOR.put("timestamp", Types.TIMESTAMP);
-        JDBC_TYPE_FOR.put("binary", Types.BLOB);
         JDBC_TYPE_FOR.put("boolean", Types.BOOLEAN);
         JDBC_TYPE_FOR.put("array", Types.ARRAY);
         JDBC_TYPE_FOR.put("xml", Types.SQLXML);
@@ -2384,107 +2165,89 @@ public class RubyJdbcConnection extends RubyObject {
         JDBC_TYPE_FOR.put("nclob", Types.NCLOB);
     }
 
-    protected int jdbcTypeFor(final ThreadContext context, final Ruby runtime,
-        final IRubyObject column, final Object value) throws SQLException {
+    protected int jdbcTypeForAttribute(final ThreadContext context,
+        final IRubyObject attribute) throws SQLException {
 
-        final String internedType;
-        if ( column != null && ! column.isNil() ) {
-            // NOTE: there's no ActiveRecord "convention" really for this ...
-            // this is based on Postgre's initial support for arrays :
-            // `column.type` contains the base type while there's `column.array?`
-            if ( column.respondsTo("array?") && column.callMethod(context, "array?").isTrue() ) {
-                internedType = "array";
-            }
-            else {
-                internedType = resolveColumnType(context, runtime, column).asJavaString();
-            }
+        final String internedType = internedTypeFor(context, attribute);
+        final Integer sqlType = jdbcTypeFor(internedType);
+        if ( sqlType != null ) {
+            return sqlType.intValue();
         }
-        else {
-            if ( value instanceof RubyInteger ) internedType = "integer";
-            else if ( value instanceof RubyNumeric ) internedType = "float";
-            else if ( value instanceof RubyTime ) internedType = "timestamp";
-            else internedType = "string";
-        }
-
-        final Integer sqlType = JDBC_TYPE_FOR.get(internedType);
-        if ( sqlType != null ) return sqlType.intValue();
 
         return Types.OTHER; // -1 as well as 0 are used in Types
     }
 
-    protected void setIntegerParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, final Object value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value instanceof IRubyObject ) {
-            setIntegerParameter(context, connection, statement, index, (IRubyObject) value, column, type);
+    protected Integer jdbcTypeFor(final String type) {
+        return JDBC_TYPE_FOR.get(type);
+    }
+
+    protected IRubyObject attributeType(final ThreadContext context, final IRubyObject attribute) {
+        return attribute.callMethod(context, "type");
+    }
+
+    protected IRubyObject attributeSQLType(final ThreadContext context, final IRubyObject attribute) {
+        return attributeType(context, attribute).callMethod(context, "type");
+    }
+
+    protected String internedTypeFor(final ThreadContext context, final IRubyObject attribute) throws SQLException {
+
+        final IRubyObject type = attributeSQLType(context, attribute);
+
+        if ( !type.isNil() ) {
+            return type.asJavaString();
         }
-        else {
-            if ( value == null ) statement.setNull(index, Types.INTEGER);
-            else {
-                statement.setLong(index, ((Number) value).longValue());
-            }
+
+        final IRubyObject value = attribute.callMethod(context, "value");
+
+        if ( value instanceof RubyInteger ) {
+            return "integer";
+        }
+
+        if ( value instanceof RubyNumeric ) {
+            return "float";
         }
+
+        if ( value instanceof RubyTime ) {
+            return "timestamp";
+        }
+
+        return "string";
     }
 
     protected void setIntegerParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
         final int index, final IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) statement.setNull(index, Types.INTEGER);
-        else {
-            if ( value instanceof RubyFixnum ) {
-                statement.setLong(index, ((RubyFixnum) value).getLongValue());
-            }
-            else if ( value instanceof RubyNumeric ) {
-                // NOTE: fix2int will call value.convertToIngeter for non-numeric
-                // types which won't work for Strings since it uses `to_int` ...
-                statement.setInt(index, RubyNumeric.fix2int(value));
-            }
-            else {
-                statement.setLong(index, value.convertToInteger("to_i").getLongValue());
-            }
-        }
-    }
+        final IRubyObject attribute, final int type) throws SQLException {
 
-    protected void setBigIntegerParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, final Object value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value instanceof IRubyObject ) {
-            setBigIntegerParameter(context, connection, statement, index, (IRubyObject) value, column, type);
+        if ( value instanceof RubyBignum ) { // e.g. HSQLDB / H2 report JDBC type 4
+            setBigIntegerParameter(context, connection, statement, index, (RubyBignum) value, attribute, type);
+        }
+        else if ( value instanceof RubyFixnum ) {
+            statement.setLong(index, ((RubyFixnum) value).getLongValue());
+        }
+        else if ( value instanceof RubyNumeric ) {
+            // NOTE: fix2int will call value.convertToInteger for non-numeric
+            // types which won't work for Strings since it uses `to_int` ...
+            statement.setInt(index, RubyNumeric.fix2int(value));
         }
         else {
-            if ( value == null ) statement.setNull(index, Types.BIGINT);
-            else {
-                if ( value instanceof BigDecimal ) {
-                    statement.setBigDecimal(index, (BigDecimal) value);
-                }
-                else if ( value instanceof BigInteger ) {
-                    setLongOrDecimalParameter(statement, index, (BigInteger) value);
-                }
-                else {
-                    statement.setLong(index, ((Number) value).longValue());
-                }
-            }
+            statement.setLong(index, value.convertToInteger("to_i").getLongValue());
         }
     }
 
     protected void setBigIntegerParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
         final int index, final IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) statement.setNull(index, Types.INTEGER);
+        final IRubyObject attribute, final int type) throws SQLException {
+
+        if ( value instanceof RubyBignum ) {
+            setLongOrDecimalParameter(statement, index, ((RubyBignum) value).getValue());
+        }
+        else if ( value instanceof RubyInteger ) {
+            statement.setLong(index, ((RubyInteger) value).getLongValue());
+        }
         else {
-            if ( value instanceof RubyBignum ) {
-                setLongOrDecimalParameter(statement, index, ((RubyBignum) value).getValue());
-            }
-            else if ( value instanceof RubyInteger ) {
-                statement.setLong(index, ((RubyInteger) value).getLongValue());
-            }
-            else {
-                setLongOrDecimalParameter(statement, index, value.convertToInteger("to_i").getBigIntegerValue());
-            }
+            setLongOrDecimalParameter(statement, index, value.convertToInteger("to_i").getBigIntegerValue());
         }
     }
 
@@ -2502,153 +2265,63 @@ public class RubyJdbcConnection extends RubyObject {
         }
     }
 
-    protected void setDoubleParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, final Object value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value instanceof IRubyObject ) {
-            setDoubleParameter(context, connection, statement, index, (IRubyObject) value, column, type);
-        }
-        else {
-            if ( value == null ) statement.setNull(index, Types.DOUBLE);
-            else {
-                statement.setDouble(index, ((Number) value).doubleValue());
-            }
-        }
-    }
-
     protected void setDoubleParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
         final int index, final IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) statement.setNull(index, Types.DOUBLE);
-        else {
-            if ( value instanceof RubyNumeric ) {
-                statement.setDouble(index, ((RubyNumeric) value).getDoubleValue());
-            }
-            else {
-                statement.setDouble(index, value.convertToFloat().getDoubleValue());
-            }
-        }
-    }
+        final IRubyObject attribute, final int type) throws SQLException {
 
-    protected void setDecimalParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, final Object value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value instanceof IRubyObject ) {
-            setDecimalParameter(context, connection, statement, index, (IRubyObject) value, column, type);
+        if ( value instanceof RubyNumeric ) {
+            statement.setDouble(index, ((RubyNumeric) value).getDoubleValue());
         }
         else {
-            if ( value == null ) statement.setNull(index, Types.DECIMAL);
-            else {
-                if ( value instanceof BigDecimal ) {
-                    statement.setBigDecimal(index, (BigDecimal) value);
-                }
-                else if ( value instanceof BigInteger ) {
-                    setLongOrDecimalParameter(statement, index, (BigInteger) value);
-                }
-                else {
-                    statement.setDouble(index, ((Number) value).doubleValue());
-                }
-            }
+            statement.setDouble(index, value.convertToFloat().getDoubleValue());
         }
     }
 
     protected void setDecimalParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
         final int index, final IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) statement.setNull(index, Types.DECIMAL);
-        else {
-            // NOTE: RubyBigDecimal moved into org.jruby.ext.bigdecimal (1.6 -> 1.7)
-            if ( value.getMetaClass().getName().indexOf("BigDecimal") != -1 ) {
-                statement.setBigDecimal(index, getBigDecimalValue(value));
-            }
-            else if ( value instanceof RubyInteger ) {
-                statement.setBigDecimal(index, new BigDecimal(((RubyInteger) value).getBigIntegerValue()));
-            }
-            else if ( value instanceof RubyNumeric ) {
-                statement.setDouble(index, ((RubyNumeric) value).getDoubleValue());
-            }
-            else { // e.g. `BigDecimal '42.00000000000000000001'`
-                IRubyObject v = callMethod(context, "BigDecimal", value);
-                statement.setBigDecimal(index, getBigDecimalValue(v));
-            }
-        }
-    }
+        final IRubyObject attribute, final int type) throws SQLException {
 
-    private static BigDecimal getBigDecimalValue(final IRubyObject value) {
-        try { // reflect ((RubyBigDecimal) value).getValue() :
-            return (BigDecimal) value.getClass().
-                getMethod("getValue", (Class<?>[]) null).
-                invoke(value, (Object[]) null);
+        if (value instanceof RubyBigDecimal) {
+            statement.setBigDecimal(index, ((RubyBigDecimal) value).getValue());
         }
-        catch (NoSuchMethodException e) {
-            throw new RuntimeException(e);
+        else if ( value instanceof RubyInteger ) {
+            statement.setBigDecimal(index, new BigDecimal(((RubyInteger) value).getBigIntegerValue()));
         }
-        catch (IllegalAccessException e) {
-            throw new RuntimeException(e);
-        }
-        catch (InvocationTargetException e) {
-            throw new RuntimeException(e.getCause() != null ? e.getCause() : e);
-        }
-    }
-
-    protected void setTimestampParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, final Object value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value instanceof IRubyObject ) {
-            setTimestampParameter(context, connection, statement, index, (IRubyObject) value, column, type);
+        else if ( value instanceof RubyNumeric ) {
+            statement.setDouble(index, ((RubyNumeric) value).getDoubleValue());
         }
-        else {
-            if ( value == null ) statement.setNull(index, Types.TIMESTAMP);
-            else {
-                if ( value instanceof Timestamp ) {
-                    statement.setTimestamp(index, (Timestamp) value);
-                }
-                else if ( value instanceof java.util.Date ) {
-                    statement.setTimestamp(index, new Timestamp(((java.util.Date) value).getTime()));
-                }
-                else {
-                    statement.setTimestamp(index, Timestamp.valueOf(value.toString()));
-                }
-            }
+        else { // e.g. `BigDecimal '42.00000000000000000001'`
+            statement.setBigDecimal(index,
+                    RubyBigDecimal.newInstance(context, context.runtime.getModule("BigDecimal"), value).getValue());
         }
     }
 
     protected void setTimestampParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
         final int index, IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) statement.setNull(index, Types.TIMESTAMP);
-        else {
-            value = getTimeInDefaultTimeZone(context, value);
-            if ( value instanceof RubyTime ) {
-                final RubyTime timeValue = (RubyTime) value;
-                final DateTime dateTime = timeValue.getDateTime();
-
-                final Timestamp timestamp = new Timestamp( dateTime.getMillis() );
-                if ( type != Types.DATE ) { // 1942-11-30T01:02:03.123_456
-                    // getMillis already set nanos to: 123_000_000
-                    final int usec = (int) timeValue.getUSec(); // 456 on JRuby
-                    if ( usec >= 0 ) {
-                        timestamp.setNanos( timestamp.getNanos() + usec * 1000 );
-                    }
-                }
-                statement.setTimestamp( index, timestamp, getTimeZoneCalendar(dateTime.getZone().getID()) );
-            }
-            else if ( value instanceof RubyString ) { // yyyy-[m]m-[d]d hh:mm:ss[.f...]
-                final Timestamp timestamp = Timestamp.valueOf( value.toString() );
-                statement.setTimestamp( index, timestamp ); // assume local time-zone
-            }
-            else { // DateTime ( ActiveSupport::TimeWithZone.to_time )
-                final RubyFloat timeValue = value.convertToFloat(); // to_f
-                final Timestamp timestamp = convertToTimestamp(timeValue);
+        final IRubyObject attribute, final int type) throws SQLException {
 
-                statement.setTimestamp( index, timestamp, getTimeZoneCalendar("GMT") );
-            }
+        value = callMethod(context, "time_in_default_timezone", value);
+
+        if (value instanceof RubyTime) {
+            final RubyTime timeValue = (RubyTime) value;
+            final DateTime dateTime = timeValue.getDateTime();
+            final Timestamp timestamp = new Timestamp(dateTime.getMillis());
+
+            // 1942-11-30T01:02:03.123_456
+            if (type != Types.DATE && timeValue.getNSec() >= 0) timestamp.setNanos((int) (timestamp.getNanos() + timeValue.getNSec()));
+
+            statement.setTimestamp(index, timestamp, getTimeZoneCalendar(dateTime.getZone().getID()));
+        } else if ( value instanceof RubyString ) { // yyyy-[m]m-[d]d hh:mm:ss[.f...]
+            final Timestamp timestamp = Timestamp.valueOf(value.toString());
+            statement.setTimestamp(index, timestamp); // assume local time-zone
+        } else { // DateTime ( ActiveSupport::TimeWithZone.to_time )
+            final RubyFloat timeValue = value.convertToFloat(); // to_f
+            final Timestamp timestamp = convertToTimestamp(timeValue);
+
+            statement.setTimestamp( index, timestamp, getTimeZoneCalendar("GMT") );
         }
     }
 
@@ -2663,7 +2336,7 @@ public class RubyJdbcConnection extends RubyObject {
         final int len = strValue.getRealSize() - strValue.getBegin();
         if ( dot1 > 0 && dot4 < len ) { // skip .123 but handle .1234
             final int end = Math.min( len - dot4, 3 );
-            CharSequence usecSeq = strValue.subSequence(dot4, end);
+            CharSequence usecSeq = strValue.subSequence(dot4, dot4 + end);
             final int usec = Integer.parseInt( usecSeq.toString() );
             if ( usec < 10 ) { // 0.1234 ~> 4
                 timestamp.setNanos( timestamp.getNanos() + usec * 100 );
@@ -2679,301 +2352,124 @@ public class RubyJdbcConnection extends RubyObject {
         return timestamp;
     }
 
-    protected static IRubyObject getTimeInDefaultTimeZone(final ThreadContext context, IRubyObject value) {
-        if ( value.respondsTo("to_time") ) {
-            value = value.callMethod(context, "to_time");
-        }
-        final String method = isDefaultTimeZoneUTC(context) ? "getutc" : "getlocal";
-        if ( value.respondsTo(method) ) {
-            value = value.callMethod(context, method);
-        }
-        return value;
-    }
-
-    protected static boolean isDefaultTimeZoneUTC(final ThreadContext context) {
-        final RubyClass base = getBase(context.getRuntime());
-        final String tz = base.callMethod(context, "default_timezone").toString(); // :utc
-        return "utc".equalsIgnoreCase(tz);
-    }
-
     private static Calendar getTimeZoneCalendar(final String ID) {
         return Calendar.getInstance( TimeZone.getTimeZone(ID) );
     }
 
-    protected void setTimeParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, final Object value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value instanceof IRubyObject ) {
-            setTimeParameter(context, connection, statement, index, (IRubyObject) value, column, type);
-        }
-        else {
-            if ( value == null ) statement.setNull(index, Types.TIME);
-            else {
-                if ( value instanceof Time ) {
-                    statement.setTime(index, (Time) value);
-                }
-                else if ( value instanceof java.util.Date ) {
-                    statement.setTime(index, new Time(((java.util.Date) value).getTime()));
-                }
-                else { // hh:mm:ss
-                    statement.setTime(index, Time.valueOf(value.toString()));
-                    // statement.setString(index, value.toString());
-                }
-            }
-        }
-    }
-
     protected void setTimeParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
         final int index, IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) statement.setNull(index, Types.TIME);
-        else {
-            value = getTimeInDefaultTimeZone(context, value);
-            if ( value instanceof RubyTime ) {
-                final RubyTime timeValue = (RubyTime) value;
-                final DateTime dateTime = timeValue.getDateTime();
+        final IRubyObject attribute, final int type) throws SQLException {
 
-                final Time time = new Time( dateTime.getMillis() );
-                statement.setTime( index, time, getTimeZoneCalendar(dateTime.getZone().getID()) );
-            }
-            else if ( value instanceof RubyString ) {
-                final Time time = Time.valueOf( value.toString() );
-                statement.setTime( index, time ); // assume local time-zone
-            }
-            else { // DateTime ( ActiveSupport::TimeWithZone.to_time )
-                final RubyFloat timeValue = value.convertToFloat(); // to_f
-                final Time time = new Time(timeValue.getLongValue() * 1000); // millis
-                // java.sql.Time is expected to be only up to second precision
-                statement.setTime( index, time, getTimeZoneCalendar("GMT") );
-            }
-        }
-    }
+        value = callMethod(context, "time_in_default_timezone", value);
 
-    protected void setDateParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, final Object value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value instanceof IRubyObject ) {
-            setDateParameter(context, connection, statement, index, (IRubyObject) value, column, type);
+        if ( value instanceof RubyTime ) {
+            final DateTime dateTime = ((RubyTime) value).getDateTime();
+            final Time time = new Time(dateTime.getMillis());
+
+            statement.setTime(index, time, getTimeZoneCalendar(dateTime.getZone().getID()));
         }
-        else {
-            if ( value == null ) statement.setNull(index, Types.DATE);
-            else {
-                if ( value instanceof Date ) {
-                    statement.setDate(index, (Date) value);
-                }
-                else if ( value instanceof java.util.Date ) {
-                    statement.setDate(index, new Date(((java.util.Date) value).getTime()));
-                }
-                else { // yyyy-[m]m-[d]d
-                    statement.setDate(index, Date.valueOf(value.toString()));
-                    // statement.setString(index, value.toString());
-                }
-            }
+        else if ( value instanceof RubyString ) {
+            final Time time = Time.valueOf(value.toString());
+            statement.setTime(index, time); // assume local time-zone
+        }
+        else { // DateTime ( ActiveSupport::TimeWithZone.to_time )
+            final RubyFloat timeValue = value.convertToFloat(); // to_f
+            final Time time = new Time(timeValue.getLongValue() * 1000); // millis
+            // java.sql.Time is expected to be only up to second precision
+            statement.setTime(index, time, getTimeZoneCalendar("GMT"));
         }
     }
 
     protected void setDateParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
         final int index, IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) statement.setNull(index, Types.DATE);
-        else {
-            //if ( value instanceof RubyString ) {
-            //    final Date date = Date.valueOf( value.toString() );
-            //    statement.setDate( index, date ); // assume local time-zone
-            //    return;
-            //}
-            if ( ! "Date".equals( value.getMetaClass().getName() ) ) {
-                if ( value.respondsTo("to_date") ) {
-                    value = value.callMethod(context, "to_date");
-                }
-            }
-            final Date date = Date.valueOf( value.asString().toString() ); // to_s
-            statement.setDate( index, date /*, getTimeZoneCalendar("GMT") */ );
-        }
-    }
+        final IRubyObject attribute, final int type) throws SQLException {
 
-    protected void setBooleanParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, final Object value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value instanceof IRubyObject ) {
-            setBooleanParameter(context, connection, statement, index, (IRubyObject) value, column, type);
-        }
-        else {
-            if ( value == null ) statement.setNull(index, Types.BOOLEAN);
-            else {
-                statement.setBoolean(index, ((Boolean) value).booleanValue());
-            }
+        if ( ! "Date".equals(value.getMetaClass().getName()) && value.respondsTo("to_date") ) {
+            value = value.callMethod(context, "to_date");
         }
+        final Date date = Date.valueOf(value.asString().toString()); // to_s
+        statement.setDate(index, date);
     }
 
     protected void setBooleanParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
         final int index, final IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) statement.setNull(index, Types.BOOLEAN);
-        else {
-            statement.setBoolean(index, value.isTrue());
-        }
-    }
-
-    protected void setStringParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, final Object value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value instanceof IRubyObject ) {
-            setStringParameter(context, connection, statement, index, (IRubyObject) value, column, type);
-        }
-        else {
-            if ( value == null ) statement.setNull(index, Types.VARCHAR);
-            else {
-                statement.setString(index, value.toString());
-            }
-        }
+        final IRubyObject attribute, final int type) throws SQLException {
+        statement.setBoolean(index, value.isTrue());
     }
 
     protected void setStringParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
         final int index, final IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) statement.setNull(index, Types.VARCHAR);
-        else {
-            statement.setString(index, value.asString().toString());
-        }
-    }
+        final IRubyObject attribute, final int type) throws SQLException {
 
-    protected void setArrayParameter(final ThreadContext context,
-            final Connection connection, final PreparedStatement statement,
-            final int index, final Object value,
-            final IRubyObject column, final int type) throws SQLException {
-        if ( value instanceof IRubyObject ) {
-            setArrayParameter(context, connection, statement, index, (IRubyObject) value, column, type);
-        } else {
-            if ( value == null ) {
-                statement.setNull(index, Types.ARRAY);
-            } else {
-                String typeName = resolveArrayBaseTypeName(context, value, column, type);
-                Array array = connection.createArrayOf(typeName, (Object[]) value);
-                statement.setArray(index, array);
-            }
-        }
+        statement.setString(index, value.asString().toString());
     }
 
     protected void setArrayParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
         final int index, final IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) {
-            statement.setNull(index, Types.ARRAY);
-        } else {
-            String typeName = resolveArrayBaseTypeName(context, value, column, type);
-            Array array = connection.createArrayOf(typeName, ((RubyArray) value).toArray());
-            statement.setArray(index, array);
-        }
-    }
+        final IRubyObject attribute, final int type) throws SQLException {
 
-    protected String resolveArrayBaseTypeName(final ThreadContext context,
-        final Object value, final IRubyObject column, final int type) {
-        // return column.callMethod(context, "sql_type").toString();
-        String sqlType = column.callMethod(context, "sql_type").toString();
-        final int index = sqlType.indexOf('('); // e.g. "character varying(255)"
-        if ( index > 0 ) sqlType = sqlType.substring(0, index);
-        return sqlType;
+        final String typeName = resolveArrayBaseTypeName(context, attribute);
+        final IRubyObject valueForDB = value.callMethod(context, "values");
+        Array array = connection.createArrayOf(typeName, ((RubyArray) valueForDB).toArray());
+        statement.setArray(index, array);
     }
 
-    protected void setXmlParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, final Object value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value instanceof IRubyObject ) {
-            setXmlParameter(context, connection, statement, index, (IRubyObject) value, column, type);
-        }
-        else {
-            if ( value == null ) statement.setNull(index, Types.SQLXML);
-            else {
-                SQLXML xml = connection.createSQLXML();
-                xml.setString(value.toString());
-                statement.setSQLXML(index, xml);
-            }
+    protected String resolveArrayBaseTypeName(final ThreadContext context, final IRubyObject attribute) throws SQLException {
+
+        // This shouldn't return nil at this point because we know we have an array typed attribute
+        final RubySymbol type = (RubySymbol) attributeSQLType(context, attribute);
+
+        // For some reason the driver doesn't like "character varying" as a type
+        if ( type.eql(context.runtime.newSymbol("string")) ){
+            return "text";
         }
+
+        final IRubyObject adapter = callMethod("adapter");
+        final RubyHash nativeTypes = (RubyHash) adapter.callMethod(context, "native_database_types");
+        final RubyHash typeInfo = (RubyHash) nativeTypes.op_aref(context, type);
+
+        return typeInfo.op_aref(context, context.runtime.newSymbol("name")).asString().toString();
     }
 
     protected void setXmlParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
         final int index, final IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) statement.setNull(index, Types.SQLXML);
-        else {
-            SQLXML xml = connection.createSQLXML();
-            xml.setString(value.asString().toString());
-            statement.setSQLXML(index, xml);
-        }
-    }
+        final IRubyObject attribute, final int type) throws SQLException {
 
-    protected void setBlobParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, final Object value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value instanceof IRubyObject ) {
-            setBlobParameter(context, connection, statement, index, (IRubyObject) value, column, type);
-        }
-        else {
-            if ( value == null ) statement.setNull(index, Types.BLOB);
-            else {
-                //statement.setBlob(index, (InputStream) value);
-                statement.setBinaryStream(index, (InputStream) value);
-            }
-        }
+        SQLXML xml = connection.createSQLXML();
+        xml.setString(value.asString().toString());
+        statement.setSQLXML(index, xml);
     }
 
     protected void setBlobParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
         final int index, final IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value.isNil() ) statement.setNull(index, Types.BLOB);
-        else {
-            if ( value instanceof RubyIO ) { // IO/File
-                //statement.setBlob(index, ((RubyIO) value).getInStream());
-                statement.setBinaryStream(index, ((RubyIO) value).getInStream());
-            }
-            else { // should be a RubyString
-                final ByteList blob = value.asString().getByteList();
-                statement.setBytes(index, blob.bytes());
-                //statement.setBinaryStream(index,
-//                    new ByteArrayInputStream(blob.unsafeBytes(), blob.getBegin(), blob.getRealSize()),
-//                    blob.getRealSize() // length
-//                );
-                // JDBC 4.0 :
-                //statement.setBlob(index,
-                //    new ByteArrayInputStream(bytes.unsafeBytes(), bytes.getBegin(), bytes.getRealSize())
-                //);
-            }
-        }
-    }
+        final IRubyObject attribute, final int type) throws SQLException {
 
-    protected void setClobParameter(final ThreadContext context,
-        final Connection connection, final PreparedStatement statement,
-        final int index, final Object value,
-        final IRubyObject column, final int type) throws SQLException {
-        if ( value instanceof IRubyObject ) {
-            setClobParameter(context, connection, statement, index, (IRubyObject) value, column, type);
+        if ( value instanceof RubyIO ) { // IO/File
+            // JDBC 4.0: statement.setBlob(index, ((RubyIO) value).getInStream());
+            statement.setBinaryStream(index, ((RubyIO) value).getInStream());
         }
-        else {
-            if ( value == null ) statement.setNull(index, Types.CLOB);
-            else {
-                statement.setClob(index, (Reader) value);
-            }
+        else { // should be a RubyString
+            final ByteList blob = value.asString().getByteList();
+            statement.setBytes(index, blob.bytes());
+
+            // JDBC 4.0 :
+            //statement.setBlob(index,
+            //    new ByteArrayInputStream(bytes.unsafeBytes(), bytes.getBegin(), bytes.getRealSize())
+            //);
         }
     }
 
     protected void setClobParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
         final int index, final IRubyObject value,
-        final IRubyObject column, final int type) throws SQLException {
+        final IRubyObject attribute, final int type) throws SQLException {
         if ( value.isNil() ) statement.setNull(index, Types.CLOB);
         else {
             if ( value instanceof RubyIO ) { // IO/File
@@ -2990,35 +2486,32 @@ public class RubyJdbcConnection extends RubyObject {
 
     protected void setObjectParameter(final ThreadContext context,
         final Connection connection, final PreparedStatement statement,
-        final int index, Object value,
-        final IRubyObject column, final int type) throws SQLException {
-        if (value instanceof IRubyObject) {
-            value = ((IRubyObject) value).toJava(Object.class);
-        }
-        if ( value == null ) statement.setNull(index, Types.JAVA_OBJECT);
-        statement.setObject(index, value);
-    }
+        final int index, IRubyObject value,
+        final IRubyObject attribute, final int type) throws SQLException {
 
-    protected final Connection getConnection() {
-        return getConnection(false);
+        statement.setObject(index, value.toJava(Object.class));
     }
 
-    protected Connection getConnection(boolean error) {
-        final Connection connection = (Connection) dataGetStruct(); // synchronized
-        if ( connection == null && error ) {
-            final RubyClass errorClass = getConnectionNotEstablished( getRuntime() );
-            throw new RaiseException(getRuntime(), errorClass, "no connection available", false);
+    protected Connection getConnection(ThreadContext context, boolean reportMissingConnection) {
+        Connection connection = (Connection) dataGetStruct(); // synchronized
+
+        if (connection == null && reportMissingConnection) {
+            throw new RaiseException(getRuntime(), ActiveRecord(context).getClass("ConnectionNotEstablished"),
+                    "no connection available", false);
         }
+
         return connection;
     }
 
-    private IRubyObject setConnection(final Connection connection) {
-        close( getConnection(false) ); // close previously open connection if there is one
+    private IRubyObject setConnection(ThreadContext context, final Connection connection) {
+        close(getConnection(context, false)); // close previously open connection if there is one
+
+        final IRubyObject rubyConnectionObject = connection != null ?
+                convertJavaToRuby(connection) : context.runtime.getNil();
 
-        final IRubyObject rubyConnectionObject =
-            connection != null ? convertJavaToRuby(connection) : getRuntime().getNil();
         setInstanceVariable( "@connection", rubyConnectionObject );
         dataWrapStruct(connection);
+
         return rubyConnectionObject;
     }
 
@@ -3152,25 +2645,6 @@ public class RubyJdbcConnection extends RubyObject {
         return tables;
     }
 
-    /**
-     * NOTE: since 1.3.0 only present for binary compatibility (with extensions).
-     *
-     * @depreacated no longer used - replaced with
-     * {@link #matchTables(Ruby, Connection, String, String, String, String[], boolean)}
-     * please update your sub-class esp. if you're overriding this method !
-     */
-    @Deprecated
-    protected SQLBlock tableLookupBlock(final Ruby runtime,
-            final String catalog, final String schemaPattern,
-            final String tablePattern, final String[] types) {
-        return new SQLBlock() {
-            @Override
-            public IRubyObject call(final Connection connection) throws SQLException {
-                return matchTables(runtime, connection, catalog, schemaPattern, tablePattern, types, false);
-            }
-        };
-    }
-
     protected static final int COLUMN_NAME = 4;
     protected static final int DATA_TYPE = 5;
     protected static final int TYPE_NAME = 6;
@@ -3212,24 +2686,7 @@ public class RubyJdbcConnection extends RubyObject {
     private static IRubyObject defaultValueFromResultSet(final Ruby runtime, final ResultSet resultSet)
         throws SQLException {
         final String defaultValue = resultSet.getString(COLUMN_DEF);
-        return defaultValue == null ? runtime.getNil() : RubyString.newUnicodeString(runtime, defaultValue);
-    }
-
-    /**
-     * Internal API that might be subject to change!
-     * @since 1.3.18
-     */
-    protected static boolean usesType(final Ruby runtime) { // AR 4.2
-        return runtime.getModule("ActiveRecord").getConstantAt("Type") != null;
-    }
-
-    /**
-     * This method is considered internal and is not part of AR-JDBC's Java ext
-     * API and thus might be subject to change in the future.
-     * Please copy it to your own class if you rely on it to avoid issues.
-     */
-    protected static boolean isAr42(IRubyObject column) {
-        return column.respondsTo("cast_type");
+        return defaultValue == null ? runtime.getNil() : RubyString.newInternalFromJavaExternal(runtime, defaultValue);
     }
 
     protected RubyArray mapColumnsResult(final ThreadContext context,
@@ -3258,9 +2715,9 @@ public class RubyJdbcConnection extends RubyObject {
         final IRubyObject config = getConfig(context);
         while ( results.next() ) {
             final String colName = results.getString(COLUMN_NAME);
-            final RubyString railsColumnName = RubyString.newUnicodeString(runtime, caseConvertIdentifierForRails(metaData, colName));
+            final RubyString railsColumnName = RubyString.newInternalFromJavaExternal(runtime, caseConvertIdentifierForRails(metaData, colName));
             final IRubyObject defaultValue = defaultValueFromResultSet( runtime, results );
-            final RubyString sqlType = RubyString.newUnicodeString( runtime, typeFromResultSet(results) );
+            final RubyString sqlType = RubyString.newInternalFromJavaExternal( runtime, typeFromResultSet(results) );
             final RubyBoolean nullable = runtime.newBoolean( ! results.getString(IS_NULLABLE).trim().equals("NO") );
             final IRubyObject[] args;
             if ( lookupCastType ) {
@@ -3355,22 +2812,8 @@ public class RubyJdbcConnection extends RubyObject {
         return keys;
     }
 
-    protected IRubyObject mapGeneratedKey(final Ruby runtime, final ResultSet genKeys)
-        throws SQLException {
-        return runtime.newFixnum( genKeys.getLong(1) );
-    }
-
-    protected IRubyObject mapGeneratedKeysOrUpdateCount(final ThreadContext context,
-        final Connection connection, final Statement statement) throws SQLException {
-        final Ruby runtime = context.getRuntime();
-        final IRubyObject key = mapGeneratedKeys(runtime, connection, statement);
-        return ( key == null || key.isNil() ) ? runtime.newFixnum( statement.getUpdateCount() ) : key;
-    }
-
-    @Deprecated
-    protected IRubyObject unmarshalKeysOrUpdateCount(final ThreadContext context,
-        final Connection connection, final Statement statement) throws SQLException {
-        return mapGeneratedKeysOrUpdateCount(context, connection, statement);
+    protected IRubyObject mapGeneratedKey(final Ruby runtime, final ResultSet genKeys) throws SQLException {
+        return runtime.newFixnum(genKeys.getLong(1));
     }
 
     private Boolean supportsGeneratedKeys;
@@ -3386,64 +2829,6 @@ public class RubyJdbcConnection extends RubyObject {
         return supportsGeneratedKeys.booleanValue();
     }
 
-    /**
-     * @deprecated no longer used - kept for binary compatibility, this method
-     * is confusing since it closes the result set it receives and thus was
-     * replaced with {@link #mapGeneratedKeys(Ruby, Connection, Statement)}
-     */
-    @Deprecated
-    public static IRubyObject unmarshal_id_result(
-        final Ruby runtime, final ResultSet genKeys) throws SQLException {
-        try {
-            if (genKeys.next() && genKeys.getMetaData().getColumnCount() > 0) {
-                return runtime.newFixnum( genKeys.getLong(1) );
-            }
-            return runtime.getNil();
-        }
-        finally { close(genKeys); }
-     }
-
-    protected IRubyObject mapResults(final ThreadContext context,
-            final Connection connection, final Statement statement,
-            final boolean downCase) throws SQLException {
-
-        final Ruby runtime = context.getRuntime();
-        IRubyObject result;
-        ResultSet resultSet = statement.getResultSet();
-        try {
-            result = mapToRawResult(context, runtime, connection, resultSet, downCase);
-        }
-        finally { close(resultSet); }
-
-        if ( ! statement.getMoreResults() ) return result;
-
-        final List<IRubyObject> results = new ArrayList<IRubyObject>();
-        results.add(result);
-
-        do {
-            resultSet = statement.getResultSet();
-            try {
-                result = mapToRawResult(context, runtime, connection, resultSet, downCase);
-            }
-            finally { close(resultSet); }
-
-            results.add(result);
-        }
-        while ( statement.getMoreResults() );
-
-        return runtime.newArray(results);
-    }
-
-    /**
-     * @deprecated no longer used but kept for binary compatibility
-     */
-    @Deprecated
-    protected IRubyObject unmarshalResult(final ThreadContext context,
-            final DatabaseMetaData metaData, final ResultSet resultSet,
-            final boolean downCase) throws SQLException {
-        return mapToRawResult(context, context.getRuntime(), metaData, resultSet, downCase);
-    }
-
     /**
      * Converts a JDBC result set into an array (rows) of hashes (row).
      *
@@ -3462,20 +2847,6 @@ public class RubyJdbcConnection extends RubyObject {
         return results;
     }
 
-    @Deprecated
-    @SuppressWarnings("unchecked")
-    private IRubyObject mapToRawResult(final ThreadContext context, final Ruby runtime,
-            final DatabaseMetaData metaData, final ResultSet resultSet,
-            final boolean downCase) throws SQLException {
-
-        final ColumnData[] columns = extractColumns(runtime, metaData, resultSet, downCase);
-
-        final RubyArray results = runtime.newArray();
-        // [ { 'col1': 1, 'col2': 2 }, { 'col1': 3, 'col2': 4 } ]
-        populateFromResultSet(context, runtime, (List<IRubyObject>) results, resultSet, columns);
-        return results;
-    }
-
     private IRubyObject yieldResultRows(final ThreadContext context, final Ruby runtime,
             final Connection connection, final ResultSet resultSet,
             final Block block) throws SQLException {
@@ -3509,23 +2880,6 @@ public class RubyJdbcConnection extends RubyObject {
         return setupColumns(runtime, connection, resultSet.getMetaData(), downCase);
     }
 
-    @Deprecated
-    protected ColumnData[] extractColumns(final Ruby runtime,
-        final DatabaseMetaData metaData, final ResultSet resultSet,
-        final boolean downCase) throws SQLException {
-        return setupColumns(runtime, metaData, resultSet.getMetaData(), downCase);
-    }
-
-    /**
-     * @deprecated renamed and parameterized to {@link #withConnection(ThreadContext, boolean, Callable)}
-     */
-    @Deprecated
-    @SuppressWarnings("unchecked")
-    protected Object withConnectionAndRetry(final ThreadContext context, final SQLBlock block)
-        throws RaiseException {
-        return withConnection(context, block);
-    }
-
     protected <T> T withConnection(final ThreadContext context, final Callable<T> block)
         throws RaiseException {
         try {
@@ -3544,7 +2898,7 @@ public class RubyJdbcConnection extends RubyObject {
         do {
             if ( retry > 0 ) reconnect(context); // we're retrying running block
 
-            final Connection connection = getConnection(true);
+            final Connection connection = getConnection(context, true);
             boolean autoCommit = true; // retry in-case getAutoCommit throws
             try {
                 autoCommit = connection.getAutoCommit();
@@ -3607,15 +2961,6 @@ public class RubyJdbcConnection extends RubyObject {
         throw wrapException(context, exception);
     }
 
-    /**
-     * @deprecated use {@link #wrapException(ThreadContext, Throwable)} instead
-     * for overriding how exceptions are handled use {@link #handleException(ThreadContext, Throwable)}
-     */
-    @Deprecated
-    protected RuntimeException wrap(final ThreadContext context, final Throwable exception) {
-        return wrapException(context, exception);
-    }
-
     protected RaiseException wrapException(final ThreadContext context, final Throwable exception) {
         final Ruby runtime = context.getRuntime();
         if ( exception instanceof SQLException ) {
@@ -3703,63 +3048,19 @@ public class RubyJdbcConnection extends RubyObject {
         return end;
     }
 
-    /**
-     * JDBC connection helper that handles mapping results to
-     * <code>ActiveRecord::Result</code> (available since AR-3.1).
-     *
-     * @see #populateFromResultSet(ThreadContext, Ruby, List, ResultSet, RubyJdbcConnection.ColumnData[])
-     * @author kares
-     */
-    protected static class ResultHandler {
-
-        protected static Boolean USE_RESULT;
-
-        // AR-3.2 : initialize(columns, rows)
-        // AR-4.0 : initialize(columns, rows, column_types = {})
-        protected static Boolean INIT_COLUMN_TYPES = Boolean.FALSE;
+    // maps a AR::Result row
+    protected IRubyObject mapRow(final ThreadContext context, final Ruby runtime,
+                              final ColumnData[] columns, final ResultSet resultSet,
+                              final RubyJdbcConnection connection) throws SQLException {
+        final RubyArray row = runtime.newArray(columns.length);
 
-        protected static Boolean FORCE_HASH_ROWS = Boolean.FALSE;
-
-        private static volatile ResultHandler instance;
-
-        public static ResultHandler getInstance(final Ruby runtime) {
-            if ( instance == null ) {
-                synchronized(ResultHandler.class) {
-                    if ( instance == null ) { // fine to initialize twice
-                        setInstance( new ResultHandler(runtime) );
-                    }
-                }
-            }
-            return instance;
+        for (int i = 0; i < columns.length; i++) {
+            final ColumnData column = columns[i];
+            row.append(connection.jdbcToRuby(context, runtime, column.index, column.type, resultSet));
         }
 
-        protected static synchronized void setInstance(final ResultHandler instance) {
-            ResultHandler.instance = instance;
-        }
-
-        protected ResultHandler(final Ruby runtime) {
-            final RubyClass result = getResult(runtime);
-            USE_RESULT = result != null && result != runtime.getNilClass();
-        }
-
-        public IRubyObject mapRow(final ThreadContext context, final Ruby runtime,
-            final ColumnData[] columns, final ResultSet resultSet,
-            final RubyJdbcConnection connection) throws SQLException {
-
-            if ( USE_RESULT ) { // maps a AR::Result row
-                final RubyArray row = runtime.newArray(columns.length);
-
-                for ( int i = 0; i < columns.length; i++ ) {
-                    final ColumnData column = columns[i];
-                    row.append( connection.jdbcToRuby(context, runtime, column.index, column.type, resultSet) );
-                }
-
-                return row;
-            }
-            else {
-                return mapRawRow(context, runtime, columns, resultSet, connection);
-            }
-        }
+        return row;
+    }
 
         IRubyObject mapRawRow(final ThreadContext context, final Ruby runtime,
             final ColumnData[] columns, final ResultSet resultSet,
@@ -3777,37 +3078,20 @@ public class RubyJdbcConnection extends RubyObject {
             return row;
         }
 
-        public IRubyObject newResult(final ThreadContext context, final Ruby runtime,
-            final ColumnData[] columns, final IRubyObject rows) { // rows array
-            if ( USE_RESULT ) { // ActiveRecord::Result.new(columns, rows)
-                final RubyClass result = getResult(runtime);
-                return result.callMethod( context, "new", initArgs(runtime, columns, rows), Block.NULL_BLOCK );
-            }
-            return rows; // contains { 'col1' => 1, ... } Hash-es
-        }
-
-        private IRubyObject[] initArgs(final Ruby runtime,
-            final ColumnData[] columns, final IRubyObject rows) {
+    protected IRubyObject newResult(final ThreadContext context, ColumnData[] columns, IRubyObject rows) {
+        RubyClass result = ActiveRecord(context).getClass("Result");
 
-            final IRubyObject[] args;
+        return Helpers.invoke(context, result, "new", columnsToArray(context, columns), rows);
+    }
 
-            final RubyArray cols = RubyArray.newArray(runtime, columns.length);
+    private RubyArray columnsToArray(ThreadContext context, ColumnData[] columns) {
+        final RubyArray cols = RubyArray.newArray(context.runtime, columns.length);
 
-            if ( INIT_COLUMN_TYPES ) { // NOTE: NOT IMPLEMENTED
-                for ( int i = 0; i < columns.length; i++ ) {
-                    cols.append( columns[i].name );
-                }
-                args = new IRubyObject[] { cols, rows };
-            }
-            else {
-                for ( int i = 0; i < columns.length; i++ ) {
-                    cols.append( columns[i].name );
-                }
-                args = new IRubyObject[] { cols, rows };
-            }
-            return args;
+        for ( int i = 0; i < columns.length; i++ ) {
+            cols.append( columns[i].name );
         }
 
+        return cols;
     }
 
 
@@ -3876,14 +3160,8 @@ public class RubyJdbcConnection extends RubyObject {
         return new TableName(catalog, schema, name);
     }
 
-    /**
-     * @deprecated use {@link #extractTableName(Connection, String, String, String)}
-     */
-    @Deprecated
-    protected TableName extractTableName(
-            final Connection connection, final String schema,
-            final String tableName) throws IllegalArgumentException, SQLException {
-        return extractTableName(connection, null, schema, tableName);
+    protected IRubyObject valueForDatabase(final ThreadContext context, final IRubyObject attribute) {
+        return attribute.callMethod(context, "value_for_database");
     }
 
     protected static final class ColumnData {
@@ -3921,32 +3199,8 @@ public class RubyJdbcConnection extends RubyObject {
             } else {
                 name = caseConvertIdentifierForRails(connection, name);
             }
-            final RubyString columnName = RubyString.newUnicodeString(runtime, name);
-            final int columnType = resultMetaData.getColumnType(i);
-            columns[i - 1] = new ColumnData(columnName, columnType, i);
-        }
-
-        return columns;
-    }
-
-    @Deprecated
-    private ColumnData[] setupColumns(
-            final Ruby runtime,
-            final DatabaseMetaData metaData,
-            final ResultSetMetaData resultMetaData,
-            final boolean downCase) throws SQLException {
 
-        final int columnCount = resultMetaData.getColumnCount();
-        final ColumnData[] columns = new ColumnData[columnCount];
-
-        for ( int i = 1; i <= columnCount; i++ ) { // metadata is one-based
-            String name = resultMetaData.getColumnLabel(i);
-            if ( downCase ) {
-                name = name.toLowerCase();
-            } else {
-                name = caseConvertIdentifierForRails(metaData, name);
-            }
-            final RubyString columnName = RubyString.newUnicodeString(runtime, name);
+            final RubyString columnName = RubyString.newInternalFromJavaExternal(runtime, name);
             final int columnType = resultMetaData.getColumnType(i);
             columns[i - 1] = new ColumnData(columnName, columnType, i);
         }
@@ -3998,6 +3252,10 @@ public class RubyJdbcConnection extends RubyObject {
         }
     }
 
+    public static void debugMessage(final ThreadContext context, final IRubyObject item) {
+        debugMessage(context, item.callMethod(context, "inspect").asString().toString());
+    }
+
     protected static void debugErrorSQL(final ThreadContext context, final String sql) {
         if ( debug || ( context != null && context.runtime.isDebug() ) ) {
             final PrintStream out = context != null ? context.runtime.getOut() : System.out;