activerecord-jdbc-alt-adapter 72.1.0-java → 80.1.0.beta1-java

data/lib/arjdbc/postgresql/adapter.rb

@@ -219,6 +219,10 @@ module ArJdbc
       true
     end
 
+    def supports_native_partitioning?
+      database_version >= 100_000
+    end
+
     def supports_insert_returning?
       true
     end
@@ -953,9 +957,6 @@ module ActiveRecord::ConnectionAdapters
     FEATURE_NOT_SUPPORTED = "0A000" # :nodoc:
 
     def execute_and_clear(sql, name, binds, prepare: false, async: false)
-      sql = transform_query(sql)
-      check_if_write_query(sql)
-
       if !prepare || without_prepared_statement?(binds)
         result = exec_no_cache(sql, name, binds, async: async)
       else
@@ -972,7 +973,6 @@ module ActiveRecord::ConnectionAdapters
 
     def exec_no_cache(sql, name, binds, async: false)
       materialize_transactions
-      mark_transaction_written_if_write(sql)
 
       # make sure we carry over any changes to ActiveRecord.default_timezone that have been
       # made since we established the connection
@@ -990,7 +990,6 @@ module ActiveRecord::ConnectionAdapters
 
     def exec_cache(sql, name, binds, async: false)
       materialize_transactions
-      mark_transaction_written_if_write(sql)
       update_typemap_for_default_timezone
 
       stmt_key = prepare_statement(sql, binds)

data/lib/arjdbc/postgresql/database_statements.rb

@@ -15,6 +15,51 @@ module ArJdbc
 
         "EXPLAIN (#{options.join(", ").upcase})"
       end
+
+      private
+
+      def internal_exec_query(sql, name = nil, binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true)
+          sql = preprocess_query(sql)
+
+        # puts "[1]internal----->sql: #{sql}, binds: #{binds}"
+        type_casted_binds = type_casted_binds(binds)
+        # puts "[2]internal----->sql: #{type_casted_binds.size}, binds: #{type_casted_binds}"
+
+        with_raw_connection do |conn|
+          if without_prepared_statement?(binds)
+            log(sql, name, async: async) { conn.execute_query(sql) }
+          else
+            log(sql, name, type_casted_binds, async: async) do
+              # this is different from normal AR that always caches
+              cached_statement = fetch_cached_statement(sql) if prepare && @jdbc_statement_cache_enabled
+              conn.execute_prepared_query(sql, type_casted_binds, cached_statement)
+            end
+          end
+        end
+      end
+
+      def perform_query(raw_connection, sql, binds, type_casted_binds, prepare:, notification_payload:, batch:)
+        result = raw_connection.execute(sql)
+
+        count = 0
+        count = result.count if result.respond_to?(:count)
+
+        verified!
+        notification_payload[:row_count] = count
+        result
+      end
+
+      def cast_result(raw_result)
+        return ActiveRecord::Result.empty if raw_result.nil?
+
+        fields = raw_result.fields
+
+        if fields.empty?
+          ActiveRecord::Result.empty
+        else
+          ActiveRecord::Result.new(fields, raw_result.values)
+        end
+      end
     end
   end
 end

data/lib/arjdbc/postgresql/schema_statements.rb

@@ -6,6 +6,30 @@ module ArJdbc
       ForeignKeyDefinition = ActiveRecord::ConnectionAdapters::ForeignKeyDefinition
       Utils = ActiveRecord::ConnectionAdapters::PostgreSQL::Utils
 
+      def decode_string_array(value)
+        return value if value.is_a?(Array)
+        _arjdbc_array_parser.parse_pg_array(value)
+      end
+
+      # Returns an array of the names of all schemas presently in the effective search path,
+      # in their priority order.
+      def current_schemas # :nodoc:
+        schemas = query_value("SELECT current_schemas(false)", "SCHEMA")
+        decode_string_array(schemas)
+      end
+
+      private
+
+      def _arjdbc_array_parser
+        @_arjdbc_array_parser ||= begin
+          obj = Object.new
+          obj.extend(ActiveRecord::ConnectionAdapters::PostgreSQL::ArrayParser)
+          obj
+        end
+      end
+
+      public
+
       def foreign_keys(table_name)
         scope = quoted_scope(table_name)
         fk_info = internal_exec_query(<<~SQL, "SCHEMA", allow_retry: true, materialize_transactions: false)

