activerecord-jdbc-alt-adapter 70.2.0-java → 71.0.0.alpha2-java

data/lib/arjdbc/mysql/adapter.rb

@@ -23,7 +23,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 +33,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
+
+            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
 
-        # configure_connection taken care of at ArJdbc::Abstract::Core
+        @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 +85,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 +125,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 +198,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 +246,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/postgresql/adapter.rb

@@ -13,6 +13,7 @@ require 'active_record/connection_adapters/postgresql/schema_dumper'
 require 'active_record/connection_adapters/postgresql/schema_statements'
 require 'active_record/connection_adapters/postgresql/type_metadata'
 require 'active_record/connection_adapters/postgresql/utils'
+
 require 'arjdbc/abstract/core'
 require 'arjdbc/abstract/connection_management'
 require 'arjdbc/abstract/database_statements'
@@ -21,6 +22,8 @@ require 'arjdbc/abstract/transaction_support'
 require 'arjdbc/postgresql/base/array_decoder'
 require 'arjdbc/postgresql/base/array_encoder'
 require 'arjdbc/postgresql/name'
+require 'arjdbc/postgresql/schema_statements'
+
 require 'active_model'
 
 module ArJdbc
@@ -35,11 +38,6 @@ module ArJdbc
     # @private
     Type = ::ActiveRecord::Type
 
-    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
-    def self.jdbc_connection_class
-      ::ActiveRecord::ConnectionAdapters::PostgreSQLJdbcConnection
-    end
-
     # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_column_class
     def jdbc_column_class; ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn end
 
@@ -52,8 +50,8 @@ module ArJdbc
     def redshift?
       # SELECT version() :
       #  PostgreSQL 8.0.2 on i686-pc-linux-gnu, compiled by GCC gcc (GCC) 3.4.2 20041017 (Red Hat 3.4.2-6.fc3), Redshift 1.0.647
-      if ( redshift = config[:redshift] ).nil?
-        redshift = !! (@connection.database_product || '').index('Redshift')
+      if (redshift = @config[:redshift]).nil?
+        redshift = !! (valid_raw_connection.database_product || '').index('Redshift')
       end
       redshift
     end
@@ -73,8 +71,8 @@ module ArJdbc
         # see http://jdbc.postgresql.org/documentation/91/connect.html
         # self.set_client_encoding(encoding)
       #end
-      self.client_min_messages = config[:min_messages] || 'warning'
-      self.schema_search_path = config[:schema_search_path] || config[:schema_order]
+      self.client_min_messages = @config[:min_messages] || 'warning'
+      self.schema_search_path = @config[:schema_search_path] || @config[:schema_order]
 
       # Use standard-conforming strings if available so we don't have to do the E'...' dance.
       set_standard_conforming_strings
@@ -93,7 +91,7 @@ module ArJdbc
 
       # SET statements from :variables config hash
       # http://www.postgresql.org/docs/8.3/static/sql-set.html
-      (config[:variables] || {}).map do |k, v|
+      (@config[:variables] || {}).map do |k, v|
         if v == ':default' || v == :default
           # Sets the value to the global or compile default
           execute("SET SESSION #{k} TO DEFAULT", 'SCHEMA')
@@ -101,6 +99,8 @@ module ArJdbc
           execute("SET SESSION #{k} TO #{quote(v)}", 'SCHEMA')
         end
       end
+
+      reload_type_map
     end
 
     # @private
@@ -127,7 +127,7 @@ module ArJdbc
       inet:         { name: 'inet' },
       int4range:    { name: 'int4range' },
       int8range:    { name: 'int8range' },
-      integer:      { name: 'integer' },
+      integer:      { name: 'integer', limit: 4 },
       interval:     { name: 'interval' },
       json:         { name: 'json' },
       jsonb:        { name: 'jsonb' },
@@ -232,6 +232,10 @@ module ArJdbc
     alias supports_insert_on_duplicate_update? supports_insert_on_conflict?
     alias supports_insert_conflict_target? supports_insert_on_conflict?
 
+    def supports_identity_columns? # :nodoc:
+      database_version >= 10_00_00 # >= 10.0
+    end
+
     def index_algorithms
       { concurrently: 'CONCURRENTLY' }
     end
@@ -297,14 +301,21 @@ module ArJdbc
       query_value("SELECT pg_advisory_unlock(#{lock_id})")
     end
 
-    def enable_extension(name)
-      exec_query("CREATE EXTENSION IF NOT EXISTS \"#{name}\"").tap {
-        reload_type_map
-      }
+    def enable_extension(name, **)
+      schema, name = name.to_s.split(".").values_at(-2, -1)
+      sql = +"CREATE EXTENSION IF NOT EXISTS \"#{name}\""
+      sql << " SCHEMA #{schema}" if schema
+
+      internal_exec_query(sql).tap { reload_type_map }
     end
 
