activerecord-jdbc-alt-adapter 71.0.0.alpha1-java → 71.0.0.alpha2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a773766cbb0e3ea279a04ab67b60c578382c604214c0a3dd5e54b7f419f4b96
-  data.tar.gz: d0f347ef628b4b791d81ad46a34d20f8ea3acb75cee3a473b2dbd8784769e897
+  metadata.gz: 6590c4d705c35e5a4849e4ef0bb076efba93509b8bcd8b4c2db49a4bc84b0f31
+  data.tar.gz: cb87d9f9f2763b178f990359efecb6b1199cbe15866460bb837232fcdd8b75e1
 SHA512:
-  metadata.gz: 7c08cd49b3245c655a4c51d5c0d327cf7f058a7c2c98cedf7a59f00f60d14e7d79b1d9c2eef614712cee71b684f717fd6edd7c122fd0349d775a7e4fb2a48150
-  data.tar.gz: b1a059930367508754dc54ff2b8b76434991ac2897ea4ff4917a7ef540d25c28272c4c5cbe13f5b5215eded00940c9beece3f2415860a69b4621a7c62664fa02
+  metadata.gz: 511e55410d149724a0765b5494a15ca4fe493bbd36b969a587d7bab23458cb32a45d34c01f79ca8b170b7f1e86fdf58e81bc4ba3ea15d464fe954a8266c41743
+  data.tar.gz: 9fdfe69ab63373f8e31cd2d60f5ae88fd3f4499250010aab4ffbeabb9c9345f017bb012932598a84297bd63d8b28f5bc38d18213f95b19b3307a93f38ecfc775

data/.github/workflows/main.yml

@@ -31,9 +31,12 @@ jobs:
         db: ['mssql']
         test_targets: ['test_mssql']
 
+    # NOTE: using a specific tag, it fails with 2019-latest.
+    # it seems the issue is related to some changes in mssql tools
+    # https://learn.microsoft.com/en-au/answers/questions/1853144/error-failed-to-initialize-container-mcr-microsoft
     services:
       mssql:
-        image: mcr.microsoft.com/mssql/server:2019-latest
+        image: mcr.microsoft.com/mssql/server:2019-CU27-ubuntu-20.04
         env:
           ACCEPT_EULA: Y
           MSSQL_SA_PASSWORD: Password12!
@@ -112,7 +115,7 @@ jobs:
 
     services:
       postgres:
-        image: postgres:10
+        image: postgres:11
         env:
           POSTGRES_PASSWORD: postgres
           POSTGRES_HOST_AUTH_METHOD: trust
@@ -157,7 +160,7 @@ jobs:
 
     services:
       mssql:
-        image: mcr.microsoft.com/mssql/server:2019-latest
+        image: mcr.microsoft.com/mssql/server:2019-CU27-ubuntu-20.04
         env:
           ACCEPT_EULA: Y
           MSSQL_SA_PASSWORD: Password12!
@@ -243,7 +246,7 @@ jobs:
 
     services:
       postgres:
-        image: postgres:10
+        image: postgres:11
         env:
           POSTGRES_PASSWORD: postgres
           POSTGRES_HOST_AUTH_METHOD: trust

data/.github/workflows/ruby.yml

@@ -84,7 +84,7 @@ jobs:
 
     services:
       postgres:
-        image: postgres:10
+        image: postgres:11
         env:
           POSTGRES_PASSWORD: postgres
           POSTGRES_HOST_AUTH_METHOD: trust
@@ -211,7 +211,7 @@ jobs:
 
     services:
       postgres:
-        image: postgres:10
+        image: postgres:11
         env:
           POSTGRES_PASSWORD: postgres
           POSTGRES_HOST_AUTH_METHOD: trust

data/.gitignore

@@ -19,6 +19,8 @@ nbproject
 .project
 *.sqlite
 *.sqlite3
+*.sqlite3-shm
+*.sqlite3-wal
 *.derby
 derby.log
 test.hsqldb*
@@ -33,8 +35,9 @@ Gemfile.lock
 .settings
 activerecord-jdbc.iml
 lib/arjdbc/jdbc/adapter_java.jar
-.jrubyrc
 tags
-pik.sh
-.ruby-version
+.jrubyrc
 .rubocop.yml
+.solargraph.yml
+pik.sh
+.tool-versions

