activerecord-jdbc-adapter 70.2-java → 72.0-java

data/lib/arjdbc/abstract/statement_cache.rb

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

data/lib/arjdbc/abstract/transaction_support.rb

@@ -12,11 +12,11 @@ module ArJdbc
       # @since 1.3.0
       # @override
       def supports_savepoints?
-        @connection.supports_savepoints?
+        @raw_connection.supports_savepoints?
       end
 
       def supports_transaction_isolation?
-        @connection.supports_transaction_isolation?
+        @raw_connection.supports_transaction_isolation?
       end
 
       ########################## Transaction Interface ##########################
@@ -24,26 +24,44 @@ module ArJdbc
       # Starts a database transaction.
       # @override
       def begin_db_transaction
-        log('BEGIN', 'TRANSACTION') { @connection.begin }
+        log('BEGIN', 'TRANSACTION') do
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+            result = conn.begin
+            verified!
+            result
+          end
+        end
       end
 
       # Starts a database transaction.
       # @param isolation the transaction isolation to use
       def begin_isolated_db_transaction(isolation)
-        log("BEGIN ISOLATED - #{isolation}", 'TRANSACTION') { @connection.begin(isolation) }
+        log("BEGIN ISOLATED - #{isolation}", 'TRANSACTION') do
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+            conn.begin(isolation)
+          end
+        end
       end
 
       # Commits the current database transaction.
       # @override
       def commit_db_transaction
-        log('COMMIT', 'TRANSACTION') { @connection.commit }
+        log('COMMIT', 'TRANSACTION') do
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+            conn.commit
+          end
+        end
       end
 
       # Rolls back the current database transaction.
       # Called from 'rollback_db_transaction' in the AbstractAdapter
       # @override
       def exec_rollback_db_transaction
-        log('ROLLBACK', 'TRANSACTION') { @connection.rollback }
+        log('ROLLBACK', 'TRANSACTION') do
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+            conn.rollback
+          end
+        end
       end
 
       ########################## Savepoint Interface ############################
@@ -55,7 +73,11 @@ module ArJdbc
       # @since 1.3.0
       # @extension added optional name parameter
       def create_savepoint(name = current_savepoint_name)
-        log("SAVEPOINT #{name}", 'TRANSACTION') { @connection.create_savepoint(name) }
+        log("SAVEPOINT #{name}", 'TRANSACTION') do
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+            conn.create_savepoint(name)
+          end
+        end
       end
 
       # Transaction rollback to a given (previously created) save-point.
@@ -64,7 +86,11 @@ module ArJdbc
       # @param name the save-point name
       # @extension added optional name parameter
       def exec_rollback_to_savepoint(name = current_savepoint_name)
-        log("ROLLBACK TO SAVEPOINT #{name}", 'TRANSACTION') { @connection.rollback_savepoint(name) }
+        log("ROLLBACK TO SAVEPOINT #{name}", 'TRANSACTION') do
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+            conn.rollback_savepoint(name)
+          end
+        end
       end
 
       # Release a previously created save-point.
@@ -73,22 +99,13 @@ module ArJdbc
       # @param name the save-point name
       # @extension added optional name parameter
       def release_savepoint(name = current_savepoint_name)
-        log("RELEASE SAVEPOINT #{name}", 'TRANSACTION') { @connection.release_savepoint(name) }
+        log("RELEASE SAVEPOINT #{name}", 'TRANSACTION') do
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do |conn|
+            conn.release_savepoint(name)
+          end
+        end
       end
 
     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/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/jdbc/column.rb

@@ -12,45 +12,11 @@ module ActiveRecord
     # specific type.
     # @see JdbcAdapter#jdbc_column_class
     class JdbcColumn < Column
-      # @deprecated attribute writers will be removed in 1.4
-      attr_writer :limit, :precision # unless ArJdbc::AR42
-
-      def initialize(config, name, *args)
-        if self.class == JdbcColumn
-          # NOTE: extending classes do not want this if they do they shall call
-          call_discovered_column_callbacks(config) if config
-          default = args.shift
-        else # for extending classes allow ignoring first argument :
-          if ! config.nil? && ! config.is_a?(Hash)
-            default = name; name = config # initialize(name, default, *args)
-          else
-            default = args.shift
-          end
-        end
-
-        super(name, default, *args)
-        init_column(name, default, *args)
-      end
-
-      # Additional column initialization for sub-classes.
-      def init_column(*args); end
 
       # Similar to `ActiveRecord`'s `extract_value_from_default(default)`.
       # @return default value for a column (possibly extracted from driver value)
       def default_value(value); value; end
 
-      protected
-
-      # @private
-      def call_discovered_column_callbacks(config)
-        dialect = (config[:dialect] || config[:driver]).to_s
-        for matcher, block in self.class.column_types
-          block.call(config, self) if matcher === dialect
-        end
-      end
-
-      public
-
       # Returns the available column types
       # @return [Hash] of (matcher, block) pairs
       def self.column_types

data/lib/arjdbc/jdbc/connection_methods.rb

