activerecord-jdbc-adapter 72.1-java → 81.0.pre1-java

data/lib/arjdbc/abstract/database_statements.rb

@@ -9,9 +9,18 @@ module ArJdbc
 
       NO_BINDS = [].freeze
 
-      def exec_insert(sql, name = nil, binds = NO_BINDS, pk = nil, sequence_name = nil, returning: nil)
-        sql = transform_query(sql)
+      def mark_transaction_written_if_write(sql)
+        if write_query?(sql)
+          ensure_writes_are_allowed(sql)
+          mark_transaction_written
+        end
+      end
 
+      def check_if_write_query(sql)
+        ensure_writes_are_allowed(sql) if write_query?(sql)
+      end
+
+      def exec_insert(sql, name = nil, binds = NO_BINDS, pk = nil, sequence_name = nil, returning: nil)
         if preventing_writes?
           raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
         end
@@ -34,8 +43,6 @@ module ArJdbc
       # It appears that at this point (AR 5.0) "prepare" should only ever be true
       # if prepared statements are enabled
       def internal_exec_query(sql, name = nil, binds = NO_BINDS, prepare: false, async: false, allow_retry: false, materialize_transactions: true)
-        sql = transform_query(sql)
-
         if preventing_writes? && write_query?(sql)
           raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
         end
@@ -58,8 +65,6 @@ module ArJdbc
       end
 
       def exec_update(sql, name = 'SQL', binds = NO_BINDS)
-        sql = transform_query(sql)
-
         if preventing_writes?
           raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
         end
@@ -86,13 +91,23 @@ module ArJdbc
 
       private
 
+      def without_prepared_statement?(binds)
+        !prepared_statements || binds.empty?
+      end
+
       def convert_legacy_binds_to_attributes(binds)
         binds.map do |column, value|
           ActiveRecord::Relation::QueryAttribute.new(nil, type_cast(value, column), ActiveModel::Type::Value.new)
         end
       end
 
-      def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
+      def preprocess_query(sql)
+        check_if_write_query(sql) if respond_to?(:check_if_write_query, true)
+        mark_transaction_written_if_write(sql) if respond_to?(:mark_transaction_written_if_write, true)
+        sql
+      end
+
+      def raw_execute(sql, name, binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true, batch: false)
         log(sql, name, async: async) do
           with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
             result = conn.execute(sql)

data/lib/arjdbc/mysql/adapter_hash_config.rb

@@ -61,8 +61,7 @@ module ArJdbc
 
       properties["connectionCollation"] ||= config[:collation] if config[:collation]
 
-      reconnect = config[:reconnect]
-      properties["autoReconnect"] ||= reconnect.to_s unless reconnect.nil?
+      properties["autoReconnect"] ||= reconnect.to_s unless config[:reconnect].nil?
 
       properties["noDatetimeStringSync"] = true unless properties.key?("noDatetimeStringSync")
 

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,7 +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)

data/lib/arjdbc/postgresql/schema_statements.rb

@@ -6,6 +6,23 @@ 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
+
+      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

@@ -223,17 +223,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")
+        raw_execute("PRAGMA defer_foreign_keys = ON", "SCHEMA", allow_retry: false, materialize_transactions: false)
+        raw_execute("PRAGMA foreign_keys = OFF", "SCHEMA", allow_retry: false, materialize_transactions: false)
         yield
       ensure
-        execute("PRAGMA defer_foreign_keys = #{old_defer_foreign_keys}")
-        execute("PRAGMA foreign_keys = #{old_foreign_keys}")
+        raw_execute("PRAGMA defer_foreign_keys = #{old_defer_foreign_keys}", "SCHEMA", allow_retry: false, materialize_transactions: false)
+        raw_execute("PRAGMA foreign_keys = #{old_foreign_keys}", "SCHEMA", allow_retry: false, materialize_transactions: false)
       end
     end
 
@@ -388,6 +400,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}"
 
@@ -441,12 +471,17 @@ module ArJdbc
 
       rowid = is_column_the_rowid?(field, definitions)
 
-      ActiveRecord::ConnectionAdapters::SQLite3Column.new(
-        field["name"],
+      column_args = [field["name"]]
+      column_args << lookup_cast_type(field["type"])
+      column_args.push(
         default_value,
         type_metadata,
         field["notnull"].to_i == 0,
-        default_function,
+        default_function
+      )
+
+      ActiveRecord::ConnectionAdapters::SQLite3Column.new(
+        *column_args,
         collation: field["collation"],
         auto_increment: field["auto_increment"],
         rowid: rowid,
@@ -579,7 +614,7 @@ module ArJdbc
             column_options[:stored] = column.virtual_stored?
             column_options[:type] = column.type
           elsif column.has_default?
-            type = lookup_cast_type_from_column(column)
+            type = column.fetch_cast_type(self)
             default = type.deserialize(column.default)
             default = -> { column.default_function } if default.nil?
 
@@ -791,7 +826,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_execute(stmt, "SCHEMA")
+          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
@@ -830,6 +875,10 @@ module ActiveRecord::ConnectionAdapters
       def jdbc_connection_class
         ::ActiveRecord::ConnectionAdapters::SQLite3JdbcConnection
       end
+
+      def native_database_types # :nodoc:
+        ArJdbc::SQLite3::NATIVE_DATABASE_TYPES
+      end
     end
 
     # NOTE: include these modules before all then override some methods with the
@@ -845,7 +894,7 @@ 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
 
 
     ##
@@ -954,7 +1003,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/column.rb

@@ -9,7 +9,7 @@ module ActiveRecord::ConnectionAdapters
       super
 
       @auto_increment = auto_increment
-      @default = nil if default =~ /NULL/
+      @default = nil if default.is_a?(String) && default.match?(/NULL/)
       @rowid = rowid
       @generated_type = generated_type
     end

data/lib/arjdbc/version.rb

@@ -1,3 +1,3 @@
 module ArJdbc
-  VERSION = '72.1'
+  VERSION = '81.0.pre1'
 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/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

@@ -52,7 +52,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)