activerecord-jdbc-adapter 71.0-java → 72.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4450a117ffce0ffee520932ab4872346aa4c7192f36ebea911db380b9d5cca89
-  data.tar.gz: ec27e839eee02e6c3cbaba4d2a48fc46375c11b7de2f1a420d89ea4574152ef4
+  metadata.gz: f1b3740f2a2d3d25cd4ab6bf0538e3848717ac46b27f793d67b876b424a9cd02
+  data.tar.gz: b55adb9d8ce1abbfc66c2d2ea17e70f861a877d673ada18898230503bb740ba8
 SHA512:
-  metadata.gz: bc36b55927d27830d0ae0e6c424e799ccb4f34c44765fbc42b90ba49071b080ebf025adfa3568d254e75e8b137f5fc7c00b2d9004bcd0d412831eb5eebfb03ca
-  data.tar.gz: fdcac70debef8aba9131e875d05578d3308a34222d06738e7eca008ea51f7b89b0ee05a360f7273d9ebc2a70a62d3b753e70ad0c99e5707fb97ae81dffb2529e
+  metadata.gz: a8c590ce9f1fda81cb270a53e8ddb07f21c46bd757ea11f6e8ee196486cdcdb843131230128cf1351787caaaa9f5a76291e33fb265b80f16128c7e0a4482187e
+  data.tar.gz: '0479e365e2de0b5f866acd5872e41a96f693bd85c82fc0758a38cc03b365e9a93e3e3124d011fe214b9bb54e3317d17688d752aed18ad152b8035dec8b688462'

data/.github/workflows/ruby.yml

@@ -9,9 +9,9 @@ name: Ruby
 
 on:
   push:
-    branches: [ master ]
+    branches: [ master, 72-stable ]
   pull_request:
-    branches: [ master ]
+    branches: [ master, 72-stable ]
 
 permissions:
   contents: read
@@ -24,10 +24,10 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby-version: ['jruby-head']
+        ruby-version: ['jruby-9.4.14.0']
         db: ['mysql2']
         test_targets: ["rails:test_mysql2"]
-        ar_version: ["7-1-stable"]
+        ar_version: ["7-2-stable"]
         prepared_statements: ['false', 'true']
         driver: ['MySQL']
 
@@ -76,10 +76,10 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby-version: [ 'jruby-head' ]
+        ruby-version: [ 'jruby-9.4.14.0' ]
         db: [ 'postgresql' ]
         test_targets: [ "rails:test_postgresql" ]
-        ar_version: ["7-1-stable"]
+        ar_version: ["7-2-stable"]
         prepared_statements: [ 'false', 'true' ]
 
     services:
@@ -126,10 +126,10 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby-version: ['jruby-head']
+        ruby-version: ['jruby-9.4.14.0']
         db: ['sqlite3']
         test_targets: ["rails:test_sqlite3"]
-        ar_version: ["7-1-stable"]
+        ar_version: ["7-2-stable"]
 
     env:
       DB: ${{ matrix.db }}
@@ -158,7 +158,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby-version: ['jruby-head']
+        ruby-version: ['jruby-9.4.14.0']
         db: ['mysql2']
         test_targets: ["db:mysql test_mysql2"]
         prepared_statements: ['false', 'true']
@@ -203,7 +203,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby-version: ['jruby-head']
+        ruby-version: ['jruby-9.4.14.0']
         db: ['postgresql']
         test_targets: ["db:postgresql test_postgresql"]
         prepared_statements: ['false', 'true']
@@ -250,7 +250,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby-version: ['jruby-head']
+        ruby-version: ['jruby-9.4.14.0']
         db: ['sqlite3']
         test_targets: ['test_sqlite3']
 

data/README.md

@@ -56,7 +56,7 @@ adapters are available:
 
 ```yml
 development:
-  adapter: mysql2 # or mysql
+  adapter: mysql2
   database: blog_development
   username: blog
   password: 1234
@@ -80,7 +80,7 @@ or preferably using the *properties:* syntax:
 
 ```yml
 production:
-  adapter: mysql
+  adapter: mysql2
   username: blog
   password: blog
   url: "jdbc:mysql://localhost:3306/blog?profileSQL=true"

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/lib/arjdbc/abstract/core.rb

@@ -60,7 +60,16 @@ module ArJdbc
       # this version of log() automatically fills type_casted_binds from binds if necessary
       def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil, async: false)
         if binds.any? && (type_casted_binds.nil? || type_casted_binds.empty?)