-    def disable_extension(name)
-      exec_query("DROP EXTENSION IF EXISTS \"#{name}\" CASCADE").tap {
+    # Removes an extension from the database.
+    #
+    # [<tt>:force</tt>]
+    #   Set to +:cascade+ to drop dependent objects as well.
+    #   Defaults to false.
+    def disable_extension(name, force: false)
+      internal_exec_query("DROP EXTENSION IF EXISTS \"#{name}\"#{' CASCADE' if force == :cascade}").tap {
         reload_type_map
       }
     end
@@ -318,7 +329,7 @@ module ArJdbc
     end
 
     def extensions
-      exec_query("SELECT extname FROM pg_extension", "SCHEMA").cast_values
+      internal_exec_query("SELECT extname FROM pg_extension", "SCHEMA", allow_retry: true, materialize_transactions: false).cast_values
     end
 
     # Returns a list of defined enum types, and their values.
@@ -370,7 +381,7 @@ module ArJdbc
 
     def get_database_version # :nodoc:
       begin
-        version = @connection.database_product
+        version = valid_raw_connection.database_product
         if match = version.match(/([\d\.]*\d).*?/)
           version = match[1].split('.').map(&:to_i)
           # PostgreSQL version representation does not have more than 4 digits
@@ -426,8 +437,7 @@ module ArJdbc
       end
     end
 
-
-    def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
+    def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil) # :nodoc:
       val = super
       if !use_insert_returning? && pk
         unless sequence_name
@@ -464,18 +474,23 @@ module ArJdbc
     # since apparently calling close on the statement object
     # doesn't always free the server resources and calling
     # 'DISCARD ALL' fails if we are inside a transaction
-    def clear_cache!
-      super
-      # Make sure all query plans are *really* gone
-      @connection.execute 'DEALLOCATE ALL' if active?
-    end
+    # def clear_cache!
+    #   super
+    #   # Make sure all query plans are *really* gone
+    #   @connection.execute 'DEALLOCATE ALL' if active?
+    # end
 
     def reset!
-      clear_cache!
-      reset_transaction
-      @connection.rollback # Have to deal with rollbacks differently than the AR adapter
-      @connection.execute 'DISCARD ALL'
-      @connection.configure_connection
+      @lock.synchronize do
+        return connect! unless @raw_connection
+
+        # Have to deal with rollbacks differently than the AR adapter
+        @raw_connection.rollback
+
+        @raw_connection.execute("DISCARD ALL")
+
+        super
+      end
     end
 
     def default_sequence_name(table_name, pk = "id") #:nodoc:
@@ -660,6 +675,8 @@ module ArJdbc
         ::ActiveRecord::LockWaitTimeout.new(message, sql: sql, binds: binds)
       when /canceling statement/ # This needs to come after lock timeout because the lock timeout message also contains "canceling statement"
         ::ActiveRecord::QueryCanceled.new(message, sql: sql, binds: binds)
+      when /relation "animals" does not exist/i
+        ::ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
       else
         super
       end
@@ -742,7 +759,7 @@ module ActiveRecord::ConnectionAdapters
     include ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements
     include ActiveRecord::ConnectionAdapters::PostgreSQL::Quoting
 
-    include Jdbc::ConnectionPoolCallbacks
+    # include Jdbc::ConnectionPoolCallbacks
 
     include ArJdbc::Abstract::Core
     include ArJdbc::Abstract::ConnectionManagement
@@ -753,6 +770,7 @@ module ActiveRecord::ConnectionAdapters
 
     require 'arjdbc/postgresql/oid_types'
     include ::ArJdbc::PostgreSQL::OIDTypes
+    include ::ArJdbc::PostgreSQL::SchemaStatements
 
     include ::ArJdbc::PostgreSQL::ColumnHelpers
 
@@ -761,16 +779,27 @@ module ActiveRecord::ConnectionAdapters
     # AR expects OID to be available on the adapter
     OID = ActiveRecord::ConnectionAdapters::PostgreSQL::OID
 
-    def initialize(connection, logger = nil, connection_parameters = nil, config = {})
+    class << self
+      def jdbc_connection_class
+        ::ActiveRecord::ConnectionAdapters::PostgreSQLJdbcConnection
+      end
+
+      def new_client(conn_params, adapter_instance)
+        jdbc_connection_class.new(conn_params, adapter_instance)
+      end
+    end
+
+    def initialize(...)
+      super
+
+      conn_params = @config.compact
+
+      @connection_parameters = conn_params
+
       # @local_tz is initialized as nil to avoid warnings when connect tries to use it
       @local_tz = nil
       @max_identifier_length = nil
 
-      super(connection, logger, config) # configure_connection happens in super
-
-      @type_map = Type::HashLookupTypeMap.new
-      initialize_type_map
-
       @use_insert_returning = @config.key?(:insert_returning) ?
         self.class.type_cast_config_to_boolean(@config[:insert_returning]) : true
     end