@@ -7,7 +7,7 @@ module ArJdbc
 
     def jdbc_connection(config)
       adapter_class = config[:adapter_class] || ::ActiveRecord::ConnectionAdapters::JdbcAdapter
-      adapter_class.new(nil, logger, nil, config)
+      adapter_class.new(config)
     end
 
     def jndi_connection(config); jdbc_connection(config) end

data/lib/arjdbc/mysql/adapter.rb

@@ -11,6 +11,10 @@ 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
   module ConnectionAdapters
     AbstractMysqlAdapter.class_eval do
@@ -23,7 +27,7 @@ module ActiveRecord
     class Mysql2Adapter < AbstractMysqlAdapter
       ADAPTER_NAME = 'Mysql2'
 
-      include Jdbc::ConnectionPoolCallbacks
+      # include Jdbc::ConnectionPoolCallbacks
 
       include ArJdbc::Abstract::ConnectionManagement
       include ArJdbc::Abstract::DatabaseStatements
@@ -32,28 +36,52 @@ module ActiveRecord
       include ArJdbc::Abstract::TransactionSupport
 
       include ArJdbc::MySQL
+      include ArJdbc::MysqlConfig
 
-      def initialize(connection, logger, connection_options, config)
-        superclass_config = config.reverse_merge(prepared_statements: false)
-        super(connection, logger, connection_options, superclass_config)
+      class << self
+        def jdbc_connection_class
+          ::ActiveRecord::ConnectionAdapters::MySQLJdbcConnection
+        end
 
-        # configure_connection taken care of at ArJdbc::Abstract::Core
-      end
+        def new_client(conn_params, adapter_instance)
+          jdbc_connection_class.new(conn_params, adapter_instance)
+        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
+        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
 
-      def check_version
-        # for JNDI, don't check version as the whole connection should be lazy
-        return if ::ActiveRecord::ConnectionAdapters::JdbcConnection.jndi_config?(config)
+      # 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
+
+        @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"
+        # else
+        #   @config[:flags] |= ::Mysql2::Client::FOUND_ROWS
+        # end
+
+        @connection_parameters = conn_params
       end
 
       def supports_json?
@@ -96,20 +124,25 @@ module ActiveRecord
         !READ_QUERY.match?(sql)
       end
 
-      def explain(arel, binds = [])
-        sql     = "EXPLAIN #{to_sql(arel, binds)}"
-        start   = Concurrent.monotonic_time
-        result  = exec_query(sql, "EXPLAIN", binds)
-        elapsed = Concurrent.monotonic_time - start
+      def explain(arel, binds = [], options = [])
+        sql     = build_explain_clause(options) + " " + to_sql(arel, binds)
+        start   = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        result  = internal_exec_query(sql, "EXPLAIN", binds)
+        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
 
         MySQL::ExplainPrettyPrinter.new.pp(result, elapsed)
       end
 
-      # Reloading the type map in abstract/statement_cache.rb blows up postgres
-      def clear_cache!
-        # FIXME: This seems to have disappeared in Rails 7?
-        # reload_type_map
-        super
+      def build_explain_clause(options = [])
+        return "EXPLAIN" if options.empty?
+
+        explain_clause = "EXPLAIN #{options.join(" ").upcase}"
+        
+        if analyze_without_explain? && explain_clause.include?("ANALYZE")
+          explain_clause.sub("EXPLAIN ", "")
+        else
+          explain_clause
+        end
       end
 
       def each_hash(result) # :nodoc:
@@ -164,29 +197,72 @@ module ActiveRecord
       # CONNECTION MANAGEMENT ====================================
       #++
 
+      def active?
+        !(@raw_connection.nil? || @raw_connection.closed?) && @lock.synchronize { @raw_connection&.ping } || false
+      end
+
       alias :reset! :reconnect!
 
+      # Disconnects from the database if already connected.
+      # Otherwise, this method does nothing.
+      def disconnect!
+        @lock.synchronize do
+          super
+          @raw_connection&.close
+          @raw_connection = nil
+        end
+      end
+
+      def discard! # :nodoc:
+        @lock.synchronize do
+          super
+          @raw_connection&.automatic_close = false
+          @raw_connection = nil
+        end
+      end
+
       #
 
       private
+      # https://mariadb.com/kb/en/analyze-statement/
+      def analyze_without_explain?
+        mariadb? && database_version >= "10.1.0"
+      end
+
+      def text_type?(type)
+        TYPE_MAP.lookup(type).is_a?(Type::String) || TYPE_MAP.lookup(type).is_a?(Type::Text)
+      end
+
+      def configure_connection
+        # @raw_connection.query_options[:as] = :array
+        # @raw_connection.query_options[:database_timezone] = default_timezone
+        super
+      end
 
       # 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
-        @full_version ||= @connection.full_version
-      end
-
-      def jdbc_connection_class(spec)
-        ::ActiveRecord::ConnectionAdapters::MySQLJdbcConnection
+        @full_version ||= any_raw_connection.full_version
       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/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'