data/activerecord-jdbc-adapter.gemspec

@@ -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.1.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

@@ -36,10 +36,13 @@ module ArJdbc
       #  end
       # end
 
+      private
+
       # DIFFERENCE: we delve into jdbc shared code and this does self.class.new_client.
       def connect
-        @raw_connection = jdbc_connection_class(@config[:adapter_spec]).new(@config, self)
-        @raw_connection.configure_connection
+        @raw_connection = self.class.new_client(@connection_parameters, self)
+      rescue ActiveRecord::ConnectionNotEstablished => ex
+        raise ex.set_pool(@pool)
       end
 
       def reconnect

data/lib/arjdbc/abstract/core.rb

@@ -2,23 +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(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
-
-        super(config) # AbstractAdapter
       end
 
       # Retrieve the raw `java.sql.Connection` object.

data/lib/arjdbc/abstract/database_statements.rb

@@ -33,7 +33,7 @@ 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)
+      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)
@@ -104,7 +104,7 @@ module ArJdbc
         end
       end
 
-      def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: false)
+      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|
             conn.execute(sql)

data/lib/arjdbc/abstract/statement_cache.rb

@@ -24,7 +24,7 @@ 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

data/lib/arjdbc/abstract/transaction_support.rb

@@ -107,16 +107,3 @@ module ArJdbc
     end
   end
 end
-
-# patch to avoid the usage of WeakMap
-require 'active_record/connection_adapters/abstract/transaction'
-module ActiveRecord
-  module ConnectionAdapters
-    class Transaction
-      def add_record(record, ensure_finalize = true)
-        @records ||= []
-        @records << record
-      end
-    end
-  end
-end

data/lib/arjdbc/mssql/adapter.rb

@@ -88,15 +88,20 @@ module ActiveRecord
 
       # @override
       def active?
-        return false unless @raw_connection
+        @lock.synchronize do
+          return false unless @raw_connection
 
-        @raw_connection.active?
+          @raw_connection.active?
+        end
       end
 
       # @override
       def disconnect!
-        super # clear_cache! && reset_transaction
-        @raw_connection&.disconnect!
+        @lock.synchronize do
+          super # clear_cache! && reset_transaction
+          @raw_connection&.disconnect!
+          @raw_connection = nil
+        end
       end
 
       # Returns the (JDBC) `ActiveRecord` column class for this adapter.
@@ -490,6 +495,10 @@ module ActiveRecord
           RangeError.new(message, sql: sql, binds: binds)
         when /Snapshot isolation transaction aborted due to update conflict. You cannot use snapshot isolation/
           StatementInvalid.new(message, sql: sql, binds: binds)
+        when /Incorrect syntax near the keyword .*/
+          StatementInvalid.new(message, sql: sql, binds: binds)
+        when /Could not find stored procedure .*/
+          StatementInvalid.new(message, sql: sql, binds: binds)
         else
           super
         end

data/lib/arjdbc/mssql/schema_statements.rb

@@ -174,9 +174,12 @@ module ActiveRecord
           end
         end
 
-        def rename_table(table_name, new_table_name)
-          execute "EXEC sp_rename '#{table_name}', '#{new_table_name}'"
-          rename_table_indexes(table_name, new_table_name)
+        def rename_table(table_name, new_name, **options)
+          validate_table_length!(new_name) unless options[:_uses_legacy_table_name]
+          schema_cache.clear_data_source_cache!(table_name.to_s)
+          schema_cache.clear_data_source_cache!(new_name.to_s)
+          execute "EXEC sp_rename '#{table_name}', '#{new_name}'"
+          rename_table_indexes(table_name, new_name)
         end
 
         # This is the same as the abstract method

data/lib/arjdbc/mysql/adapter.rb

@@ -23,7 +23,7 @@ module ActiveRecord
     class Mysql2Adapter < AbstractMysqlAdapter
       ADAPTER_NAME = 'Mysql2'
 
-      include Jdbc::ConnectionPoolCallbacks
+      # include Jdbc::ConnectionPoolCallbacks
 
       include ArJdbc::Abstract::ConnectionManagement
       include ArJdbc::Abstract::DatabaseStatements
@@ -33,6 +33,34 @@ module ActiveRecord
 
       include ArJdbc::MySQL
 
