activerecord-jdbc-adapter 70.1-java → 71.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '095c3d28051b253315cdd1bec95a83683f3240b0f3315cfb8f9c3c4c0d124f41'
-  data.tar.gz: 13b5d48e4c1b0b16811da5a361cfd9bb687727b5bbad2f5b750540b0232408ee
+  metadata.gz: 4450a117ffce0ffee520932ab4872346aa4c7192f36ebea911db380b9d5cca89
+  data.tar.gz: ec27e839eee02e6c3cbaba4d2a48fc46375c11b7de2f1a420d89ea4574152ef4
 SHA512:
-  metadata.gz: bc4801f970c8651e0ce8076b6544bf56d0e4decd77a9463439a8d5692f767aab896786680197c25b52d510465837290604970689b1b6cba26708385038f1fa39
-  data.tar.gz: 47e1df847914baefffadb80537b1ffd9dfcb218b2f5bfd26addefad934be7b31a0ade446c5838bea88b81897c34b13a7cef8e6b840540e89f4627f950949549c
+  metadata.gz: bc36b55927d27830d0ae0e6c424e799ccb4f34c44765fbc42b90ba49071b080ebf025adfa3568d254e75e8b137f5fc7c00b2d9004bcd0d412831eb5eebfb03ca
+  data.tar.gz: fdcac70debef8aba9131e875d05578d3308a34222d06738e7eca008ea51f7b89b0ee05a360f7273d9ebc2a70a62d3b753e70ad0c99e5707fb97ae81dffb2529e

data/.github/workflows/ruby.yml

@@ -27,7 +27,7 @@ jobs:
         ruby-version: ['jruby-head']
         db: ['mysql2']
         test_targets: ["rails:test_mysql2"]
-        ar_version: ["7-0-stable"]
+        ar_version: ["7-1-stable"]
         prepared_statements: ['false', 'true']
         driver: ['MySQL']
 
@@ -42,10 +42,10 @@ jobs:
       AR_VERSION: ${{ matrix.ar_version }}
       PREPARED_STATEMENTS: ${{ matrix.prepared_statements }}
       DRIVER: ${{ matrix.driver }}
-      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M"
+      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M --dev"
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
@@ -79,12 +79,12 @@ jobs:
         ruby-version: [ 'jruby-head' ]
         db: [ 'postgresql' ]
         test_targets: [ "rails:test_postgresql" ]
-        ar_version: ["7-0-stable"]
+        ar_version: ["7-1-stable"]
         prepared_statements: [ 'false', 'true' ]
 
     services:
       postgres:
-        image: postgres:10
+        image: postgres:11
         env:
           POSTGRES_PASSWORD: postgres
           POSTGRES_HOST_AUTH_METHOD: trust
@@ -95,14 +95,14 @@ jobs:
     env:
       DB: ${{ matrix.db }}
       AR_VERSION: ${{ matrix.ar_version }}
-      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M"
+      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M --dev"
       PREPARED_STATEMENTS: ${{ matrix.prepared_statements }}
       PGHOST: localhost
       PGPORT: 5432
       PGUSER: postgres
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
@@ -129,15 +129,15 @@ jobs:
         ruby-version: ['jruby-head']
         db: ['sqlite3']
         test_targets: ["rails:test_sqlite3"]
-        ar_version: ["7-0-stable"]
+        ar_version: ["7-1-stable"]
 
     env:
       DB: ${{ matrix.db }}
       AR_VERSION: ${{ matrix.ar_version }}
-      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M"
+      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M --dev"
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
@@ -149,7 +149,7 @@ jobs:
           rake jar # compiles ext generates: lib/arjdbc/jdbc/adapter_java.jar
       - name: Run tests
         run: |
-          bundle exec rake ${{ matrix.test_targets }}
+          bundle exec rake ${{ matrix.test_targets }} --trace
 
   test-arjdbc-mysql:
 
@@ -173,13 +173,13 @@ jobs:
     env:
       DB: ${{ matrix.db }}
       DRIVER: ${{ matrix.driver }}
-      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M"
+      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M --dev"
       MY_USER: root
       MY_PASSWORD: root
       PREPARED_STATEMENTS: ${{ matrix.prepared_statements }}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
