activerecord-jdbc-adapter 70.2-java → 72.0-java

data/lib/arjdbc/sqlite3/adapter_hash_config.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module ArJdbc
+  module SQLite3Config
+    def build_connection_config(config)
+      config = config.deep_dup
+
+      load_jdbc_driver
+
+      config[:driver] ||= "org.sqlite.JDBC"
+
+      parse_sqlite3_config!(config)
+
+      database = config[:database]
+
+      # NOTE: "jdbc:sqlite::memory:" syntax is supported
+      config[:url] ||= "jdbc:sqlite:#{database == ':memory:' ? '' : database}"
+      config[:connection_alive_sql] ||= "SELECT 1"
+
+      config[:properties] = build_properties(config)
+
+      config
+    end
+
+    private
+
+    def load_jdbc_driver
+      require "jdbc/sqlite3"
+
+      ::Jdbc::SQLite3.load_driver(:require) if defined?(::Jdbc::SQLite3.load_driver)
+    rescue LoadError
+      # assuming driver.jar is on the class-path
+    end
+
+    def build_properties(config)
+      properties = config[:properties] || {}
+
+      if config[:readonly]
+        # See
+        # * http://sqlite.org/c3ref/open.html
+        # * http://sqlite.org/c3ref/c_open_autoproxy.html
+        # => 0x01 = readonly, 0x40 = uri (default in JDBC)
+        properties[:open_mode] =
+          ::SQLite3::Constants::Open::READONLY | ::SQLite3::Constants::Open::URI
+      end
+
+      if config[:flags]
+        properties[:open_mode] ||= 0
+        properties[:open_mode] |= config[:flags]
+
+        # JDBC driver has an extra flag for it
+        if config[:flags] & ::SQLite3::Constants::Open::SHAREDCACHE != 0
+          properties[:shared_cache] = true
+        end
+      end
+
+      timeout = config[:timeout]
+      if timeout && timeout.to_s !~ /\A\d+\Z/
+        raise ActiveRecord::StatementInvalid.new(
+          "TypeError: Timeout must be nil or a number (got: #{timeout}).",
+          connection_pool: ActiveRecord::ConnectionAdapters::NullPool.new
+        )
+      end
+
+      properties["busy_timeout"] ||= timeout unless timeout.nil?
+
+      properties
+    end
+
+    def parse_sqlite3_config!(config)
+      database = (config[:database] ||= config[:dbfile])
+
+      if database != ":memory:"
+        # make sure to have an absolute path. Ruby and Java don't agree
+        # on working directory
+        base_dir = defined?(Rails.root) ? Rails.root : nil
+        config[:database] = File.expand_path(database, base_dir)
+        dirname = File.dirname(config[:database])
+        Dir.mkdir(dirname) unless File.directory?(dirname)
+      end
+    rescue Errno::ENOENT => e
+      if e.message.include?("No such file or directory")
+        raise ActiveRecord::NoDatabaseError.new(
+          connection_pool: ActiveRecord::ConnectionAdapters::NullPool.new
+        )
+      end
+
+      raise
+    end
+  end
+end