+      class << self
+        def jdbc_connection_class
+          ::ActiveRecord::ConnectionAdapters::MySQLJdbcConnection
+        end
+
+        def new_client(conn_params, adapter_instance)
+          jdbc_connection_class.new(conn_params, adapter_instance)
+        end
+
+        private
+          def initialize_type_map(m)
+            super
+
+            m.register_type(%r(char)i) do |sql_type|
+              limit = extract_limit(sql_type)
+              Type.lookup(:string, adapter: :mysql2, limit: limit)
+            end
+
+            m.register_type %r(^enum)i, Type.lookup(:string, adapter: :mysql2)
+            m.register_type %r(^set)i,  Type.lookup(:string, adapter: :mysql2)
+          end
+      end
+
+      # NOTE: redefines constant defined in abstract class however this time
+      # will use methods defined in the mysql abstract class and map properly
+      # mysql types.
+      TYPE_MAP = Type::TypeMap.new.tap { |m| initialize_type_map(m) }
+
       def initialize(...)
         super
 
@@ -171,7 +199,7 @@ module ActiveRecord
       #++
 
       def active?
-        !(@raw_connection.nil? || @raw_connection.closed?)  && @lock.synchronize { @raw_connection&.execute_query("/* ping */ SELECT 1") } || false
+        !(@raw_connection.nil? || @raw_connection.closed?) && @lock.synchronize { @raw_connection&.ping } || false
       end
 
       alias :reset! :reconnect!
@@ -221,14 +249,21 @@ module ActiveRecord
         @full_version ||= any_raw_connection.full_version
       end
 
-      def jdbc_connection_class(spec)
-        ::ActiveRecord::ConnectionAdapters::MySQLJdbcConnection
-      end
-
       def jdbc_column_class
         ::ActiveRecord::ConnectionAdapters::MySQL::Column
       end
 
+      def translate_exception(exception, message:, sql:, binds:)
+        case message
+        when /Table .* doesn't exist/i
+          StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
+        when /BLOB, TEXT, GEOMETRY or JSON column .* can't have a default value/i
+          StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
+        else
+          super
+        end
+      end
+
       # defined in MySQL::DatabaseStatements which is not included
       def default_insert_value(column)
         super unless column.auto_increment?

data/lib/arjdbc/postgresql/adapter.rb

@@ -13,6 +13,7 @@ require 'active_record/connection_adapters/postgresql/schema_dumper'
 require 'active_record/connection_adapters/postgresql/schema_statements'
 require 'active_record/connection_adapters/postgresql/type_metadata'
 require 'active_record/connection_adapters/postgresql/utils'
+
 require 'arjdbc/abstract/core'
 require 'arjdbc/abstract/connection_management'
 require 'arjdbc/abstract/database_statements'
@@ -21,6 +22,8 @@ require 'arjdbc/abstract/transaction_support'
 require 'arjdbc/postgresql/base/array_decoder'
 require 'arjdbc/postgresql/base/array_encoder'
 require 'arjdbc/postgresql/name'
+require 'arjdbc/postgresql/schema_statements'
+
 require 'active_model'
 
 module ArJdbc
@@ -35,11 +38,6 @@ module ArJdbc
     # @private
     Type = ::ActiveRecord::Type
 
-    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
-    def self.jdbc_connection_class
-      ::ActiveRecord::ConnectionAdapters::PostgreSQLJdbcConnection
-    end
-
     # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_column_class
     def jdbc_column_class; ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn end
 
@@ -52,8 +50,8 @@ module ArJdbc
     def redshift?
       # SELECT version() :
       #  PostgreSQL 8.0.2 on i686-pc-linux-gnu, compiled by GCC gcc (GCC) 3.4.2 20041017 (Red Hat 3.4.2-6.fc3), Redshift 1.0.647
-      if ( redshift = config[:redshift] ).nil?
-        redshift = !! (@connection.database_product || '').index('Redshift')
+      if (redshift = @config[:redshift]).nil?
+        redshift = !! (valid_raw_connection.database_product || '').index('Redshift')
       end
       redshift
     end
@@ -73,8 +71,8 @@ module ArJdbc
         # see http://jdbc.postgresql.org/documentation/91/connect.html
         # self.set_client_encoding(encoding)
       #end