@@ -211,7 +211,7 @@ jobs:
 
     services:
       postgres:
-        image: postgres:10
+        image: postgres:11
         env:
           POSTGRES_PASSWORD: postgres
           POSTGRES_HOST_AUTH_METHOD: trust
@@ -222,7 +222,7 @@ jobs:
     env:
       DB: ${{ matrix.db }}
       DRIVER: ${{ matrix.driver }}
-      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M"
+      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M --dev"
       PREPARED_STATEMENTS: ${{ matrix.prepared_statements }}
       INSERT_RETURNING: ${{ matrix.insert_returning }}
       PGHOST: localhost
@@ -230,7 +230,7 @@ jobs:
       PGUSER: postgres
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
@@ -256,10 +256,10 @@ jobs:
 
     env:
       DB: ${{ matrix.db }}
-      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M"
+      JRUBY_OPTS: "-J-Xms64M -J-Xmx1024M --dev"
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:

data/.gitignore

@@ -15,9 +15,12 @@ coverage
 build.xml
 nbproject
 .classpath
+.ruby-version
 .project
 *.sqlite
 *.sqlite3
+*.sqlite3-shm
+*.sqlite3-wal
 *.derby
 derby.log
 test.hsqldb*
@@ -32,3 +35,8 @@ Gemfile.lock
 .settings
 activerecord-jdbc.iml
 lib/arjdbc/jdbc/adapter_java.jar
+.jrubyrc
+.rubocop.yml
+.solargraph.yml
+pik.sh
+.tool-versions

data/Gemfile

@@ -41,10 +41,17 @@ elsif ENV['AR_VERSION'] # Use specific version of AR and not .gemspec version
         gem 'actionpack', require: false
         gem 'actionview', require: false
       end
+      
     end
   end
 else