data/lib/arjdbc/sqlite3/column.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module ActiveRecord::ConnectionAdapters
+  class SQLite3Column < JdbcColumn
+
+    attr_reader :rowid
+
+    def initialize(*, auto_increment: nil, rowid: false, generated_type: nil, **)
+      super
+
+      @auto_increment = auto_increment
+      @default = nil if default =~ /NULL/
+      @rowid = rowid
+      @generated_type = generated_type
+    end
+
+    def self.string_to_binary(value)
+      value
+    end
+
+    def self.binary_to_string(value)
+      if value.respond_to?(:encoding) && value.encoding != Encoding::ASCII_8BIT
+        value = value.force_encoding(Encoding::ASCII_8BIT)
+      end
+      value
+    end
+
+    # @override {ActiveRecord::ConnectionAdapters::JdbcColumn#default_value}
+    def default_value(value)
+      # JDBC returns column default strings with actual single quotes :
+      return $1 if value =~ /^'(.*)'$/
+
+      value
+    end
+
+    def auto_increment?
+      @auto_increment
+    end
+
+    def auto_incremented_by_db?
+      auto_increment? || rowid
+    end
+
+    def virtual?
+      !@generated_type.nil?
+    end
+
+    def virtual_stored?
+      virtual? && @generated_type == :stored
+    end
+
+    def has_default?
+      super && !virtual?
+    end
+
+    def init_with(coder)
+      @auto_increment = coder["auto_increment"]
+      super
+    end
+
+    def encode_with(coder)
+      coder["auto_increment"] = @auto_increment
+      super
+    end
+
+    def ==(other)
+      other.is_a?(Column) &&
+        super &&
+        auto_increment? == other.auto_increment?
+    end
+    alias :eql? :==
+
+    def hash
+      Column.hash ^
+        super.hash ^
+        auto_increment?.hash ^
+        rowid.hash
+    end
+
+    # @override {ActiveRecord::ConnectionAdapters::Column#type_cast}
+    def type_cast(value)
+      return nil if value.nil?
+      case type
+        when :string then value
+        when :primary_key
+          value.respond_to?(:to_i) ? value.to_i : ( value ? 1 : 0 )
+        when :float    then value.to_f
+        when :decimal  then self.class.value_to_decimal(value)
+        when :boolean  then self.class.value_to_boolean(value)
+        else super
+      end
+    end
+
+    private
+
+    # @override {ActiveRecord::ConnectionAdapters::Column#extract_limit}
+    def extract_limit(sql_type)
+      return nil if sql_type =~ /^(real)\(\d+/i
+      super
+    end
+
+    def extract_precision(sql_type)
+      case sql_type
+        when /^(real)\((\d+)(,\d+)?\)/i then $2.to_i
+        else super
+      end
+    end
+
+    def extract_scale(sql_type)
+      case sql_type
+        when /^(real)\((\d+)\)/i then 0
+        when /^(real)\((\d+)(,(\d+))\)/i then $4.to_i
+        else super
+      end
+    end
+  end
+end

data/lib/arjdbc/sqlite3/connection_methods.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 ArJdbc::ConnectionMethods.module_eval do
   def sqlite3_connection(config)
+    raise ArgumentError, 'Configuration must not be empty' if config.blank?
+    
     config = config.deep_dup
     config[:adapter_spec] ||= ::ArJdbc::SQLite3
     config[:adapter_class] = ActiveRecord::ConnectionAdapters::SQLite3Adapter unless config.key?(:adapter_class)
@@ -18,7 +20,7 @@ ArJdbc::ConnectionMethods.module_eval do
       parse_sqlite3_config!(config)
     rescue Errno::ENOENT => error
       if error.message.include?('No such file or directory')
-        raise ActiveRecord::NoDatabaseError
+        raise ActiveRecord::NoDatabaseError.new(connection_pool: ActiveRecord::ConnectionAdapters::NullPool.new)
       else
         raise
       end
@@ -50,7 +52,10 @@ ArJdbc::ConnectionMethods.module_eval do
 
     timeout = config[:timeout]
     if timeout && timeout.to_s !~ /\A\d+\Z/
-      raise TypeError.new "Timeout must be nil or a number (got: #{timeout})."
+      raise ActiveRecord::StatementInvalid.new(
+        "TypeError: Timeout must be nil or a number (got: #{timeout}).",
+        connection_pool: ActiveRecord::ConnectionAdapters::NullPool.new
+      )
     end
 
     options = config[:properties]

data/lib/arjdbc/sqlite3/pragmas.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module SQLite3
+  # defines methods to de generate pragma statements
+  module Pragmas
+    class << self
+      # The enumeration of valid synchronous modes.
+      SYNCHRONOUS_MODES = [["full", 2], ["normal", 1], ["off", 0]].freeze
+
+      # The enumeration of valid temp store modes.
+      TEMP_STORE_MODES = [["default", 0], ["file", 1], ["memory", 2]].freeze
+
+      # The enumeration of valid auto vacuum modes.
+      AUTO_VACUUM_MODES = [["none", 0], ["full", 1], ["incremental", 2]].freeze
+
+      # The list of valid journaling modes.
+      JOURNAL_MODES = [["delete"], ["truncate"], ["persist"], ["memory"], ["wal"], ["off"]].freeze
+
+      # The list of valid locking modes.
+      LOCKING_MODES = [["normal"], ["exclusive"]].freeze
+
+      # The list of valid encodings.
+      ENCODINGS = [["utf-8"], ["utf-16"], ["utf-16le"], ["utf-16be"]].freeze
+
+      # The list of valid WAL checkpoints.
+      WAL_CHECKPOINTS = [["passive"], ["full"], ["restart"], ["truncate"]].freeze
+
+      # Enforce foreign key constraints
+      # https://www.sqlite.org/pragma.html#pragma_foreign_keys
+      # https://www.sqlite.org/foreignkeys.html
+      def foreign_keys(value)
+        gen_boolean_pragma(:foreign_keys, value)
+      end
+
+      # Journal mode WAL allows for greater concurrency (many readers + one writer)
+      # https://www.sqlite.org/pragma.html#pragma_journal_mode
+      def journal_mode(value)
+        gen_enum_pragma(:journal_mode, value, JOURNAL_MODES)
+      end
+
+      # Set more relaxed level of database durability
+      # 2 = "FULL" (sync on every write), 1 = "NORMAL" (sync every 1000 written pages) and 0 = "NONE"
+      # https://www.sqlite.org/pragma.html#pragma_synchronous
+      def synchronous(value)
+        gen_enum_pragma(:synchronous, value, SYNCHRONOUS_MODES)
+      end
+
+      def temp_store(value)
+        gen_enum_pragma(:temp_store, value, TEMP_STORE_MODES)
+      end
+
+      # Set the global memory map so all processes can share some data
+      # https://www.sqlite.org/pragma.html#pragma_mmap_size
+      # https://www.sqlite.org/mmap.html
+      def mmap_size(value)
+        "PRAGMA mmap_size = #{value.to_i}"
+      end
+
+      # Impose a limit on the WAL file to prevent unlimited growth
+      # https://www.sqlite.org/pragma.html#pragma_journal_size_limit
+      def journal_size_limit(value)
+        "PRAGMA journal_size_limit = #{value.to_i}"
+      end
+
+      # Set the local connection cache to 2000 pages
+      # https://www.sqlite.org/pragma.html#pragma_cache_size
+      def cache_size(value)
+        "PRAGMA cache_size = #{value.to_i}"
+      end
+
+      private
+
+      def gen_boolean_pragma(name, mode)
+        case mode
+        when String
+          case mode.downcase
+          when "on", "yes", "true", "y", "t" then mode = "'ON'"
+          when "off", "no", "false", "n", "f" then mode = "'OFF'"
+          else
+            raise ActiveRecord::JDBCError, "unrecognized pragma parameter #{mode.inspect}"
+          end
+        when true, 1
+          mode = "ON"
+        when false, 0, nil
+          mode = "OFF"
+        else
+          raise ActiveRecord::JDBCError, "unrecognized pragma parameter #{mode.inspect}"
+        end
+
+        "PRAGMA #{name} = #{mode}"
+      end
+
+      def gen_enum_pragma(name, mode, enums)
+        match = enums.find { |p| p.find { |i| i.to_s.downcase == mode.to_s.downcase } }
+
+        unless match
+          # Unknown pragma value
+          raise ActiveRecord::JDBCError, "unrecognized #{name} #{mode.inspect}"
+        end
+
+        "PRAGMA #{name} = '#{match.first.upcase}'"
+      end
+    end
+  end
+end

data/lib/arjdbc/sqlite3.rb

@@ -1,3 +1,3 @@
 require 'arjdbc'
 require 'arjdbc/sqlite3/adapter'
-require 'arjdbc/sqlite3/connection_methods'
+# require 'arjdbc/sqlite3/connection_methods'

data/lib/arjdbc/version.rb

@@ -1,3 +1,3 @@
 module ArJdbc
-  VERSION = '70.2'
+  VERSION = '72.0'
 end

data/lib/arjdbc.rb

@@ -12,8 +12,20 @@ if defined?(JRUBY_VERSION)
   rescue LoadError => e
     warn "activerecord-jdbc-adapter failed to load railtie: #{e.inspect}"
   end if defined?(Rails) && ActiveRecord::VERSION::MAJOR >= 3
+
+  ActiveSupport.on_load(:active_record) do
+    ActiveRecord::ConnectionAdapters.register(
+      "sqlite3", "ActiveRecord::ConnectionAdapters::SQLite3Adapter", "arjdbc/sqlite3/adapter"
+    )
+    ActiveRecord::ConnectionAdapters.register(
+      "postgresql", "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter", "arjdbc/postgresql/adapter"
+    )
+    ActiveRecord::ConnectionAdapters.register(
+      "mysql2", "ActiveRecord::ConnectionAdapters::Mysql2Adapter", "arjdbc/mysql/adapter"
+    )
+  end
 else
   warn "activerecord-jdbc-adapter is for use with JRuby only"
 end
 
-require 'arjdbc/version'
+require 'arjdbc/version'

data/rakelib/02-test.rake

@@ -36,11 +36,11 @@ 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'
-    test_task.options = '--use-color=t'
+    test_task.options = '--use-color=t --progress-style=mark'
     test_task.verbose = true if $VERBOSE
     yield(test_task) if block_given?
   end

data/rakelib/rails.rake

@@ -34,6 +34,7 @@ namespace :rails do
           File.join(root_dir, 'lib'),
           File.join(root_dir, driver, 'lib'),
           File.join(root_dir, 'test/rails'),
+          File.join(root_dir, 'jdbc-sqlite3', 'lib'),  # Added for connection management tests which hardcode sqlite3
           ar_test_dir
       ]
 