@@ -793,10 +822,6 @@ module ActiveRecord::ConnectionAdapters
     public :sql_for_insert
     alias :postgresql_version :database_version
 
-    def jdbc_connection_class(spec)
-      ::ArJdbc::PostgreSQL.jdbc_connection_class
-    end
-
     private
 
     FEATURE_NOT_SUPPORTED = "0A000" # :nodoc:
@@ -829,8 +854,10 @@ module ActiveRecord::ConnectionAdapters
 
       type_casted_binds = type_casted_binds(binds)
       log(sql, name, binds, type_casted_binds, async: async) do
-        ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-          @connection.exec_params(sql, type_casted_binds)
+        with_raw_connection do |conn|
+          result = conn.exec_params(sql, type_casted_binds)
+          verified!
+          result
         end
       end
     end

data/lib/arjdbc/postgresql/oid_types.rb

@@ -67,28 +67,6 @@ module ArJdbc
 
     # @private
     module OIDTypes
-
-      # @override
-      def enable_extension(name)
-        result = super(name)
-        @extensions = nil
-        reload_type_map
-        result
-      end
-
-      # @override
-      def disable_extension(name)
-        result = super(name)
-        @extensions = nil
-        reload_type_map
-        result
-      end
-
-      # @override
-      def extensions
-        @extensions ||= super
-      end
-
       def get_oid_type(oid, fmod, column_name, sql_type = '') # :nodoc:
         # Note: type_map is storing a bunch of oid type prefixed with a namespace even
         # if they are not namespaced (e.g. ""."oidvector").  builtin types which are
@@ -118,8 +96,15 @@ module ArJdbc
       end
 
       def reload_type_map
-          type_map.clear
+        @lock.synchronize do
+          if @type_map
+            type_map.clear
+          else
+            @type_map = Type::HashLookupTypeMap.new
+          end
+
           initialize_type_map
+        end
       end
 
         def initialize_type_map_inner(m)
@@ -274,10 +259,6 @@ module ArJdbc
         $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
       end
 
-      def extract_limit(sql_type)
-        $1.to_i if sql_type =~ /\((.*)\)/
-      end
-
       # Support arrays/ranges for defining attributes that don't exist in the db
       ActiveRecord::Type.add_modifier({ array: true }, OID::Array, adapter: :postgresql)
       ActiveRecord::Type.add_modifier({ range: true }, OID::Range, adapter: :postgresql)

data/lib/arjdbc/postgresql/schema_statements.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module ArJdbc
+  module PostgreSQL
+    module SchemaStatements
+      ForeignKeyDefinition = ActiveRecord::ConnectionAdapters::ForeignKeyDefinition
+      Utils = ActiveRecord::ConnectionAdapters::PostgreSQL::Utils
+
+      def foreign_keys(table_name)
+        scope = quoted_scope(table_name)
+        fk_info = internal_exec_query(<<~SQL, "SCHEMA", allow_retry: true, materialize_transactions: false)
+          SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete, c.convalidated AS valid, c.condeferrable AS deferrable, c.condeferred AS deferred, c.conkey, c.confkey, c.conrelid, c.confrelid
+          FROM pg_constraint c
+          JOIN pg_class t1 ON c.conrelid = t1.oid
+          JOIN pg_class t2 ON c.confrelid = t2.oid
+          JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
+          JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
+          JOIN pg_namespace t3 ON c.connamespace = t3.oid
+          WHERE c.contype = 'f'
+            AND t1.relname = #{scope[:name]}
+            AND t3.nspname = #{scope[:schema]}
+          ORDER BY c.conname
+        SQL
+
+        fk_info.map do |row|
+          to_table = Utils.unquote_identifier(row["to_table"])
+          # conkey = row["conkey"].scan(/\d+/).map(&:to_i)
+          # confkey = row["confkey"].scan(/\d+/).map(&:to_i)
+          conkey = row["conkey"]
+          confkey = row["confkey"]
+
+          if conkey.size > 1
+            column = column_names_from_column_numbers(row["conrelid"], conkey)
+            primary_key = column_names_from_column_numbers(row["confrelid"], confkey)
+          else
+            column = Utils.unquote_identifier(row["column"])
+            primary_key = row["primary_key"]
+          end
+
+          options = {
+            column: column,
+            name: row["name"],
+            primary_key: primary_key
+          }
+
+          options[:on_delete] = extract_foreign_key_action(row["on_delete"])
+          options[:on_update] = extract_foreign_key_action(row["on_update"])
+          options[:deferrable] = extract_constraint_deferrable(row["deferrable"], row["deferred"])
+
+          options[:validate] = row["valid"]
+
+          ForeignKeyDefinition.new(table_name, to_table, options)
+        end
+      end
+    end
+  end
+end