data/lib/arjdbc/sqlite3/adapter.rb

@@ -22,6 +22,8 @@ require "arjdbc/sqlite3/pragmas"
 
 require "arjdbc/abstract/relation_query_attribute_monkey_patch"
 
+require "arjdbc/sqlite3/database_statements"
+
 module SQLite3
   module Constants
     module Open
@@ -223,17 +225,29 @@ module ArJdbc
 
     # REFERENTIAL INTEGRITY ====================================
 
+    def execute_batch(statements, name = nil, **kwargs)
+      if statements.is_a?(Array)
+        # SQLite JDBC doesn't support multiple statements in one execute
+        # Execute each statement separately
+        statements.each do |sql|
+          raw_execute(sql, name, **kwargs.merge(batch: true))
+        end
+      else
+        raw_execute(statements, name, batch: true, **kwargs)
+      end
+    end
+
     def disable_referential_integrity # :nodoc:
       old_foreign_keys = query_value("PRAGMA foreign_keys")
       old_defer_foreign_keys = query_value("PRAGMA defer_foreign_keys")
 
       begin
-        execute("PRAGMA defer_foreign_keys = ON")
-        execute("PRAGMA foreign_keys = OFF")
+        execute("PRAGMA defer_foreign_keys = ON", "SCHEMA")
+        execute("PRAGMA foreign_keys = OFF", "SCHEMA")
         yield
       ensure
-        execute("PRAGMA defer_foreign_keys = #{old_defer_foreign_keys}")
-        execute("PRAGMA foreign_keys = #{old_foreign_keys}")
+        execute("PRAGMA defer_foreign_keys = #{old_defer_foreign_keys}", "SCHEMA")
+        execute("PRAGMA foreign_keys = #{old_foreign_keys}", "SCHEMA")
       end
     end
 
@@ -388,6 +402,24 @@ module ArJdbc
       end
     end
 
+    # Returns a list of defined virtual tables (for Rails 8 compatibility)
+    VIRTUAL_TABLE_REGEX = /USING\s+(\w+)(?:\s*\((.*)\))?/im
+    def virtual_tables
+      query = <<~SQL
+        SELECT name, sql FROM sqlite_master
+        WHERE type = 'table' AND sql LIKE 'CREATE VIRTUAL TABLE%';
+      SQL
+
+      exec_query(query, "SCHEMA").cast_values.each_with_object({}) do |(name, sql), memo|
+        match = sql.match(VIRTUAL_TABLE_REGEX)
+        next unless match
+
+        module_name = match[1]
+        arguments = match[2] || ""
+        memo[name] = [module_name, arguments.strip]
+      end.to_a
+    end
+
     def build_insert_sql(insert) # :nodoc:
       sql = +"INSERT #{insert.into} #{insert.values_list}"
 
@@ -791,7 +823,17 @@ module ArJdbc
       DEFAULT_PRAGMAS.merge(pragmas).each do |pragma, value|
         if ::SQLite3::Pragmas.respond_to?(pragma)
           stmt = ::SQLite3::Pragmas.public_send(pragma, value)
-          raw_execute(stmt, "SCHEMA")
+          # Skip pragma execution if we're inside a transaction and it's not allowed
+          begin
+            raw_connection.execute(stmt)
+          rescue => e
+            if e.message.include?("Safety level may not be changed inside a transaction")
+              # Log warning and skip this pragma
+              warn "Cannot set pragma '#{pragma}' inside a transaction, skipping"
+            else
+              raise
+            end
+          end
         else
           warn "Unknown SQLite pragma: #{pragma}"
         end
@@ -845,8 +887,9 @@ module ActiveRecord::ConnectionAdapters
     include ArJdbc::Abstract::ConnectionManagement
     include ArJdbc::Abstract::DatabaseStatements
     include ArJdbc::Abstract::StatementCache
-    include ArJdbc::Abstract::TransactionSupport
+    # Don't include TransactionSupport - use Rails' SQLite3::DatabaseStatements instead
 
