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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 973f3cfa750c3424b5de9105f177584edea8ebe705d50b20e4b9f6d989a4919f
-  data.tar.gz: e7f86bfeb49f90f2767e3bdcc3e0101a58149e97421e8d7b96da8f59fc469959
+  metadata.gz: 9368e28d99e49de4164150e2e006ce8991be7d7aab58e6773936866f86dbbdd0
+  data.tar.gz: '03983c9218db6dd3a9ab278b0364ded1d9f5c315853b7ed6b543a05cca8c6c6c'
 SHA512:
-  metadata.gz: f276911281e38f162526b603959f5798fa5d09c73284a79078376126b5fade87add2e4a4345242029a4b4e39097b5a6964651483576f51ed8bee3ac7b6e586a3
-  data.tar.gz: 8e5d458add630631bfaa82605f20d28c80310e25787c9db2c94c1b8cc677ac8ff6e0730c97b6271a333cbfe919da8a35ad8deb7911aeedc89c3021629e0c5370
+  metadata.gz: 450ddae41c05f2519c53ff0ad17de0bfd3cfefa1a471775a9d27946843f2d685301ff12cbbcdd4f434f275ee4f067798fc500ff49a2f2ec79f2339dfede6fc8c
+  data.tar.gz: aa9aa18ad21ead09d7bab3180032c8fa71ffee37fbb43dbba6a52ac3b436da34010e229e10cf1d6eec9edb2a803addcd0585a0b8ac78bdba05281f77dc7f5924

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.3'
+  gem.add_dependency "activerecord", "~> 7.2.2"
 
   #gem.add_development_dependency 'test-unit', '2.5.4'
   #gem.add_development_dependency 'test-unit-context', '>= 0.3.0'

data/activerecord-jdbc-alt-adapter.gemspec

@@ -43,7 +43,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.3'
+  gem.add_dependency "activerecord", "~> 7.2.2"
 
   #gem.add_development_dependency 'test-unit', '2.5.4'
   #gem.add_development_dependency 'test-unit-context', '>= 0.3.0'

data/lib/arel/visitors/sqlserver.rb

@@ -83,15 +83,17 @@ module Arel
         @select_statement = nil
       end
 
-      def visit_Arel_Table o, collector
+      def visit_Arel_Table(o, collector)
         # Apparently, o.engine.connection can actually be a different adapter
         # than sqlserver. Can be removed if fixed in ActiveRecord. See:
         # github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues/450
         table_name = begin
-          if o.class.engine.connection.respond_to?(:sqlserver?) && o.class.engine.connection.database_prefix_remote_server?
-            remote_server_table_name(o)
-          else
-            quote_table_name(o.name)
+          o.class.engine.with_connection do |connection|
+            if connection.respond_to?(:sqlserver?) && connection.database_prefix_remote_server?
+              remote_server_table_name(o)
+            else
+              quote_table_name(o.name)
+            end
           end
         rescue Exception => e
           quote_table_name(o.name)
@@ -259,10 +261,12 @@ module Arel
         column_name ? t[column_name] : nil
       end
 
-      def remote_server_table_name o
-        ActiveRecord::ConnectionAdapters::SQLServer::Utils.extract_identifiers(
-          "#{o.class.engine.connection.database_prefix}#{o.name}"
-        ).quoted
+      def remote_server_table_name(o)
+        o.class.engine.with_connection do |connection|
+          ActiveRecord::ConnectionAdapters::SQLServer::Utils.extract_identifiers(
+            "#{connection.database_prefix}#{o.name}"
+          ).quoted
+        end
       end
 
       # Need to remove ordering from subqueries unless TOP/OFFSET also used. Otherwise, SQLServer

data/lib/arjdbc/abstract/database_statements.rb

@@ -79,7 +79,7 @@ module ArJdbc
       alias :exec_delete :exec_update
 
       # overridden to support legacy binds
-      def select_all(arel, name = nil, binds = NO_BINDS, preparable: nil, async: false)
+      def select_all(arel, name = nil, binds = NO_BINDS, preparable: nil, async: false, allow_retry: false)
         binds = convert_legacy_binds_to_attributes(binds) if binds.first.is_a?(Array)
         super
       end