-      self.client_min_messages = config[:min_messages] || 'warning'
-      self.schema_search_path = config[:schema_search_path] || config[:schema_order]
+      self.client_min_messages = @config[:min_messages] || 'warning'
+      self.schema_search_path = @config[:schema_search_path] || @config[:schema_order]
 
       # Use standard-conforming strings if available so we don't have to do the E'...' dance.
       set_standard_conforming_strings
@@ -93,7 +91,7 @@ module ArJdbc
 
       # SET statements from :variables config hash
       # http://www.postgresql.org/docs/8.3/static/sql-set.html
-      (config[:variables] || {}).map do |k, v|
+      (@config[:variables] || {}).map do |k, v|
         if v == ':default' || v == :default
           # Sets the value to the global or compile default
           execute("SET SESSION #{k} TO DEFAULT", 'SCHEMA')
@@ -101,6 +99,8 @@ module ArJdbc
           execute("SET SESSION #{k} TO #{quote(v)}", 'SCHEMA')
         end
       end
+
+      reload_type_map
     end
 
     # @private
@@ -127,7 +127,7 @@ module ArJdbc
       inet:         { name: 'inet' },
       int4range:    { name: 'int4range' },
       int8range:    { name: 'int8range' },
-      integer:      { name: 'integer' },
+      integer:      { name: 'integer', limit: 4 },
       interval:     { name: 'interval' },
       json:         { name: 'json' },
       jsonb:        { name: 'jsonb' },
@@ -232,6 +232,10 @@ module ArJdbc
     alias supports_insert_on_duplicate_update? supports_insert_on_conflict?
     alias supports_insert_conflict_target? supports_insert_on_conflict?
 
+    def supports_identity_columns? # :nodoc:
+      database_version >= 10_00_00 # >= 10.0
+    end
+
     def index_algorithms
       { concurrently: 'CONCURRENTLY' }
     end
@@ -297,14 +301,21 @@ module ArJdbc
       query_value("SELECT pg_advisory_unlock(#{lock_id})")
     end
 
-    def enable_extension(name)
-      exec_query("CREATE EXTENSION IF NOT EXISTS \"#{name}\"").tap {
-        reload_type_map
-      }
+    def enable_extension(name, **)
+      schema, name = name.to_s.split(".").values_at(-2, -1)
+      sql = +"CREATE EXTENSION IF NOT EXISTS \"#{name}\""
+      sql << " SCHEMA #{schema}" if schema
+
+      internal_exec_query(sql).tap { reload_type_map }
     end
 
-    def disable_extension(name)
-      exec_query("DROP EXTENSION IF EXISTS \"#{name}\" CASCADE").tap {
+    # Removes an extension from the database.
+    #
+    # [<tt>:force</tt>]
+    #   Set to +:cascade+ to drop dependent objects as well.
+    #   Defaults to false.
+    def disable_extension(name, force: false)
+      internal_exec_query("DROP EXTENSION IF EXISTS \"#{name}\"#{' CASCADE' if force == :cascade}").tap {
         reload_type_map
       }
     end
@@ -318,7 +329,7 @@ module ArJdbc
     end
 
     def extensions
-      exec_query("SELECT extname FROM pg_extension", "SCHEMA").cast_values
+      internal_exec_query("SELECT extname FROM pg_extension", "SCHEMA", allow_retry: true, materialize_transactions: false).cast_values
     end
 
     # Returns a list of defined enum types, and their values.
@@ -370,7 +381,7 @@ module ArJdbc
 
     def get_database_version # :nodoc:
       begin
-        version = @connection.database_product
+        version = valid_raw_connection.database_product
         if match = version.match(/([\d\.]*\d).*?/)
           version = match[1].split('.').map(&:to_i)
           # PostgreSQL version representation does not have more than 4 digits
@@ -426,8 +437,7 @@ module ArJdbc
       end
     end
 
-
-    def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
+    def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil) # :nodoc:
       val = super
       if !use_insert_returning? && pk
         unless sequence_name
@@ -464,18 +474,23 @@ module ArJdbc
     # since apparently calling close on the statement object
     # doesn't always free the server resources and calling
     # 'DISCARD ALL' fails if we are inside a transaction
-    def clear_cache!
-      super
-      # Make sure all query plans are *really* gone
-      @connection.execute 'DEALLOCATE ALL' if active?
-    end
+    # def clear_cache!
+    #   super
+    #   # Make sure all query plans are *really* gone
+    #   @connection.execute 'DEALLOCATE ALL' if active?
+    # end
 
     def reset!