-  gemspec name: 'activerecord-jdbc-adapter' # Use versiom from .gemspec
+  if defined? JRUBY_VERSION
+    gemspec name: 'activerecord-jdbc-adapter' # Use versiom from .gemspec
+  else # read add_dependency 'activerecord', '~> 7.0' and use the same requirement on MRI
+    ar_req = File.read('activerecord-jdbc-adapter.gemspec').match(/add_dependency.*?activerecord.*['"](.*?)['"]/)[1]
+    raise "add_dependency 'activerecord', ... line not detected in gemspec" unless ar_req
+    gem 'activerecord', ar_req
+  end
 end
 
 gem 'rake', require: nil
@@ -59,7 +66,7 @@ end
 
 group :rails do
   group :test do
-    gem 'minitest', require: nil
+    gem 'minitest', '~> 5.24.0', require: nil
     gem 'minitest-excludes', require: nil
     gem 'minitest-rg', require: nil
 
@@ -70,6 +77,10 @@ group :rails do
   gem 'builder', require: nil
 
   gem 'erubis', require: nil # "~> 2.7.0"
+
+  # Due to rails/activesupport/lib/active_support/message_pack.rb
+  gem 'msgpack', '>= 1.7.0', require: false
+
   # NOTE: due rails/activerecord/test/cases/connection_management_test.rb
   gem 'rack', require: nil
 
@@ -77,7 +88,7 @@ group :rails do
 end
 
 group :development do
-  gem 'ruby-debug', require: nil # if ENV['DEBUG']
+  #gem 'ruby-debug', require: nil # if ENV['DEBUG']
   group :doc do
     gem 'yard', require: nil
     gem 'kramdown', require: nil
@@ -92,10 +103,12 @@ group :test do
 
   gem 'mysql2', '>= 0.4.4', require: nil, platform: :mri
   gem 'pg', '>= 0.18.0', require: nil, platform: :mri
-  gem 'sqlite3', '~> 1.3.6', require: nil, platform: :mri
+  gem 'sqlite3', '~> 1.4', require: nil, platform: :mri
 
   # group :mssql do
   #   gem 'tiny_tds', require: nil, platform: :mri
   #   gem 'activerecord-sqlserver-adapter', require: nil, platform: :mri
   # end
 end
+
+gem 'pry-nav'

data/README.md

@@ -24,10 +24,15 @@ Versions are targeted at certain versions of Rails and live on their own branche
 | 51.x        | 5.1.x         | 51-stable | 9.1.x     | 7        |
 | 52.x        | 5.2.x         | 52-stable | 9.1.x     | 7        |
 | 60.x        | 6.0.x         | 60-stable | 9.2.7     | 8        |
-| 61.x        | 6.1.x         | master    | 9.2.7     | 8        |
+| 61.x        | 6.1.x         | 61-stable | 9.2.7     | 8        |
+| 70.x        | 7.0.x         | 70-stable | 9.3.0     | 8        |
+| 71.x        | 7.1.x         | 71-stable | 9.4.3     | 8        |
+| 72.x        | 7.2.x         | master    | 9.4.3     | 8        |
 
-Note that JRuby 9.1.x is end-of-life. We recommend Java 8 at a minimum for all
-versions.
+Note: 72.x is still under development and not supported yet.
+
+Note that JRuby 9.1.x and JRuby 9.2.x are at end-of-life. We recommend Java 8
+at a minimum for all versions.
 
 ## Using ActiveRecord JDBC
 

data/RUNNING_TESTS.md

@@ -16,6 +16,8 @@ Rake tasks are loaded from **rakelib/02-test-rake**, most adapters have a
 corresponding test_[adapter] task e.g. `rake test_sqlite3` that run against DB.
 To check all available (test related) tasks simply `rake -T | grep test`.
 
+### Database Setup
+
 If the adapter supports creating a database it will try to do so automatically
 (most embed databases such as SQLite3) for some adapters (MySQL, PostgreSQL) we
 do this auto-magically (see the `rake db:create` tasks), but otherwise you'll
@@ -48,6 +50,40 @@ but one can easily run tests with prepared statements disabled using env vars :
 
     rake test_derby PREPARED_STATEMENTS=false
 
+#### MySQL with Docker
+
+The standard Docker MySQL image can be used for testing and development. Depending on your environment these commands
+may need to be run as root.
+
+Pull the image:
+
+```
+sudo docker pull mysql
+```
+
+Start up the database with a root password (we show a simple one here but pick one no one else knows):
+
+```
+docker run -p 3306:3306 --name mysql -e MYSQL_ROOT_PASSWORD=testtest9 -d mysql
+```
+
+The `mysql` client can be run through Docker as well:
+
+```sh
+docker run -it --link mysql:mysql --rm mysql sh -c 'exec mysql -h"$MYSQL_PORT_3306_TCP_ADDR" -P"$MYSQL_PORT_3306_TCP_PORT" -uroot -p"$MYSQL_ENV_MYSQL_ROOT_PASSWORD"'
+```
+
+Set up the database for the unit tests (you may need to replace 'localhost' with your container's IP):
+
+```sql
+CREATE USER 'rails'@'localhost' IDENTIFIED BY 'testtest9';
+CREATE DATABASE activerecord_unittest;
+GRANT ALL PRIVILEGES ON activerecord_unittest.* TO 'rails'@'localhost';
+CREATE DATABASE activerecord_unittest2;
+GRANT ALL PRIVILEGES ON activerecord_unittest2.* TO 'rails'@'localhost';
+```
+
+Then edit test/rails/config.yml for the appropriate configuration credentials.
 
 ### ActiveRecord (Rails) Tests
 

data/activerecord-jdbc-adapter.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |gem|
     "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."
+    "PostgreSQL, and SQLite3."
 
   gem.require_paths = ["lib"]
 
@@ -41,7 +41,7 @@ Gem::Specification.new do |gem|
   gem.executables = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files = gem.files.grep(%r{^test/})
 
-  gem.add_dependency 'activerecord', '~> 7.0'
+  gem.add_dependency 'activerecord', '~> 7.1.3'
 
   #gem.add_development_dependency 'test-unit', '2.5.4'
   #gem.add_development_dependency 'test-unit-context', '>= 0.3.0'

data/lib/arjdbc/abstract/connection_management.rb

@@ -6,29 +6,28 @@ module ArJdbc
 
       # @override
       def active?
-        return unless @connection
-        @connection.active?
+        @raw_connection&.active?
       end
 
       def really_valid?
-        return unless @connection
-        @connection.really_valid?
+        @raw_connection&.really_valid?
       end
 
       # @override
-      def reconnect!
-        super # clear_cache! && reset_transaction
-        @connection.reconnect! # handles adapter.configure_connection
-      end
+      # Removed to fix sqlite adapter, may be needed for others
+      # def reconnect!
+      #   super # clear_cache! && reset_transaction
+      #   @connection.reconnect! # handles adapter.configure_connection
+      # end
 
       # @override
       def disconnect!
         super # clear_cache! && reset_transaction
-        return unless @connection
-        @connection.disconnect!
+        @raw_connection&.disconnect!
       end
 
       # @override
+      # Removed to fix sqlite adapter, may be needed for others
       # def verify!(*ignored)
       #  if @connection && @connection.jndi?
       #    # checkout call-back does #reconnect!
@@ -37,6 +36,22 @@ module ArJdbc
       #  end
       # end
 
+      private
+
+      # DIFFERENCE: we delve into jdbc shared code and this does self.class.new_client.
+      def connect
+        @raw_connection = self.class.new_client(@connection_parameters, self)
+      rescue ActiveRecord::ConnectionNotEstablished => ex
+        raise ex.set_pool(@pool)
+      end
+
+      def reconnect
+        @raw_connection&.close
+
+        @raw_connection = nil
+
+        connect
+      end
     end
   end
 end

data/lib/arjdbc/abstract/core.rb

@@ -2,27 +2,17 @@
 
 module ArJdbc
   module Abstract
-
     # This is minimum amount of code needed from base JDBC Adapter class to make common adapters
     # work.  This replaces using jdbc/adapter as a base class for all adapters.
     module Core
-
-      attr_reader :config
-
-      def initialize(connection, logger = nil, config = {})
-        @config = config
+      def initialize(...)
+        super
 
         if self.class.equal? ActiveRecord::ConnectionAdapters::JdbcAdapter
           spec = @config.key?(:adapter_spec) ? @config[:adapter_spec] :
                      ( @config[:adapter_spec] = adapter_spec(@config) ) # due resolving visitor
           extend spec if spec
         end
-
-        connection ||= jdbc_connection_class(config[:adapter_spec]).new(config, self)
-
-        super(connection, logger, config) # AbstractAdapter
-
-        connection.configure_connection # will call us (maybe)
       end
 
       # Retrieve the raw `java.sql.Connection` object.
@@ -56,6 +46,9 @@ module ArJdbc
         # swallow an ArJdbc / driver bug into an AR::StatementInvalid !
         return exception if exception.is_a?(Throwable)
 
+        # We create this exception in Java where we do not have access to the pool
+        exception.instance_variable_set(:@connection_pool, @pool) if exception.kind_of?(::ActiveRecord::JDBCError)
+
         case exception
           when SystemExit, SignalException, NoMemoryError then exception
           when ActiveModel::RangeError, TypeError, RuntimeError then exception

data/lib/arjdbc/abstract/database_statements.rb

@@ -9,85 +9,75 @@ module ArJdbc
 
       NO_BINDS = [].freeze
 
-      def exec_insert(sql, name = nil, binds = NO_BINDS, pk = nil, sequence_name = nil)
+      def exec_insert(sql, name = nil, binds = NO_BINDS, pk = nil, sequence_name = nil, returning: nil)
         sql = transform_query(sql)
 
         if preventing_writes?
           raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
         end
 
-        materialize_transactions
         mark_transaction_written_if_write(sql)
 
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
-        if without_prepared_statement?(binds)
-          log(sql, name) { @connection.execute_insert_pk(sql, pk) }
-        else
-          log(sql, name, binds) do
-            @connection.execute_insert_pk(sql, binds, pk)
+        with_raw_connection do |conn|
+          if without_prepared_statement?(binds)
+            log(sql, name) { conn.execute_insert_pk(sql, pk) }
+          else
+            log(sql, name, binds) do
+              conn.execute_insert_pk(sql, binds, pk)
+            end
           end
         end
       end
 
       # It appears that at this point (AR 5.0) "prepare" should only ever be true
       # if prepared statements are enabled
-      def exec_query(sql, name = nil, binds = NO_BINDS, prepare: false, async: false)
+      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
 
-        materialize_transactions
         mark_transaction_written_if_write(sql)
 
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
-        if without_prepared_statement?(binds)
-          log(sql, name) { @connection.execute_query(sql) }
-        else
-          log(sql, name, binds) do
-            # this is different from normal AR that always caches
-            cached_statement = fetch_cached_statement(sql) if prepare && @jdbc_statement_cache_enabled
-            @connection.execute_prepared_query(sql, binds, cached_statement)
+        with_raw_connection do |conn|
+          if without_prepared_statement?(binds)
+            log(sql, name, async: async) { conn.execute_query(sql) }
+          else
+            log(sql, name, 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, binds, cached_statement)
+            end
           end
         end
       end
 
-      def exec_update(sql, name = nil, binds = NO_BINDS)
+      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
 
-        materialize_transactions
         mark_transaction_written_if_write(sql)
 
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
 
-        if without_prepared_statement?(binds)
-          log(sql, name) { @connection.execute_update(sql) }
-        else
-          log(sql, name, binds) { @connection.execute_prepared_update(sql, binds) }
+        with_raw_connection do |conn|
+          if without_prepared_statement?(binds)
+            log(sql, name) { conn.execute_update(sql) }
+          else
+            log(sql, name, binds) { conn.execute_prepared_update(sql, binds) }
+          end
         end
       end
       alias :exec_delete :exec_update
 
-      def execute(sql, name = nil, async: false)
-        sql = transform_query(sql)
-        
-        if preventing_writes? && write_query?(sql)
-          raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
-        end
-
-        materialize_transactions
-        mark_transaction_written_if_write(sql)
-
-        log(sql, name, async: async) { @connection.execute(sql) }
-      end
-
       # overridden to support legacy binds
       def select_all(arel, name = nil, binds = NO_BINDS, preparable: nil, async: false)
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
@@ -102,6 +92,16 @@ module ArJdbc
         end
       end
 
+      def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: true)
+        log(sql, name, async: async) do
+          with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+            result = conn.execute(sql)
+            verified!
+            result
+          end
+        end
+      end
+
     end
   end
 end

data/lib/arjdbc/abstract/relation_query_attribute_monkey_patch.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "active_model/attribute"
+
+module ActiveRecord
+  # NOTE: improved implementation for hash methods that is used to
+  # compare objects. AR and arel commonly use `[a, b] - [b]` operations and
+  # JRuby internally uses the hash method to implement that operation,
+  # on the other hand, CRuby does not use the hash method
+  # for small arrays (length <= 16).
+  class Relation
+    # monkey patch
+    module RelationQueryAttributeMonkeyPatch
+      def hash
+        # [self.class, name, value_for_database, type].hash
+        [self.class, name, value_before_type_cast, type].hash
+      end
+    end
+
+    class QueryAttribute
+      prepend RelationQueryAttributeMonkeyPatch
+    end
+  end
+end

data/lib/arjdbc/abstract/statement_cache.rb

@@ -24,23 +24,18 @@ module ArJdbc
 
         # Only say we support the statement cache if we are using prepared statements
         # and have a max number of statements defined
-        statement_limit = self.class.type_cast_config_to_integer(config[:statement_limit])
+        statement_limit = self.class.type_cast_config_to_integer(@config[:statement_limit])
         @jdbc_statement_cache_enabled = prepared_statements && (statement_limit.nil? || statement_limit > 0)
 
         @statements = StatementPool.new(statement_limit) # AR (5.0) expects this to be stored as @statements
       end
 
-      # Clears the prepared statements cache.
-      def clear_cache!
-        @statements.clear
-      end
-
       def delete_cached_statement(sql)
         @statements.delete(sql_key(sql))
       end
 
       def fetch_cached_statement(sql)
-        @statements[sql_key(sql)] ||= @connection.prepare_statement(sql)
+        @statements[sql_key(sql)] ||= @raw_connection.prepare_statement(sql)
       end
 
       private