@@ -51,6 +52,7 @@ 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/jdbc/RubyJdbcConnection.java

@@ -126,6 +126,7 @@ public class RubyJdbcConnection extends RubyObject {
     private IRubyObject adapter; // the AbstractAdapter instance we belong to
     private volatile boolean connected = true;
     private RubyClass attributeClass;
+    private RubyClass timeZoneClass;
 
     private boolean lazy = false; // final once set on initialize
     private boolean jndi; // final once set on initialize
@@ -135,6 +136,7 @@ public class RubyJdbcConnection extends RubyObject {
     protected RubyJdbcConnection(Ruby runtime, RubyClass metaClass) {
         super(runtime, metaClass);
         attributeClass = runtime.getModule("ActiveModel").getClass("Attribute");
+        timeZoneClass = runtime.getModule("ActiveSupport").getClass("TimeWithZone");
     }
 
     private static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
@@ -793,7 +795,8 @@ public class RubyJdbcConnection extends RubyObject {
                         // Unfortunately the result set gets closed when getMoreResults()
                         // is called, so we have to process the result sets as we get them
                         // this shouldn't be an issue in most cases since we're only getting 1 result set anyways
-                        result = mapExecuteResult(context, connection, resultSet);
+                        //result = mapExecuteResult(context, connection, resultSet);
+                        result = mapToRawResult(context, connection, resultSet, false);
                         resultSet.close();
                     } else {
                         result = context.runtime.newFixnum(updateCount);
@@ -2440,6 +2443,9 @@ public class RubyJdbcConnection extends RubyObject {
         if (attributeClass.isInstance(attribute)) {
             type = jdbcTypeForAttribute(context, attribute);
             value = valueForDatabase(context, attribute);
+        } else if (timeZoneClass.isInstance(attribute)) {
+            type = jdbcTypeFor("timestamp");
+            value = attribute;
         } else {
             type = jdbcTypeForPrimitiveAttribute(context, attribute);
             value = attribute;
@@ -2726,8 +2732,9 @@ public class RubyJdbcConnection extends RubyObject {
             statement.setDouble(index, ((RubyNumeric) value).getDoubleValue());
         }
         else { // e.g. `BigDecimal '42.00000000000000000001'`
+            Ruby runtime = context.runtime;
             statement.setBigDecimal(index,
-                    RubyBigDecimal.newInstance(context, context.runtime.getModule("BigDecimal"), value, RubyFixnum.newFixnum(context.runtime, Integer.MAX_VALUE)).getValue());
+                    RubyBigDecimal.newInstance(context, runtime.getModule("BigDecimal"), value, RubyFixnum.zero(runtime)).getValue());
         }
     }
 

data/src/java/arjdbc/mysql/MySQLRubyJdbcConnection.java

@@ -74,11 +74,7 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
         return createMySQLJdbcConnectionClass(runtime, jdbcConnection);
     }
 
-    protected static final ObjectAllocator ALLOCATOR = new ObjectAllocator() {
-        public IRubyObject allocate(Ruby runtime, RubyClass klass) {
-            return new MySQLRubyJdbcConnection(runtime, klass);
-        }
-    };
+    protected static final ObjectAllocator ALLOCATOR = MySQLRubyJdbcConnection::new;
 
     @JRubyMethod
     public IRubyObject query(final ThreadContext context, final IRubyObject sql) throws SQLException {
@@ -119,6 +115,17 @@ public class MySQLRubyJdbcConnection extends RubyJdbcConnection {
         return driverWrapper;
     }
 
+    @JRubyMethod(name = "ping")
+    public RubyBoolean db_ping(final ThreadContext context) {
+        final Connection connection = getConnection(true);
+        if (connection == null) return context.fals;
+
+        // NOTE: It seems only `connection.isValid(aliveTimeout)` is needed
+        // for JDBC 4.0 and up. https://jira.mariadb.org/browse/CONJ-51
+
+        return context.runtime.newBoolean(isConnectionValid(context, connection));
+    }
+
     private static transient Class MYSQL_CONNECTION;
     private static transient Boolean MYSQL_CONNECTION_FOUND;
 

data/src/java/arjdbc/sqlite3/SQLite3RubyJdbcConnection.java

@@ -473,7 +473,10 @@ public class SQLite3RubyJdbcConnection extends RubyJdbcConnection {
         // Assume we will only call this with an array.
         final RubyArray statements = (RubyArray) statementsArg;
         return withConnection(context, connection -> {
+            final Ruby runtime = context.runtime;
+
             Statement statement = null;
+
             try {
                 statement = createStatement(context, connection);
 
@@ -481,8 +484,15 @@ public class SQLite3RubyJdbcConnection extends RubyJdbcConnection {
                 for (int i = 0; i < length; i++) {
                     statement.addBatch(sqlString(statements.eltOk(i)));
                 }
-                statement.executeBatch();
-                return context.nil;
+
+                int[] rows = statement.executeBatch();
+
+                RubyArray rowsAffected = runtime.newArray();
+
+                for (int i = 0; i < rows.length; i++) {
+                    rowsAffected.append(runtime.newFixnum(rows[i]));
+                }
+                return rowsAffected;
             } catch (final SQLException e) {
                 // Generate list semicolon list of statements which should match AR error formatting more.
                 debugErrorSQL(context, sqlString(statements.join(context, context.runtime.newString(";\n"))));
@@ -511,7 +521,8 @@ public class SQLite3RubyJdbcConnection extends RubyJdbcConnection {
             statement.setDouble(index, ((RubyNumeric) value).getDoubleValue());
         }
         else { // e.g. `BigDecimal '42.00000000000000000001'`
-            RubyBigDecimal val = RubyBigDecimal.newInstance(context, context.runtime.getModule("BigDecimal"), value, RubyFixnum.newFixnum(context.runtime, Integer.MAX_VALUE));
+            Ruby runtime = context.runtime;
+            RubyBigDecimal val = RubyBigDecimal.newInstance(context, runtime.getModule("BigDecimal"), value, RubyFixnum.zero(runtime));
             statement.setString(index, val.getValue().toString());
         }
     }

metadata

@@ -1,32 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbc-adapter
 version: !ruby/object:Gem::Version
-  version: '70.2'
+  version: '72.0'
 platform: java
 authors:
 - Nick Sieger, Ola Bini, Karol Bucek and JRuby contributors
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-09 00:00:00.000000000 Z
+date: 2025-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.0'
-  name: activerecord
+        version: 7.2.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: 7.2.2
 description: 'AR-JDBC is a database adapter for Rails'' ActiveRecord component designed
   to be used with JRuby built upon Java''s JDBC API for database access. Provides
-  (ActiveRecord) built-in adapters: MySQL,  PostgreSQL, SQLite3, and SQLServer.'
+  (ActiveRecord) built-in adapters: MySQL,  PostgreSQL, and SQLite3.'
 email:
 - nick@nicksieger.com
 - ola.bini@gmail.com
@@ -69,6 +68,7 @@ files:
 - lib/arjdbc/abstract/connection_management.rb
 - lib/arjdbc/abstract/core.rb
 - lib/arjdbc/abstract/database_statements.rb
+- lib/arjdbc/abstract/relation_query_attribute_monkey_patch.rb
 - lib/arjdbc/abstract/statement_cache.rb
 - lib/arjdbc/abstract/transaction_support.rb
 - lib/arjdbc/discover.rb
@@ -85,7 +85,6 @@ files:
 - lib/arjdbc/jdbc/adapter.rb
 - lib/arjdbc/jdbc/adapter_java.jar
 - lib/arjdbc/jdbc/adapter_require.rb
-- lib/arjdbc/jdbc/base_ext.rb
 - lib/arjdbc/jdbc/callbacks.rb
 - lib/arjdbc/jdbc/column.rb
 - lib/arjdbc/jdbc/connection.rb
@@ -100,22 +99,29 @@ files:
 - lib/arjdbc/jdbc/type_converter.rb
 - lib/arjdbc/mysql.rb
 - lib/arjdbc/mysql/adapter.rb
+- lib/arjdbc/mysql/adapter_hash_config.rb
 - lib/arjdbc/mysql/connection_methods.rb
 - lib/arjdbc/oracle/adapter.rb
 - lib/arjdbc/postgresql.rb
 - lib/arjdbc/postgresql/adapter.rb
+- lib/arjdbc/postgresql/adapter_hash_config.rb
 - lib/arjdbc/postgresql/base/array_decoder.rb
 - lib/arjdbc/postgresql/base/array_encoder.rb
 - lib/arjdbc/postgresql/base/array_parser.rb
 - lib/arjdbc/postgresql/base/pgconn.rb
 - lib/arjdbc/postgresql/column.rb
 - lib/arjdbc/postgresql/connection_methods.rb
+- lib/arjdbc/postgresql/database_statements.rb
 - lib/arjdbc/postgresql/name.rb
 - lib/arjdbc/postgresql/oid_types.rb
+- lib/arjdbc/postgresql/schema_statements.rb
 - lib/arjdbc/railtie.rb
 - lib/arjdbc/sqlite3.rb
 - lib/arjdbc/sqlite3/adapter.rb
+- lib/arjdbc/sqlite3/adapter_hash_config.rb
+- lib/arjdbc/sqlite3/column.rb
 - lib/arjdbc/sqlite3/connection_methods.rb
+- lib/arjdbc/sqlite3/pragmas.rb
 - lib/arjdbc/tasks.rb
 - lib/arjdbc/tasks/database_tasks.rb
 - lib/arjdbc/tasks/databases.rake
@@ -181,7 +187,6 @@ homepage: https://github.com/jruby/activerecord-jdbc-adapter
 licenses:
 - BSD-2-Clause
 metadata: {}
-post_install_message:
 rdoc_options:
 - "--main"
 - README.md
@@ -198,8 +203,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: JDBC adapter for ActiveRecord, for use within JRuby on Rails.
 test_files: []

data/lib/arjdbc/jdbc/base_ext.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecord
-  class << Base
-    m = Module.new do
-      # Allow adapters to provide their own {#reset_column_information} method.
-      # @note This only affects the current thread's connection.
-      def reset_column_information # :nodoc:
-        # invoke the adapter-specific reset_column_information method
-        connection.reset_column_information if connection.respond_to?(:reset_column_information)
-        super
-      end
-    end
-
-    self.prepend(m)
-  end
-end