-      clear_cache!
-      reset_transaction
-      @connection.rollback # Have to deal with rollbacks differently than the AR adapter
-      @connection.execute 'DISCARD ALL'
-      @connection.configure_connection
+      @lock.synchronize do
+        return connect! unless @raw_connection
+
+        # Have to deal with rollbacks differently than the AR adapter
+        @raw_connection.rollback
+
+        @raw_connection.execute("DISCARD ALL")
+
+        super
+      end
     end
 
     def default_sequence_name(table_name, pk = "id") #:nodoc:
@@ -660,6 +675,8 @@ module ArJdbc
         ::ActiveRecord::LockWaitTimeout.new(message, sql: sql, binds: binds)
       when /canceling statement/ # This needs to come after lock timeout because the lock timeout message also contains "canceling statement"
         ::ActiveRecord::QueryCanceled.new(message, sql: sql, binds: binds)
+      when /relation "animals" does not exist/i
+        ::ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
       else
         super
       end
@@ -742,7 +759,7 @@ module ActiveRecord::ConnectionAdapters
     include ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements
     include ActiveRecord::ConnectionAdapters::PostgreSQL::Quoting
 
-    include Jdbc::ConnectionPoolCallbacks
+    # include Jdbc::ConnectionPoolCallbacks
 
     include ArJdbc::Abstract::Core
     include ArJdbc::Abstract::ConnectionManagement
@@ -753,6 +770,7 @@ module ActiveRecord::ConnectionAdapters
 
     require 'arjdbc/postgresql/oid_types'
     include ::ArJdbc::PostgreSQL::OIDTypes
+    include ::ArJdbc::PostgreSQL::SchemaStatements
 
     include ::ArJdbc::PostgreSQL::ColumnHelpers
 
@@ -761,16 +779,27 @@ module ActiveRecord::ConnectionAdapters
     # AR expects OID to be available on the adapter
     OID = ActiveRecord::ConnectionAdapters::PostgreSQL::OID
 
-    def initialize(connection, logger = nil, connection_parameters = nil, config = {})
+    class << self
+      def jdbc_connection_class
+        ::ActiveRecord::ConnectionAdapters::PostgreSQLJdbcConnection
+      end
+
+      def new_client(conn_params, adapter_instance)
+        jdbc_connection_class.new(conn_params, adapter_instance)
+      end
+    end
+
+    def initialize(...)
+      super
+
+      conn_params = @config.compact
+
+      @connection_parameters = conn_params
+
       # @local_tz is initialized as nil to avoid warnings when connect tries to use it
       @local_tz = nil
       @max_identifier_length = nil
 
-      super(connection, logger, config) # configure_connection happens in super
-
-      @type_map = Type::HashLookupTypeMap.new
-      initialize_type_map
-
       @use_insert_returning = @config.key?(:insert_returning) ?
         self.class.type_cast_config_to_boolean(@config[:insert_returning]) : true
     end
@@ -793,10 +822,6 @@ module ActiveRecord::ConnectionAdapters
     public :sql_for_insert
     alias :postgresql_version :database_version
 
-    def jdbc_connection_class(spec)
-      ::ArJdbc::PostgreSQL.jdbc_connection_class
-    end
-
     private
 
     FEATURE_NOT_SUPPORTED = "0A000" # :nodoc:
@@ -829,8 +854,10 @@ module ActiveRecord::ConnectionAdapters
 
       type_casted_binds = type_casted_binds(binds)
       log(sql, name, binds, type_casted_binds, async: async) do
-        ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-          @connection.exec_params(sql, type_casted_binds)
+        with_raw_connection do |conn|
+          result = conn.exec_params(sql, type_casted_binds)
+          verified!
+          result
         end
       end
     end

data/lib/arjdbc/postgresql/oid_types.rb

@@ -67,28 +67,6 @@ module ArJdbc
 
     # @private
     module OIDTypes
-
-      # @override
-      def enable_extension(name)
-        result = super(name)
-        @extensions = nil
-        reload_type_map
-        result
-      end
-
-      # @override
-      def disable_extension(name)
-        result = super(name)
-        @extensions = nil
-        reload_type_map
-        result
-      end
-
-      # @override
-      def extensions
-        @extensions ||= super
-      end
-
       def get_oid_type(oid, fmod, column_name, sql_type = '') # :nodoc:
         # Note: type_map is storing a bunch of oid type prefixed with a namespace even
         # if they are not namespaced (e.g. ""."oidvector").  builtin types which are