data/lib/arjdbc/mssql/adapter.rb

@@ -30,6 +30,8 @@ require 'arjdbc/mssql/errors'
 require 'arjdbc/mssql/schema_creation'
 require 'arjdbc/mssql/database_limits'
 
+require "arjdbc/mssql/adapter_hash_config"
+
 require "arjdbc/abstract/relation_query_attribute_monkey_patch"
 
 module ActiveRecord
@@ -44,6 +46,7 @@ module ActiveRecord
       # include ArJdbc::Abstract::DatabaseStatements
       # include ArJdbc::Abstract::StatementCache
       include ArJdbc::Abstract::TransactionSupport
+      include ArJdbc::MSSQLConfig
 
       include MSSQL::Quoting
       include MSSQL::SchemaStatements
@@ -81,7 +84,8 @@ module ActiveRecord
         # configure_connection happens in super
         super
 
-        conn_params = @config.compact
+        # assign arjdbc extra connection params
+        conn_params = build_connection_config(@config.compact)
 
         @raw_connection = nil
 
@@ -340,7 +344,7 @@ module ActiveRecord
 
         schemas_and_tables.map do |schema_table|
           schema, table = schema_table
-          "#{quote_name_part(schema)}.#{quote_name_part(table)}"
+          "#{self.class.mssql_quote_name_part(schema)}.#{self.class.mssql_quote_name_part(table)}"
         end
       end
 

data/lib/arjdbc/mssql/adapter_hash_config.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ArJdbc
+  module MSSQLConfig
+    def build_connection_config(config)
+      config = config.deep_dup
+
+      load_jdbc_driver
+
+      config[:driver] ||= database_driver_name
+
+      config[:host] ||= "localhost"
+      config[:connection_alive_sql] ||= "SELECT 1"
+      config[:lock_timeout] ||= 5000
+
+      config[:url] ||= build_connection_url(config)
+
+      config
+    end
+
+    private
+
+    def load_jdbc_driver
+      require "jdbc/mssql"
+
+      ::Jdbc::Mssql.load_driver if defined?(::Jdbc::Mssql.load_driver)
+    rescue LoadError
+      # assuming driver.jar is on the class-path
+    end
+
+    def database_driver_name
+      "com.microsoft.sqlserver.jdbc.SQLServerDriver"
+    end
+
+    def build_connection_url(config)
+      url = "".dup
+      url << "jdbc:sqlserver://#{config[:host]}"
+      url << ( config[:port] ? ":#{config[:port]};" : ';' )
+      url << "databaseName=#{config[:database]};" if config[:database]
+      url << "instanceName=#{config[:instance]};" if config[:instance]
+      url << "sendTimeAsDatetime=#{config[:send_time_as_datetime] || false};"
+      url << "loginTimeout=#{config[:login_timeout].to_i};" if config[:login_timeout]
+      url << "lockTimeout=#{config[:lock_timeout].to_i};"
+      url << "encrypt=#{config[:encrypt]};" if config.key?(:encrypt)
+      url << "trustServerCertificate=#{config[:trust_server_certificate]};" if config.key?(:trust_server_certificate)
+      app = config[:application_name] || config[:appname] || config[:application]
+      url << "applicationName=#{app};" if app
+      isc = config[:integrated_security] # Win only - needs sqljdbc_auth.dll
+      url << "integratedSecurity=#{isc};" unless isc.nil?
+      url
+    end
+  end
+end

data/lib/arjdbc/mssql/database_statements.rb

@@ -90,7 +90,7 @@ module ActiveRecord
           end
         end
 
-        def internal_exec_query(sql, name = 'SQL', binds = [], prepare: false, async: false)
+        def internal_exec_query(sql, name = 'SQL', binds = [], prepare: false, async: false, allow_retry: false)
           sql = transform_query(sql)
 
           check_if_write_query(sql)
@@ -244,7 +244,7 @@ module ActiveRecord
         end
 
         def raw_jdbc_connection