+    include ::ArJdbc::SQLite3::DatabaseStatements
 
     ##
     # :singleton-method:
@@ -954,7 +997,8 @@ module ActiveRecord::ConnectionAdapters
 
     # because the JDBC driver doesn't like multiple SQL statements in one JDBC statement
     def combine_multi_statements(total_sql)
-      total_sql
+      # For Rails 8 compatibility - join multiple statements with semicolon
+      total_sql.is_a?(Array) ? total_sql.join(";\n") : total_sql
     end
 
     def type_map

data/lib/arjdbc/sqlite3/database_statements.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ArJdbc
+  module SQLite3
+    module DatabaseStatements
+      private
+
+      def perform_query(raw_connection, sql, binds, type_casted_binds, prepare:, notification_payload:, batch:)
+        result = raw_connection.execute(sql)
+
+        count = 0
+        count = result.count if result.respond_to?(:count)
+
+        verified!
+        notification_payload[:row_count] = count
+        result
+      end
+
+      def cast_result(raw_result)
+        return ActiveRecord::Result.empty if raw_result.nil?
+
+        raw_result
+      end
+    end
+  end
+end

data/lib/arjdbc/tasks/mssql_database_tasks.rb

@@ -4,7 +4,7 @@ require 'active_record/tasks/database_tasks'
 
 module ArJdbc
   module Tasks # :nodoc:
-    class MSSQLDatabaseTasks # :nodoc:
+    class MSSQLDatabaseTasks < ActiveRecord::Tasks::AbstractTasks # :nodoc:
       def self.using_database_configurations?
         true
       end
@@ -127,25 +127,5 @@ module ArJdbc
         msg
       end
     end
-
-    module DatabaseTasksMSSQL
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-
-      def check_protected_environments!
-        super
-      rescue ActiveRecord::JDBCError => e
-        case e.message
-        when /cannot open database .* requested by the login/i
-        else
-          raise
-        end
-      end
-
-      end
-    end
-
-    ActiveRecord::Tasks::DatabaseTasks.send(:include, DatabaseTasksMSSQL)
   end
 end

data/lib/arjdbc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ArJdbc
-  VERSION = "72.1.0"
+  VERSION = "80.1.0.beta1"
 end

data/pom.xml

@@ -12,7 +12,7 @@
   <url>http://github.com/jruby/activerecord-jdbc-adapter/wiki</url>
 
   <properties>
-    <jruby.version>9.2.6.0</jruby.version>
+    <jruby.version>10.0.0.1</jruby.version>
   </properties>
 
   <issueManagement>
@@ -103,8 +103,8 @@
         <artifactId>maven-compiler-plugin</artifactId>
         <version>2.5.1</version>
         <configuration>
-          <source>1.8</source>
-          <target>1.8</target>
+          <source>21</source>
+          <target>21</target>
         </configuration>
       </plugin>
     </plugins>

data/rakelib/02-test.rake

@@ -36,7 +36,7 @@ def test_task_for(adapter, options = {})
     test_task.libs = []
     if defined?(JRUBY_VERSION)
       test_task.libs << 'lib'
-      test_task.libs << "jdbc-#{driver}/lib" if driver && File.exists?("jdbc-#{driver}/lib")
+      test_task.libs << "jdbc-#{driver}/lib" if driver && File.exist?("jdbc-#{driver}/lib")
       test_task.libs.push *FileList["activerecord-jdbc#{adapter}*/lib"]
     end
     test_task.libs << 'test'

data/rakelib/db.rake

@@ -39,7 +39,7 @@ GRANT ALL PRIVILEGES ON `test\_%`.* TO #{MYSQL_CONFIG[:username]}@localhost;
   task :postgresql do
     require File.expand_path('../../test/shared_helper', __FILE__)
     fail 'could not create test database: psql executable not found' unless psql = which('psql')
-    fail 'could not create test database: missing "postgres" role' unless PostgresHelper.postgres_role?
+    fail 'could not create test database: missing "arjdbc" role' unless PostgresHelper.postgres_role?
 
     load 'test/db/postgres_config.rb' # rescue nil
     puts POSTGRES_CONFIG.inspect if $VERBOSE