@@ -118,8 +96,15 @@ module ArJdbc
       end
 
       def reload_type_map
-          type_map.clear
+        @lock.synchronize do
+          if @type_map
+            type_map.clear
+          else
+            @type_map = Type::HashLookupTypeMap.new
+          end
+
           initialize_type_map
+        end
       end
 
         def initialize_type_map_inner(m)
@@ -274,10 +259,6 @@ module ArJdbc
         $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
       end
 
-      def extract_limit(sql_type)
-        $1.to_i if sql_type =~ /\((.*)\)/
-      end
-
       # Support arrays/ranges for defining attributes that don't exist in the db
       ActiveRecord::Type.add_modifier({ array: true }, OID::Array, adapter: :postgresql)
       ActiveRecord::Type.add_modifier({ range: true }, OID::Range, adapter: :postgresql)

data/lib/arjdbc/postgresql/schema_statements.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ArJdbc
+  module PostgreSQL
+    module SchemaStatements
+      ForeignKeyDefinition = ActiveRecord::ConnectionAdapters::ForeignKeyDefinition
+      Utils = ActiveRecord::ConnectionAdapters::PostgreSQL::Utils
+
+      def foreign_keys(table_name)
+        scope = quoted_scope(table_name)
+        fk_info = internal_exec_query(<<~SQL, "SCHEMA", allow_retry: true, materialize_transactions: false)
+          SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete, c.convalidated AS valid, c.condeferrable AS deferrable, c.condeferred AS deferred, c.conkey, c.confkey, c.conrelid, c.confrelid
+          FROM pg_constraint c
+          JOIN pg_class t1 ON c.conrelid = t1.oid
+          JOIN pg_class t2 ON c.confrelid = t2.oid
+          JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+          JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+          JOIN pg_namespace t3 ON c.connamespace = t3.oid
+          WHERE c.contype = 'f'
+            AND t1.relname = #{scope[:name]}
+            AND t3.nspname = #{scope[:schema]}
+          ORDER BY c.conname
+        SQL
+
+        fk_info.map do |row|
+          to_table = Utils.unquote_identifier(row["to_table"])
+          # conkey = row["conkey"].scan(/\d+/).map(&:to_i)
+          # confkey = row["confkey"].scan(/\d+/).map(&:to_i)
+          conkey = row["conkey"]
+          confkey = row["confkey"]
+
+          if conkey.size > 1
+            column = column_names_from_column_numbers(row["conrelid"], conkey)
+            primary_key = column_names_from_column_numbers(row["confrelid"], confkey)
+          else
+            column = Utils.unquote_identifier(row["column"])
+            primary_key = row["primary_key"]
+          end
+
+          options = {
+            column: column,
+            name: row["name"],
+            primary_key: primary_key
+          }
+
+          options[:on_delete] = extract_foreign_key_action(row["on_delete"])
+          options[:on_update] = extract_foreign_key_action(row["on_update"])
+          options[:deferrable] = extract_constraint_deferrable(row["deferrable"], row["deferred"])
+
+          options[:validate] = row["valid"]
+
+          ForeignKeyDefinition.new(table_name, to_table, options)
+        end
+      end
+    end
+  end
+end

data/lib/arjdbc/sqlite3/adapter.rb

@@ -706,44 +706,6 @@ module ArJdbc
       # https://www.sqlite.org/pragma.html#pragma_cache_size
       raw_execute("PRAGMA cache_size = 2000", "SCHEMA")
     end