-          type_casted_binds = ->{ binds.map(&:value_for_database) } # extract_raw_bind_values
+          type_casted_binds = lambda {
+            # extract_raw_bind_values
+            binds.map do |bind|
+              if bind.respond_to?(:value_for_database)
+                bind.value_for_database
+              else
+                bind
+              end
+            end
+          }
         end
         super
       end

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/abstract/transaction_support.rb

@@ -26,7 +26,9 @@ module ArJdbc
       def begin_db_transaction
         log('BEGIN', 'TRANSACTION') do
           with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
-            conn.begin
+            result = conn.begin
+            verified!
+            result
           end
         end
       end

data/lib/arjdbc/jdbc/adapter.rb

@@ -5,7 +5,6 @@ require 'active_record/connection_adapters/abstract_adapter'
 
 require 'arjdbc/version'
 require 'arjdbc/jdbc/java'
-require 'arjdbc/jdbc/base_ext'
 require 'arjdbc/jdbc/error'
 require 'arjdbc/jdbc/connection_methods'
 require 'arjdbc/jdbc/column'

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,16 +81,7 @@ module ActiveRecord
         #   @config[:flags] |= ::Mysql2::Client::FOUND_ROWS
         # end
 
-        @connection_parameters ||= @config
-      end
-
-      def self.database_exists?(config)
-        conn = ActiveRecord::Base.mysql2_connection(config)
-        conn && conn.really_valid?
-      rescue ActiveRecord::NoDatabaseError
-        false
-      ensure
-        conn.disconnect! if conn
+        @connection_parameters = conn_params
       end
 
       def supports_json?
@@ -244,7 +241,7 @@ module ActiveRecord
 
       # e.g. "5.7.20-0ubuntu0.16.04.1"
       def full_version
-        schema_cache.database_version.full_version_string
+        database_version.full_version_string
       end
 
       def get_full_version

data/lib/arjdbc/mysql/adapter_hash_config.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module ArJdbc
+  module MysqlConfig
+    def build_connection_config(config)
+      config = config.deep_dup
+
+      load_jdbc_driver
+
+      # don't set driver if it's explicitly set to false
+      # allow Java's service discovery mechanism (with connector/j 8.0)
+      config[:driver] ||= database_driver_name if config[:driver] != false
+
+      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"] ||= default_zero_date_time_behavior(config[:driver])
+
+      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
+
+    def default_zero_date_time_behavior(driver)
+      return "CONVERT_TO_NULL" if driver == false
+
+      return "CONVERT_TO_NULL" if driver.start_with?("com.mysql.cj.")
+
+      "convertToNull"
+    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'
 
@@ -344,7 +345,7 @@ module ArJdbc
           type.typname AS name,
           type.OID AS oid,
           n.nspname AS schema,
-          string_agg(enum.enumlabel, ',' ORDER BY enum.enumsortorder) AS value
+          array_agg(enum.enumlabel ORDER BY enum.enumsortorder) AS value
         FROM pg_enum AS enum
         JOIN pg_type AS type ON (type.oid = enum.enumtypid)
         JOIN pg_namespace n ON type.typnamespace = n.oid
@@ -841,6 +842,15 @@ module ActiveRecord::ConnectionAdapters
     # setting, you should immediately run <tt>bin/rails db:migrate</tt> to update the types in your schema.rb.
     class_attribute :datetime_type, default: :timestamp
 
+    ##
+    # :singleton-method:
+    # Toggles automatic decoding of date columns.
+    #
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.select_value("select '2024-01-01'::date").class #=> String
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_dates = true
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.select_value("select '2024-01-01'::date").class #=> Date
+    class_attribute :decode_dates, default: false
+
     # Try to use as much of the built in postgres logic as possible
     # maybe someday we can extend the actual adapter
     include ActiveRecord::ConnectionAdapters::PostgreSQL::ReferentialIntegrity
@@ -854,7 +864,11 @@ module ActiveRecord::ConnectionAdapters
     include ArJdbc::Abstract::DatabaseStatements
     include ArJdbc::Abstract::StatementCache
     include ArJdbc::Abstract::TransactionSupport
+    include ArJdbc::PostgreSQLConfig
+
+    # NOTE: after AR refactor quote_column_name became class and instance method
     include ArJdbc::PostgreSQL
+    extend ArJdbc::PostgreSQL
 
     require 'arjdbc/postgresql/oid_types'
     include ::ArJdbc::PostgreSQL::OIDTypes
@@ -900,7 +914,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 +927,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'