@@ -53,11 +53,13 @@ CREATE DATABASE #{POSTGRES_CONFIG[:database]} OWNER #{POSTGRES_CONFIG[:username]
        ENCODING '#{POSTGRES_CONFIG[:encoding]}' LC_COLLATE '#{POSTGRES_CONFIG[:collate]}' LC_CTYPE '#{POSTGRES_CONFIG[:collate]}';
     SQL
 
-    params = { '-U' => ENV['PSQL_USER'] || 'postgres' }
+    params = { '-U' => ENV['PGUSER'] || 'arjdbc', '-d' => 'postgres' }
+    params['-h'] = ENV['PGHOST'] if ENV['PGHOST']
+    params['-p'] = ENV['PGPORT'] if ENV['PGPORT']
     params['-q'] = nil unless $VERBOSE
 
     puts "Creating PostgreSQL (test) database: #{POSTGRES_CONFIG[:database]}"
-    sh "cat #{script.path} | #{psql} #{params.to_a.join(' ')}", verbose: $VERBOSE
+    sh "PGPASSWORD=#{ENV['PGPASSWORD'] || 'arjdbc'} cat #{script.path} | #{psql} #{params.to_a.join(' ')}", verbose: $VERBOSE
   end
   task postgres: :postgresql
 

data/rakelib/rails.rake

@@ -58,7 +58,6 @@ namespace :rails do
       ruby_opts_string += " -C \"#{ar_path}\""
       ruby_opts_string += " -rbundler/setup"
       ruby_opts_string += " -rminitest -rminitest/excludes" unless ENV['NO_EXCLUDES'].eql?('true')
-      ruby_opts_string += " -rmonkey_patches"
       file_list = ENV["TEST"] ? FileList[ ENV["TEST"].split(',') ] : test_files_finder.call
       file_list_string = file_list.map { |fn| "\"#{fn}\"" }.join(' ')
       # test_loader_code = "-e \"ARGV.each{|f| require f}\"" # :direct

data/src/java/arjdbc/ArJdbcModule.java

@@ -43,6 +43,9 @@ import org.jruby.util.ByteList;
 
 import arjdbc.jdbc.RubyJdbcConnection;
 import static arjdbc.jdbc.RubyJdbcConnection.getJdbcConnection;
+import static org.jruby.api.Access.getModule;
+import static org.jruby.api.Access.objectClass;
+import static org.jruby.api.Create.allocArray;
 
 /**
  * ::ArJdbc
@@ -52,9 +55,10 @@ import static arjdbc.jdbc.RubyJdbcConnection.getJdbcConnection;
 public class ArJdbcModule {
 
     public static RubyModule load(final Ruby runtime) {
-        final RubyModule arJdbc = runtime.getOrCreateModule("ArJdbc");
-        arJdbc.defineAnnotatedMethods( ArJdbcModule.class );
-        return arJdbc;
+        var context = runtime.getCurrentContext();
+        return objectClass(context).
+                defineModuleUnder(context, "ArJdbc").
+                defineMethods(context, ArJdbcModule.class);
     }
 
     public static RubyModule get(final Ruby runtime) {
@@ -142,7 +146,7 @@ public class ArJdbcModule {
                 catch (NoSuchMethodException e) {
                     // "old" e.g. MySQLRubyJdbcConnection.createMySQLJdbcConnectionClass(runtime, jdbcConnection)
                     connection.getMethod("create" + moduleName + "JdbcConnectionClass", Ruby.class, RubyClass.class).
-                        invoke(null, runtime, getJdbcConnection(runtime));
+                        invoke(null, runtime, getJdbcConnection(context));
                 }
             }
         }
@@ -162,20 +166,19 @@ public class ArJdbcModule {
      */
     @JRubyMethod(name = "modules", meta = true)
     public static IRubyObject modules(final ThreadContext context, final IRubyObject self) {
-        final Ruby runtime = context.getRuntime();
         final RubyModule arJdbc = (RubyModule) self;
 
         final Collection<String> constants = arJdbc.getConstantNames();
-        final RubyArray modules = runtime.newArray( constants.size() );
+        final RubyArray modules = allocArray(context, constants.size());
 
         for ( final String name : constants ) {
-           final IRubyObject constant = arJdbc.getConstant(name, false);
+           final IRubyObject constant = arJdbc.getConstant(context, name, false);
            // isModule: return false for Ruby Classes
            if ( constant != null && constant.isModule() ) {
                if ( "Util".equals(name) ) continue;
                if ( "SerializedAttributesHelper".equals(name) ) continue; // deprecated
                if ( "Version".equals(name) ) continue; // deprecated
-               modules.append( constant );
+               modules.append(context, constant);
            }
         }
         return modules;
@@ -230,9 +233,9 @@ public class ArJdbcModule {
             return null;
         }
 
-        final RubyModule jdbc = runtime.getModule("Jdbc");
+        final RubyModule jdbc = getModule(context, "Jdbc");
         if ( jdbc != null ) { // Jdbc::MySQL
-            final RubyModule constant = (RubyModule) jdbc.getConstantAt(constName);
+            final RubyModule constant = jdbc.getModule(context, constName);
             if ( constant != null ) { // ::Jdbc::MySQL.load_driver :
                 if ( constant.respondsTo("load_driver") ) {
                     IRubyObject result = constant.callMethod("load_driver");

data/src/java/arjdbc/db2/DB2Module.java

@@ -26,6 +26,7 @@ package arjdbc.db2;
 import static arjdbc.util.QuotingUtils.BYTES_0;
 import static arjdbc.util.QuotingUtils.BYTES_1;
 import static arjdbc.util.QuotingUtils.quoteSingleQuotesWithFallback;
+import static org.jruby.api.Create.newString;
 
 import org.jruby.Ruby;
 import org.jruby.RubyModule;
@@ -42,9 +43,8 @@ import org.jruby.runtime.builtin.IRubyObject;
 public class DB2Module {
 
     public static RubyModule load(final RubyModule arJdbc) {
-        RubyModule db2 = arJdbc.defineModuleUnder("DB2");
-        db2.defineAnnotatedMethods( DB2Module.class );
-        return db2;
+        var context = arJdbc.getRuntime().getCurrentContext();
+        return arJdbc.defineModuleUnder(context, "DB2").defineMethods(context, DB2Module.class);
     }
 
     public static RubyModule load(final Ruby runtime) {
@@ -63,7 +63,7 @@ public class DB2Module {
     public static IRubyObject quoted_true(
             final ThreadContext context,
             final IRubyObject self) {
-        return RubyString.newString(context.runtime, BYTES_1);
+        return newString(context, BYTES_1);
     }
 
     @JRubyMethod(name = "quoted_false", required = 0, frame = false)

data/src/java/arjdbc/db2/DB2RubyJdbcConnection.java

@@ -54,17 +54,16 @@ public class DB2RubyJdbcConnection extends RubyJdbcConnection {
         super(runtime, metaClass);
     }
 
-    public static RubyClass createDB2JdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
-        RubyClass clazz = getConnectionAdapters(runtime).
-            defineClassUnder("DB2JdbcConnection", jdbcConnection, ALLOCATOR);
-        clazz.defineAnnotatedMethods(DB2RubyJdbcConnection.class);
-
-        return clazz;
+    public static RubyClass createDB2JdbcConnectionClass(ThreadContext context, RubyClass jdbcConnection) {
+        return getConnectionAdapters(context).
+                defineClassUnder(context, "DB2JdbcConnection", jdbcConnection, ALLOCATOR).
+                defineMethods(context, DB2RubyJdbcConnection.class);
     }
 
     public static RubyClass load(final Ruby runtime) {
-        RubyClass jdbcConnection = getJdbcConnection(runtime);
-        return createDB2JdbcConnectionClass(runtime, jdbcConnection);
+        var context = runtime.getCurrentContext();
+        RubyClass jdbcConnection = getJdbcConnection(context);
+        return createDB2JdbcConnectionClass(context, jdbcConnection);
     }
 
     protected static ObjectAllocator ALLOCATOR = new ObjectAllocator() {
@@ -112,7 +111,7 @@ public class DB2RubyJdbcConnection extends RubyJdbcConnection {
                 try {
                     statement = connection.prepareStatement("VALUES IDENTITY_VAL_LOCAL()");
                     genKeys = statement.executeQuery();
-                    return doMapGeneratedKeys(context.runtime, genKeys, true);
+                    return doMapGeneratedKeys(context, genKeys, true);
                 }
                 catch (final SQLException e) {
                     debugMessage(context.runtime, "failed to get generated keys: ", e);

data/src/java/arjdbc/h2/H2Module.java

@@ -37,7 +37,8 @@ import org.jruby.RubyModule;
 public class H2Module {
 
     public static RubyModule load(final RubyModule arJdbc) {
-        RubyModule h2 = arJdbc.defineModuleUnder("H2");
+        var context = arJdbc.getRuntime().getCurrentContext();
+        RubyModule h2 = arJdbc.defineModuleUnder(context, "H2");
         // NOTE: currently no Java implemented Ruby methods
         // h2.defineAnnotatedMethods( H2Module.class );
         return h2;

data/src/java/arjdbc/h2/H2RubyJdbcConnection.java

@@ -28,9 +28,11 @@ package arjdbc.h2;
 import java.sql.Connection;
 import java.sql.SQLException;
 
+import arjdbc.db2.DB2RubyJdbcConnection;
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
 
 /**
@@ -45,16 +47,15 @@ public class H2RubyJdbcConnection extends arjdbc.jdbc.RubyJdbcConnection {
         super(runtime, metaClass);
     }
 
-    public static RubyClass createH2JdbcConnectionClass(Ruby runtime, RubyClass jdbcConnection) {
-        RubyClass clazz = getConnectionAdapters(runtime).
-            defineClassUnder("H2JdbcConnection", jdbcConnection, ALLOCATOR);
-        clazz.defineAnnotatedMethods(H2RubyJdbcConnection.class);
-        return clazz;
+    public static RubyClass createH2JdbcConnectionClass(ThreadContext context, RubyClass jdbcConnection) {
+        return getConnectionAdapters(context).
+                defineClassUnder(context, "H2JdbcConnection", jdbcConnection, ALLOCATOR).
+                defineMethods(context, H2RubyJdbcConnection.class);
     }
 
     public static RubyClass load(final Ruby runtime) {
-        RubyClass jdbcConnection = getJdbcConnection(runtime);
-        return createH2JdbcConnectionClass(runtime, jdbcConnection);
+        var context = runtime.getCurrentContext();
+        return createH2JdbcConnectionClass(context, getJdbcConnection(context));
     }
 
     protected static ObjectAllocator ALLOCATOR = new ObjectAllocator() {

data/src/java/arjdbc/hsqldb/HSQLDBModule.java

@@ -28,10 +28,10 @@ package arjdbc.hsqldb;
 import static arjdbc.util.QuotingUtils.BYTES_0;
 import static arjdbc.util.QuotingUtils.BYTES_1;
 import static arjdbc.util.QuotingUtils.quoteSingleQuotesWithFallback;
+import static org.jruby.api.Create.newString;
 
 import org.jruby.Ruby;
 import org.jruby.RubyModule;
-import org.jruby.RubyString;
 import org.jruby.anno.JRubyMethod;
 import org.jruby.runtime.ThreadContext;
 import org.jruby.runtime.builtin.IRubyObject;
@@ -39,9 +39,8 @@ import org.jruby.runtime.builtin.IRubyObject;
 public class HSQLDBModule {
 
     public static RubyModule load(final RubyModule arJdbc) {
-        RubyModule hsqldb = arJdbc.defineModuleUnder("HSQLDB");
-        hsqldb.defineAnnotatedMethods( HSQLDBModule.class );
-        return hsqldb;
+        var context = arJdbc.getRuntime().getCurrentContext();
+        return arJdbc.defineModuleUnder(context, "HSQLDB").defineMethods(context, HSQLDBModule.class);
     }
 
     public static RubyModule load(final Ruby runtime) {
@@ -60,14 +59,14 @@ public class HSQLDBModule {
     public static IRubyObject quoted_true(
             final ThreadContext context,
             final IRubyObject self) {
-        return RubyString.newString(context.getRuntime(), BYTES_1);
+        return newString(context, BYTES_1);
     }
 
     @JRubyMethod(name = "quoted_false", required = 0, frame = false)
     public static IRubyObject quoted_false(
             final ThreadContext context,
             final IRubyObject self) {
-        return RubyString.newString(context.getRuntime(), BYTES_0);
+        return newString(context, BYTES_0);
     }
 
 }

data/src/java/arjdbc/jdbc/DataSourceConnectionFactory.java

@@ -36,6 +36,7 @@ import org.jruby.util.SafePropertyAccessor;
 
 import static arjdbc.jdbc.RubyJdbcConnection.getConnectionNotEstablished;
 import static arjdbc.jdbc.RubyJdbcConnection.wrapException;
+import static org.jruby.api.Access.runtimeErrorClass;
 
 /**
  *
@@ -103,7 +104,7 @@ final class DataSourceConnectionFactory implements ConnectionFactory {
             if ( ! ( bound instanceof DataSource ) ) {
                 if ( bound == null ) throw new NameNotFoundException(); // unlikely to happen
                 final String msg = "bound object at '" + name + "' is not a " + DataSource.class.getName() + " but a " + bound.getClass().getName() + "\n" + bound;
-                throw wrapException(context, getConnectionNotEstablished(context.runtime), new ClassCastException(msg), msg);
+                throw wrapException(context, getConnectionNotEstablished(context), new ClassCastException(msg), msg);
             }
             return (DataSource) bound;
         }
@@ -124,10 +125,10 @@ final class DataSourceConnectionFactory implements ConnectionFactory {
             else {
                 message = "unable to lookup data source - name: '" + name + "' not found";
             }
-            throw wrapException(context, getConnectionNotEstablished(context.runtime), e, message);
+            throw wrapException(context, getConnectionNotEstablished(context), e, message);
         }
         catch (NamingException e) {
-            throw wrapException(context, context.runtime.getRuntimeError(), e);
+            throw wrapException(context, runtimeErrorClass(context), e);
         }
     }
 

data/src/java/arjdbc/jdbc/DriverWrapper.java

@@ -23,6 +23,7 @@
  */
 package arjdbc.jdbc;
 
+import java.lang.reflect.InvocationTargetException;
 import java.sql.Connection;
 import java.sql.Driver;
 import java.sql.SQLException;
@@ -45,7 +46,7 @@ public class DriverWrapper {
     private final Properties properties;
 
     DriverWrapper(final Ruby runtime, final String name, final Properties properties)
-        throws ClassCastException, InstantiationException, IllegalAccessException {
+            throws ClassCastException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
         this.driver = allocateDriver( loadDriver(runtime, name) );
         this.properties = properties == null ? new Properties() : properties;
     }
@@ -59,18 +60,22 @@ public class DriverWrapper {
     }
 
     private Driver allocateDriver(final Class<? extends Driver> driverClass)
-        throws InstantiationException, IllegalAccessException {
-        return driverClass.newInstance();
+            throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
+        return driverClass.getDeclaredConstructor().newInstance();
     }
 
     protected static Class<? extends Driver> loadDriver(final Ruby runtime, final String name)
         throws ClassCastException {
-        @SuppressWarnings("unchecked")
-        Class<? extends Driver> klass = runtime.getJavaSupport().loadJavaClassVerbose(name);
-        if ( ! Driver.class.isAssignableFrom(klass) ) {
-            throw new ClassCastException(klass + " is not assignable from " + Driver.class);
+        try {
+            @SuppressWarnings("unchecked")
+            Class<? extends Driver> klass = (Class<? extends Driver>) runtime.getJavaSupport().loadJavaClass(name);
+            if ( ! Driver.class.isAssignableFrom(klass) ) {
+                throw new ClassCastException(klass + " is not assignable from " + Driver.class);
+            }
+            return klass;
+        } catch (ClassNotFoundException e) {
+            throw new RuntimeException("Cannot load driver class: " + name, e);
         }
-        return klass;
     }
 
     public Connection connect(final String url, final String user, final String pass)