-
-    def configure_connection
-      if @config[:timeout] && @config[:retries]
-        raise ArgumentError, "Cannot specify both timeout and retries arguments"
-      elsif @config[:timeout]
-        # FIXME:
-#        @raw_connection.busy_timeout(self.class.type_cast_config_to_integer(@config[:timeout]))
-      elsif @config[:retries]
-        retries = self.class.type_cast_config_to_integer(@config[:retries])
-        raw_connection.busy_handler do |count|
-          count <= retries
-        end
-      end
-
-      # Enforce foreign key constraints
-      # https://www.sqlite.org/pragma.html#pragma_foreign_keys
-      # https://www.sqlite.org/foreignkeys.html
-      raw_execute("PRAGMA foreign_keys = ON", "SCHEMA")
-      unless @memory_database
-        # Journal mode WAL allows for greater concurrency (many readers + one writer)
-        # https://www.sqlite.org/pragma.html#pragma_journal_mode
-        raw_execute("PRAGMA journal_mode = WAL", "SCHEMA")
-        # 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
-        raw_execute("PRAGMA synchronous = NORMAL", "SCHEMA")
-        # 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
-        raw_execute("PRAGMA mmap_size = #{128.megabytes}", "SCHEMA")
-      end
-      # Impose a limit on the WAL file to prevent unlimited growth
-      # https://www.sqlite.org/pragma.html#pragma_journal_size_limit
-      raw_execute("PRAGMA journal_size_limit = #{64.megabytes}", "SCHEMA")
-      # Set the local connection cache to 2000 pages
-      # https://www.sqlite.org/pragma.html#pragma_cache_size
-      raw_execute("PRAGMA cache_size = 2000", "SCHEMA")      
-    end
   end
   # DIFFERENCE: A registration here is moved down to concrete class so we are not registering part of an adapter.
 end
@@ -774,6 +736,20 @@ module ActiveRecord::ConnectionAdapters
     #   config.active_record.sqlite3_adapter_strict_strings_by_default = true
     class_attribute :strict_strings_by_default, default: false # Does not actually do anything right now
 
+    def initialize(...)
+      super
+
+      conn_params = @config.compact
+
+      # NOTE: strict strings is not supported by the jdbc driver yet,
+      # hope it will supported soon, I open a issue in their repository.
+      #   https://github.com/xerial/sqlite-jdbc/issues/1153
+      #
+      # @config[:strict] = ConnectionAdapters::SQLite3Adapter.strict_strings_by_default unless @config.key?(:strict)
+
+      @connection_parameters = conn_params
+    end
+
     def self.represent_boolean_as_integer=(value) # :nodoc:
       if value == false
         raise "`.represent_boolean_as_integer=` is now always true, so make sure your application can work with it and remove this settings."
@@ -817,15 +793,6 @@ module ActiveRecord::ConnectionAdapters
       ::ActiveRecord::ConnectionAdapters::SQLite3Column
     end
 
-    def jdbc_connection_class(spec)
-      self.class.jdbc_connection_class
-    end
-
-    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
-    def self.jdbc_connection_class
-      ::ActiveRecord::ConnectionAdapters::SQLite3JdbcConnection
-    end
-
     # Note: This is not an override of ours but a moved line from AR Sqlite3Adapter to register ours vs our copied module (which would be their class).
 #    ActiveSupport.run_load_hooks(:active_record_sqlite3adapter, SQLite3Adapter)
 
@@ -843,6 +810,14 @@ module ActiveRecord::ConnectionAdapters
     ::ActiveRecord::Type.register(:integer, SQLite3Integer, adapter: :sqlite3)
 
     class << self
+      def jdbc_connection_class
+        ::ActiveRecord::ConnectionAdapters::SQLite3JdbcConnection
+      end
+
+      def new_client(conn_params, adapter_instance)
+        jdbc_connection_class.new(conn_params, adapter_instance)
+      end
+
       def dbconsole(config, options = {})
         args = []
 

data/lib/arjdbc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ArJdbc
-  VERSION = '71.0.0.alpha1'
+  VERSION = '71.0.0.alpha2'
 end

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

@@ -793,8 +793,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 = mapToRawResult(context, connection, resultSet, false);
+                        result = mapExecuteResult(context, connection, resultSet);
+                        // result = mapToRawResult(context, connection, resultSet, false);
                         resultSet.close();
                     } else {
                         result = context.runtime.newFixnum(updateCount);

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

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbc-alt-adapter
 version: !ruby/object:Gem::Version
-  version: 71.0.0.alpha1
+  version: 71.0.0.alpha2
 platform: java
 authors:
 - Nick Sieger, Ola Bini, Karol Bucek, Jesse Chavez, and JRuby contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-24 00:00:00.000000000 Z
+date: 2024-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -145,6 +145,7 @@ files:
 - lib/arjdbc/postgresql/connection_methods.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