activerecord-jdbc-adapter 70.1-java → 71.0-java

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,42 @@ 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|
+            conn.begin
+          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 +71,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 +84,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 +97,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/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,8 @@ require 'arjdbc/abstract/database_statements'
 require 'arjdbc/abstract/statement_cache'
 require 'arjdbc/abstract/transaction_support'
 
+require "arjdbc/abstract/relation_query_attribute_monkey_patch"
+
 module ActiveRecord
   module ConnectionAdapters
     AbstractMysqlAdapter.class_eval do
@@ -23,7 +25,7 @@ module ActiveRecord
     class Mysql2Adapter < AbstractMysqlAdapter
       ADAPTER_NAME = 'Mysql2'
 
-      include Jdbc::ConnectionPoolCallbacks
+      # include Jdbc::ConnectionPoolCallbacks
 
       include ArJdbc::Abstract::ConnectionManagement
       include ArJdbc::Abstract::DatabaseStatements
@@ -33,11 +35,47 @@ module ActiveRecord
 
       include ArJdbc::MySQL
 
-      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
+
+        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
 
-        # configure_connection taken care of at ArJdbc::Abstract::Core
+            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
+
+        @config[:flags] ||= 0
+
+        # 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 ||= @config
       end
 
       def self.database_exists?(config)
@@ -49,13 +87,6 @@ module ActiveRecord
         conn.disconnect! if conn
       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)
-
-        super
-      end
-
       def supports_json?
         !mariadb? && database_version >= '5.7.8'
       end
@@ -96,20 +127,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,11 +200,47 @@ 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
@@ -176,17 +248,24 @@ module ActiveRecord
       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/connection_methods.rb

@@ -126,51 +126,52 @@ ArJdbc::ConnectionMethods.module_eval do
 
   private
 
-  @@mysql_encodings = nil
+  MYSQL_ENCODINGS = {
+    "big5" => "Big5",
+    "dec8" => nil,
+    #"cp850" => "Cp850",
+    "hp8" => nil,
+    #"koi8r" => "KOI8-R",
+    "latin1" => "Cp1252",
+    "latin2" => "ISO8859_2",
+    "swe7" => nil,
+    "ascii" => "US-ASCII",
+    "ujis" => "EUC_JP",
+    "sjis" => "SJIS",
+    "hebrew" => "ISO8859_8",
+    "tis620" => "TIS620",
+    "euckr" => "EUC_KR",
+    #"koi8u" => "KOI8-R",
+    "gb2312" => "EUC_CN",
+    "greek" => "ISO8859_7",
+    "cp1250" => "Cp1250",
+    "gbk" => "GBK",
+    #"latin5" => "ISO-8859-9",
+    "armscii8" => nil,
+    "ucs2" => "UnicodeBig",
+    "cp866" => "Cp866",
+    "keybcs2" => nil,
+    "macce" => "MacCentralEurope",
+    "macroman" => "MacRoman",
+    #"cp852" => "CP852",
+    #"latin7" => "ISO-8859-13",
+    "cp1251" => "Cp1251",
+    "cp1256" => "Cp1256",
+    "cp1257" => "Cp1257",
+    "binary" => false,
+    "geostd8" => nil,
+    "cp932" => "Cp932",
+    #"eucjpms" => "eucJP-ms"
+    "utf8" => "UTF-8",
+    "utf8mb4" => false,
+    "utf16" => false,
+    "utf32" => false,
+  }
+
 
   # @see https://dev.mysql.com/doc/connector-j/5.1/en/connector-j-reference-charsets.html
   def convert_mysql_encoding(encoding) # to charset-name (characterEncoding=...)
-    ( @@mysql_encodings ||= {
-      "big5" => "Big5",
-      "dec8" => nil,
-      #"cp850" => "Cp850",
-      "hp8" => nil,
-      #"koi8r" => "KOI8-R",
-      "latin1" => "Cp1252",
-      "latin2" => "ISO8859_2",
-      "swe7" => nil,
-      "ascii" => "US-ASCII",
-      "ujis" => "EUC_JP",
-      "sjis" => "SJIS",
-      "hebrew" => "ISO8859_8",
-      "tis620" => "TIS620",
-      "euckr" => "EUC_KR",
-      #"koi8u" => "KOI8-R",
-      "gb2312" => "EUC_CN",
-      "greek" => "ISO8859_7",
-      "cp1250" => "Cp1250",
-      "gbk" => "GBK",
-      #"latin5" => "ISO-8859-9",
-      "armscii8" => nil,
-      "ucs2" => "UnicodeBig",
-      "cp866" => "Cp866",
-      "keybcs2" => nil,
-      "macce" => "MacCentralEurope",
-      "macroman" => "MacRoman",
-      #"cp852" => "CP852",
-      #"latin7" => "ISO-8859-13",
-      "cp1251" => "Cp1251",
-      "cp1256" => "Cp1256",
-      "cp1257" => "Cp1257",
-      "binary" => false,
-      "geostd8" => nil,
-      "cp932" => "Cp932",
-      #"eucjpms" => "eucJP-ms"
-      "utf8" => "UTF-8",
-      "utf8mb4" => false,
-      "utf16" => false,
-      "utf32" => false,
-    } )[ encoding ]
+    MYSQL_ENCODINGS[ encoding ]
   end
 
 end