-          @raw_connection
+          any_raw_connection
         end
 
         # It seems the truncate_tables is mostly used for testing

data/lib/arjdbc/mssql/quoting.rb

@@ -4,6 +4,62 @@ module ActiveRecord
   module ConnectionAdapters
     module MSSQL
       module Quoting
+        extend ActiveSupport::Concern
+
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
+        module ClassMethods # :nodoc:
+          def column_name_matcher
+            /
+              \A
+              (
+                (?:
+                  # \[table_name\].\[column_name\] | function(one or no argument)
+                  ((?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
+                )
+                (?:\s+AS\s+(?:\w+|\[\w+\]))?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def column_name_with_order_matcher
+            /
+              \A
+              (
+                (?:
+                  # \[table_name\].\[column_name\] | function(one or no argument)
+                  ((?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
+                )
+                (?:\s+ASC|\s+DESC)?
+              )
+              (?:\s*,\s*\g<1>)*
+              \z
+            /ix
+          end
+
+          def quote_column_name(name)
+            QUOTED_COLUMN_NAMES[name] ||= mssql_quote_column_name(name)
+          end
+
+          def quote_table_name(name)
+            QUOTED_TABLE_NAMES[name] ||= mssql_quote_column_name(name)
+          end
+
+          def mssql_quote_column_name(name)
+            name = name.to_s.split(".")
+            name.map! { |n| mssql_quote_name_part(n) } # "[#{name}]"
+            name.join(".")
+          end
+
+          # Implements the quoting style for SQL Server
+          def mssql_quote_name_part(part)
+            part =~ /^\[.*\]$/ ? part : "[#{part.gsub(']', ']]')}]"
+          end
+        end
+
         QUOTED_TRUE  = '1'
         QUOTED_FALSE = '0'
 
@@ -88,42 +144,6 @@ module ActiveRecord
         # @see #quote in old adapter
         BLOB_VALUE_MARKER = "''"
 
-        def column_name_matcher
-          COLUMN_NAME
-        end
-
-        def column_name_with_order_matcher
-          COLUMN_NAME_WITH_ORDER
-        end
-
-        COLUMN_NAME = /
-          \A
-          (
-            (?:
-              # \[table_name\].\[column_name\] | function(one or no argument)
-              ((?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
-            )
-            (?:\s+AS\s+(?:\w+|\[\w+\]))?
-          )
-          (?:\s*,\s*\g<1>)*
-          \z
-        /ix
-
-        COLUMN_NAME_WITH_ORDER = /
-          \A
-          (
-            (?:
-              # \[table_name\].\[column_name\] | function(one or no argument)
-              ((?:\w+\.|\[\w+\]\.)?(?:\w+|\[\w+\])) | \w+\((?:|\g<2>)\)
-            )
-            (?:\s+ASC|\s+DESC)?
-          )
-          (?:\s*,\s*\g<1>)*
-          \z
-        /ix
-
-        private_constant :COLUMN_NAME, :COLUMN_NAME_WITH_ORDER
-
         private
 
         def time_with_db_timezone(value)

data/lib/arjdbc/mssql/schema_statements.rb

@@ -182,20 +182,8 @@ module ActiveRecord
           rename_table_indexes(table_name, new_name)
         end
 
-        # This is the same as the abstract method
-        def quote_table_name(name)
-          quote_column_name(name)
-        end
-
-        # This overrides the abstract method to be specific to SQL Server.
-        def quote_column_name(name)
-          name = name.to_s.split('.')
-          name.map! { |n| quote_name_part(n) } # "[#{name}]"
-          name.join('.')
-        end
-
         def quote_database_name(name)
-          quote_name_part(name.to_s)
+          self.class.mssql_quote_name_part(name.to_s)
         end
 
         # @private these cannot specify a limit
@@ -439,11 +427,6 @@ module ActiveRecord
           result
         end
 
-        # Implements the quoting style for SQL Server
-        def quote_name_part(part)
-          part =~ /^\[.*\]$/ ? part : "[#{part.gsub(']', ']]')}]"
-        end
-
         def remove_check_constraints(table_name, column_name)
           constraints = select_values "SELECT CONSTRAINT_NAME FROM INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE where TABLE_NAME = '#{quote_string(table_name)}' and COLUMN_NAME = '#{quote_string(column_name)}'", 'SCHEMA'
           constraints.each do |constraint|

data/lib/arjdbc/mssql.rb

@@ -6,4 +6,4 @@ module ArJdbc
   MsSQL = MSSQL # compatibility with 1.2
 end
 
-ArJdbc.warn_unsupported_adapter 'mssql', [7, 1] # warns on AR >= 4.2
+ArJdbc.warn_unsupported_adapter "mssql", [7, 2] # warns on AR >= 4.2

data/lib/arjdbc/mysql/adapter.rb

@@ -11,6 +11,8 @@ require 'arjdbc/abstract/database_statements'
 require 'arjdbc/abstract/statement_cache'
 require 'arjdbc/abstract/transaction_support'
 
+require "arjdbc/mysql/adapter_hash_config"
+
 require "arjdbc/abstract/relation_query_attribute_monkey_patch"
 
 module ActiveRecord
@@ -34,6 +36,7 @@ module ActiveRecord
       include ArJdbc::Abstract::TransactionSupport
 
       include ArJdbc::MySQL
+      include ArJdbc::MysqlConfig
 
       class << self
         def jdbc_connection_class
@@ -68,6 +71,9 @@ module ActiveRecord
 
         @config[:flags] ||= 0
 
+        # assign arjdbc extra connection params
+        conn_params = build_connection_config(@config.compact)
+
         # JDBC mysql appears to use found rows by default: https://dev.mysql.com/doc/connector-j/en/connector-j-connp-props-connection.html
         # if @config[:flags].kind_of? Array
         #   @config[:flags].push "FOUND_ROWS"
@@ -75,7 +81,7 @@ module ActiveRecord
         #   @config[:flags] |= ::Mysql2::Client::FOUND_ROWS
         # end
 
-        @connection_parameters ||= @config
+        @connection_parameters = conn_params
       end
 
       def self.database_exists?(config)

data/lib/arjdbc/mysql/adapter_hash_config.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module ArJdbc
+  module MysqlConfig
+    def build_connection_config(config)
+      config = config.deep_dup
+
+      load_jdbc_driver
+
+      config[:driver] ||= database_driver_name
+
+      host = (config[:host] ||= "localhost")
+      port = (config[:port] ||= 3306)
+
+      # jdbc:mysql://[host][,failoverhost...][:port]/[database]
+      # - alternate fail-over syntax: [host:port],[host:port]/[database]
+      config[:url] ||= "jdbc:mysql://#{host}:#{port}/#{config[:database]}"
+
+      config[:properties] = build_properties(config)
+
+      config
+    end
+
+    private
+
+    def load_jdbc_driver
+      require "jdbc/mysql"
+
+      ::Jdbc::MySQL.load_driver(:require) if defined?(::Jdbc::MySQL.load_driver)
+    rescue LoadError
+      # assuming driver.jar is on the class-path
+    end
+
+    def database_driver_name
+      return ::Jdbc::MySQL.driver_name if defined?(::Jdbc::MySQL.driver_name)
+
+      "com.mysql.jdbc.Driver"
+    end
+
+    def build_properties(config)
+      properties = config[:properties] || {}
+
+      properties["zeroDateTimeBehavior"] ||= "CONVERT_TO_NULL"
+
+      properties["jdbcCompliantTruncation"] ||= false
+
+      charset_name = convert_mysql_encoding(config)
+
+      # do not set characterEncoding
+      if charset_name.eql?(false)
+        properties["character_set_server"] = config[:encoding] || "utf8"
+      else
+        properties["characterEncoding"] = charset_name
+      end
+
+      # driver also executes: "SET NAMES " + (useutf8mb4 ? "utf8mb4" : "utf8")
+      # thus no need to do it on configure_connection :
+      config[:encoding] = nil if config.key?(:encoding)
+
+      properties["connectionCollation"] ||= config[:collation] if config[:collation]
+
+      properties["autoReconnect"] ||= reconnect.to_s unless config[:reconnect].nil?
+
+      properties["noDatetimeStringSync"] = true unless properties.key?("noDatetimeStringSync")
+
+      sslcert = config[:sslcert]
+      sslca = config[:sslca]
+
+      if config[:sslkey] || sslcert
+        properties["useSSL"] ||= true
+        properties["requireSSL"] ||= true
+        properties["clientCertificateKeyStoreUrl"] ||= java.io.File.new(sslcert).to_url.to_s if sslcert
+
+        if sslca
+          properties["trustCertificateKeyStoreUrl"] ||= java.io.File.new(sslca).to_url.to_s
+        else
+          properties["verifyServerCertificate"] ||= false
+        end
+      else
+        # According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection
+        # must be established by default if explicit option isn't set :
+        properties["useSSL"] ||= false
+      end
+
+      # disables the effect of 'useTimezone'
+      properties["useLegacyDatetimeCode"] = false
+
+      properties
+    end
+
+    # See https://dev.mysql.com/doc/connector-j/5.1/en/connector-j-reference-charsets.html
+    # to charset-name (characterEncoding=...)
+    def convert_mysql_encoding(config)
+      # NOTE: this is "better" than passing what users are used to set on MRI
+      # e.g. 'utf8mb4' will fail cause the driver will check for a Java charset
+      # ... it's smart enough to detect utf8mb4 from server variables :
+      # "character_set_client" && "character_set_connection" (thus UTF-8)
+      encoding = config.key?(:encoding) ? config[:encoding] : "utf8"
+
+      value = MYSQL_ENCODINGS[encoding]
+
+      return false if value == false
+
+      value || encoding
+    end
+
+    MYSQL_ENCODINGS = {
+      "big5"     => "Big5",
+      "dec8"     => nil,
+      "hp8"      => nil,
+      "latin1"   => "Cp1252",
+      "latin2"   => "ISO8859_2",
+      "swe7"     => nil,
+      "ascii"    => "US-ASCII",
+      "ujis"     => "EUC_JP",
+      "sjis"     => "SJIS",
+      "hebrew"   => "ISO8859_8",
+      "tis620"   => "TIS620",
+      "euckr"    => "EUC_KR",
+      "gb2312"   => "EUC_CN",
+      "greek"    => "ISO8859_7",
+      "cp1250"   => "Cp1250",
+      "gbk"      => "GBK",
+      "armscii8" => nil,
+      "ucs2"     => "UnicodeBig",
+      "cp866"    => "Cp866",
+      "keybcs2"  => nil,
+      "macce"    => "MacCentralEurope",
+      "macroman" => "MacRoman",
+      "cp1251"   => "Cp1251",
+      "cp1256"   => "Cp1256",
+      "cp1257"   => "Cp1257",
+      "binary"   => false,
+      "geostd8"  => nil,
+      "cp932"    => "Cp932",
+      "utf8"     => "UTF-8",
+      "utf8mb4"  => false,
+      "utf16"    => false,
+      "utf32"    => false,
+      # "cp850"    => "Cp850",
+      # "koi8r"    => "KOI8-R",
+      # "koi8u"    => "KOI8-R",
+      # "latin5"   => "ISO-8859-9",
+      # "cp852"    => "CP852",
+      # "latin7"   => "ISO-8859-13",
+      # "eucjpms"  => "eucJP-ms"
+    }.freeze
+  end
+end

data/lib/arjdbc/mysql.rb

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

data/lib/arjdbc/postgresql/adapter.rb

@@ -24,6 +24,7 @@ require 'arjdbc/postgresql/base/array_encoder'
 require 'arjdbc/postgresql/name'
 require 'arjdbc/postgresql/database_statements'
 require 'arjdbc/postgresql/schema_statements'
+require "arjdbc/postgresql/adapter_hash_config"
 
 require 'active_model'
 
@@ -855,6 +856,7 @@ module ActiveRecord::ConnectionAdapters
     include ArJdbc::Abstract::StatementCache
     include ArJdbc::Abstract::TransactionSupport
     include ArJdbc::PostgreSQL
+    include ArJdbc::PostgreSQLConfig
 
     require 'arjdbc/postgresql/oid_types'
     include ::ArJdbc::PostgreSQL::OIDTypes
@@ -900,7 +902,8 @@ module ActiveRecord::ConnectionAdapters
     def initialize(...)
       super
 
-      conn_params = @config.compact
+      # assign arjdbc extra connection params
+      conn_params = build_connection_config(@config.compact)
 
       @connection_parameters = conn_params
 
@@ -912,15 +915,6 @@ module ActiveRecord::ConnectionAdapters
         self.class.type_cast_config_to_boolean(@config[:insert_returning]) : true
     end
 
-    def self.database_exists?(config)
-      conn = ActiveRecord::Base.postgresql_connection(config)
-      conn && conn.really_valid?
-    rescue ActiveRecord::NoDatabaseError
-      false
-    ensure
-      conn.disconnect! if conn
-    end
-
     require 'active_record/connection_adapters/postgresql/schema_definitions'
 
     ColumnMethods = ActiveRecord::ConnectionAdapters::PostgreSQL::ColumnMethods

data/lib/arjdbc/postgresql/adapter_hash_config.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module ArJdbc
+  module PostgreSQLConfig
+    def build_connection_config(config)
+      config = config.deep_dup
+
+      load_jdbc_driver
+
+      config[:driver] ||= database_driver_name
+
+      host = (config[:host] ||= config[:hostaddr] || ENV["PGHOST"] || "localhost")
+      port = (config[:port] ||= ENV["PGPORT"] || 5432)
+      database = config[:database] || config[:dbname] || ENV["PGDATABASE"]
+
+      app = config[:application_name] || config[:appname] || config[:application]
+
+      config[:url] ||= if app
+                         "jdbc:postgresql://#{host}:#{port}/#{database}?ApplicationName=#{app}"
+                       else
+                         "jdbc:postgresql://#{host}:#{port}/#{database}"
+                       end
+
+      config[:url] << config[:pg_params] if config[:pg_params]
+
+      config[:username] ||= config[:user] || ENV["PGUSER"] || ENV_JAVA["user.name"]
+      config[:password] ||= ENV["PGPASSWORD"] unless config.key?(:password)
+
+      config[:properties] = build_properties(config)
+
+      config
+    end
+
+    private
+
+    def load_jdbc_driver
+      require "jdbc/postgres"
+
+      ::Jdbc::Postgres.load_driver(:require) if defined?(::Jdbc::Postgres.load_driver)
+    rescue LoadError
+      # assuming driver.jar is on the class-path
+    end
+
+    def database_driver_name
+      return ::Jdbc::Postgres.driver_name if defined?(::Jdbc::Postgres.driver_name)
+
+      "org.postgresql.Driver"
+    end
+
+    def build_properties(config)
+      properties = config[:properties] || {}
+
+      # PG :connect_timeout - maximum time to wait for connection to succeed
+      connect_timeout = config[:connect_timeout] || ENV["PGCONNECT_TIMEOUT"]
+
+      properties["socketTimeout"] ||= connect_timeout if connect_timeout
+
+      login_timeout = config[:login_timeout]
+
+      properties["loginTimeout"] ||= login_timeout if login_timeout
+
+      sslmode = config.key?(:sslmode) ? config[:sslmode] : config[:requiressl]
+      # NOTE: makes not much sense since this needs some JVM options :
+      sslmode = ENV["PGSSLMODE"] || ENV["PGREQUIRESSL"] if sslmode.nil?
+
+      # PG :sslmode - disable|allow|prefer|require
+      unless sslmode.nil? || !(sslmode == true || sslmode.to_s == "require")
+        # JRuby/JVM needs to be started with :
+        #  -Djavax.net.ssl.trustStore=mystore -Djavax.net.ssl.trustStorePassword=...
+        # or a non-validating connection might be used (for testing) :
+        #  :sslfactory = 'org.postgresql.ssl.NonValidatingFactory'
+
+        if config[:driver].start_with?("org.postgresql.")
+          properties["sslfactory"] ||= "org.postgresql.ssl.NonValidatingFactory"
+        end
+
+        properties["ssl"] ||= "true"
+      end
+
+      properties["tcpKeepAlive"] ||= config[:keepalives] if config.key?(:keepalives)
+      properties["kerberosServerName"] ||= config[:krbsrvname] if config[:krbsrvname]
+
+      prepared_statements = config.fetch(:prepared_statements, true)
+
+      prepared_statements = false if prepared_statements == "false"
+
+      if prepared_statements
+        # this makes the pgjdbc driver handle hot compatibility internally
+        properties["autosave"] ||= "conservative"
+      else
+        # If prepared statements are off, lets make sure they are really *off*
+        properties["prepareThreshold"] = 0
+      end
+
+      properties
+    end
+  end
+end

data/lib/arjdbc/postgresql/base/array_encoder.rb

@@ -12,7 +12,9 @@ module ActiveRecord::ConnectionAdapters::PostgreSQL::OID
                       'text'.freeze
                     else
                       base_type = name.chomp('[]').to_sym
-                      ActiveRecord::Base.connection.native_database_types[base_type][:name]
+                      ActiveRecord::Base.with_connection do |connection|
+                        connection.native_database_types[base_type][:name]
+                      end
                     end
           end
 

data/lib/arjdbc/postgresql/oid_types.rb

@@ -112,8 +112,8 @@ module ArJdbc
           m.register_type "int4", Type::Integer.new(limit: 4)
           m.register_type "int8", Type::Integer.new(limit: 8)
           m.register_type "oid", OID::Oid.new
-          m.register_type "float4", Type::Float.new
-          m.alias_type "float8", "float4"
+          m.register_type "float4", Type::Float.new(limit: 24)
+          m.register_type "float8", Type::Float.new
           m.register_type "text", Type::Text.new
           register_class_with_limit m, "varchar", Type::String
           m.alias_type "char", "varchar"

data/lib/arjdbc/postgresql.rb

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

data/lib/arjdbc/sqlite3/adapter.rb

@@ -17,6 +17,7 @@ require "active_record/connection_adapters/sqlite3/schema_dumper"
 require "active_record/connection_adapters/sqlite3/schema_statements"
 require "active_support/core_ext/class/attribute"
 require "arjdbc/sqlite3/column"
+require "arjdbc/sqlite3/adapter_hash_config"
 
 require "arjdbc/abstract/relation_query_attribute_monkey_patch"
 
@@ -63,13 +64,6 @@ module ArJdbc
     SchemaCreation = ConnectionAdapters::SQLite3::SchemaCreation
     SQLite3Adapter = ConnectionAdapters::AbstractAdapter
 
-    ADAPTER_NAME = 'SQLite'
-
-    # DIFFERENCE: FQN
-    include ::ActiveRecord::ConnectionAdapters::SQLite3::Quoting
-    include ::ActiveRecord::ConnectionAdapters::SQLite3::SchemaStatements
-    include ::ActiveRecord::ConnectionAdapters::SQLite3::DatabaseStatements
-
     NATIVE_DATABASE_TYPES = {
         primary_key:  "integer PRIMARY KEY AUTOINCREMENT NOT NULL",
         string:       { name: "varchar" },
@@ -84,7 +78,7 @@ module ArJdbc
         boolean:      { name: "boolean" },
         json:         { name: "json" },
     }
-    
+
     class StatementPool < ConnectionAdapters::StatementPool # :nodoc:
       private
       def dealloc(stmt)
@@ -729,13 +723,41 @@ module ActiveRecord::ConnectionAdapters
   # ActiveRecord::ConnectionAdapters::SQLite3Adapter.  Once we can do that we can remove the
   # module SQLite3 above and remove a majority of this file.
   class SQLite3Adapter < AbstractAdapter
+    ADAPTER_NAME = "SQLite"
+
+    class << self
+      def new_client(conn_params, adapter_instance)
+        jdbc_connection_class.new(conn_params, adapter_instance)
+      end
+
+      def dbconsole(config, options = {})
+        args = []
+
+        args << "-#{options[:mode]}" if options[:mode]
+        args << "-header" if options[:header]
+        args << File.expand_path(config.database, const_defined?(:Rails) && Rails.respond_to?(:root) ? Rails.root : nil)
+
+        find_cmd_and_exec("sqlite3", *args)
+      end
+
+      def jdbc_connection_class
+        ::ActiveRecord::ConnectionAdapters::SQLite3JdbcConnection
+      end
+    end
+
     include ArJdbc::Abstract::Core
     include ArJdbc::SQLite3
+    include ArJdbc::SQLite3Config
+
     include ArJdbc::Abstract::ConnectionManagement
     include ArJdbc::Abstract::DatabaseStatements
     include ArJdbc::Abstract::StatementCache
     include ArJdbc::Abstract::TransactionSupport
 
+    include ::ActiveRecord::ConnectionAdapters::SQLite3::Quoting
+    include ::ActiveRecord::ConnectionAdapters::SQLite3::SchemaStatements
+    include ::ActiveRecord::ConnectionAdapters::SQLite3::DatabaseStatements
+
     ##
     # :singleton-method:
     # Configure the SQLite3Adapter to be used in a strict strings mode.
@@ -749,7 +771,8 @@ module ActiveRecord::ConnectionAdapters
     def initialize(...)
       super
 
-      conn_params = @config.compact
+      # assign arjdbc extra connection params
+      conn_params = build_connection_config(@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.
@@ -820,24 +843,6 @@ 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 = []
-
-        args << "-#{options[:mode]}" if options[:mode]
-        args << "-header" if options[:header]
-        args << File.expand_path(config.database, const_defined?(:Rails) && Rails.respond_to?(:root) ? Rails.root : nil)
-
-        find_cmd_and_exec("sqlite3", *args)
-      end
-
       private
         def initialize_type_map(m)
           super

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.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,5 +1,5 @@
 # frozen_string_literal: true
 
 module ArJdbc
-  VERSION = "71.0.0"
+  VERSION = "72.0.0.alpha1"
 end

data/lib/arjdbc.rb

@@ -12,8 +12,14 @@ 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(
+      "sqlserver", "ActiveRecord::ConnectionAdapters::MSSQLAdapter", "active_record/connection_adapters/mssql_adapter"
+    )
+  end
 else
   warn "activerecord-jdbc-adapter is for use with JRuby only"
 end
 
-require 'arjdbc/version'
+require 'arjdbc/version'

metadata

@@ -1,21 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-jdbc-alt-adapter
 version: !ruby/object:Gem::Version
-  version: 71.0.0
+  version: 72.0.0.alpha1
 platform: java
 authors:
 - Nick Sieger, Ola Bini, Karol Bucek, Jesse Chavez, and JRuby contributors
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-26 00:00:00.000000000 Z
+date: 2025-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.1.3
+        version: 7.2.2
   name: activerecord
   type: :runtime
   prerelease: false
@@ -23,7 +23,7 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 7.1.3
+        version: 7.2.2
 description: 'Fork of the ActiveRecord JDBC adapter with support for SQL Server and
   Azure SQL, for more information and help look at the README file in the github repository.
   AR-JDBC is a database adapter for Rails'' ActiveRecord component designed to be
@@ -110,6 +110,7 @@ files:
 - lib/arjdbc/jdbc/type_converter.rb
 - lib/arjdbc/mssql.rb
 - lib/arjdbc/mssql/adapter.rb
+- lib/arjdbc/mssql/adapter_hash_config.rb
 - lib/arjdbc/mssql/column.rb
 - lib/arjdbc/mssql/connection_methods.rb
 - lib/arjdbc/mssql/database_limits.rb
@@ -134,10 +135,12 @@ files:
 - lib/arjdbc/mssql/utils.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
@@ -151,6 +154,7 @@ files:
 - 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/tasks.rb
@@ -231,9 +235,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.3.26
 signing_key: