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

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'