activerecord-jdbc-adapter 60.4-java → 61.2-java

data/lib/arjdbc/postgresql/adapter.rb

@@ -48,46 +48,6 @@ module ArJdbc
       ADAPTER_NAME
     end
 
-    def get_database_version # :nodoc:
-      begin
-        version = @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
-          # From version 10 onwards, PG has changed its versioning policy to
-          # limit it to only 2 digits. i.e. in 10.x, 10 being the major
-          # version and x representing the patch release
-          # Refer to:
-          #   https://www.postgresql.org/support/versioning/
-          #   https://www.postgresql.org/docs/10/static/libpq-status.html -> PQserverVersion()
-          # for more info
-
-          if version.size >= 3
-            (version[0] * 100 + version[1]) * 100 + version[2]
-          elsif version.size == 2
-            if version[0] >= 10
-              version[0] * 100 * 100 + version[1]
-            else
-              (version[0] * 100 + version[1]) * 100
-            end
-          elsif version.size == 1
-            version[0] * 100 * 100
-          else
-            0
-          end
-        else
-          0
-        end
-      end
-    end
-
-    def check_version # :nodoc:
-      if database_version < 90300
-        raise "Your version of PostgreSQL (#{database_version}) is too old. Active Record supports PostgreSQL >= 9.3."
-      end
-    end
-
-
     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
@@ -127,6 +87,9 @@ module ArJdbc
         execute("SET time zone '#{tz}'", 'SCHEMA')
       end unless redshift?
 
+      # Set interval output format to ISO 8601 for ease of parsing by ActiveSupport::Duration.parse
+      execute("SET intervalstyle = iso_8601", "SCHEMA")
+
       # SET statements from :variables config hash
       # http://www.postgresql.org/docs/8.3/static/sql-set.html
       (config[:variables] || {}).map do |k, v|
@@ -209,6 +172,10 @@ module ArJdbc
       true
     end
 
+    def supports_partitioned_indexes?
+      database_version >= 110_000
+    end
+
     def supports_partial_index?
       true
     end
@@ -225,6 +192,10 @@ module ArJdbc
       true
     end
 
+    def supports_check_constraints?
+      true
+    end
+
     def supports_validate_constraints?
       true
     end
@@ -288,7 +259,7 @@ module ArJdbc
       database_version >= 90300
     end
 
-    def supports_foreign_tables? # we don't really support this yet, its a reminder :)
+    def supports_foreign_tables?
       database_version >= 90300
     end
 
@@ -311,11 +282,6 @@ module ArJdbc
       true
     end
 
-    # From AR 5.1 postgres_adapter.rb
-    def default_index_type?(index) # :nodoc:
-      index.using == :btree || super
-    end
-
     def get_advisory_lock(lock_id) # :nodoc:
       unless lock_id.is_a?(Integer) && lock_id.bit_length <= 63
         raise(ArgumentError, "PostgreSQL requires advisory lock ids to be a signed 64 bit integer")
@@ -369,6 +335,65 @@ module ArJdbc
       @use_insert_returning
     end
 
+    def get_database_version # :nodoc:
+      begin
+        version = @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
+          # From version 10 onwards, PG has changed its versioning policy to
+          # limit it to only 2 digits. i.e. in 10.x, 10 being the major
+          # version and x representing the patch release
+          # Refer to:
+          #   https://www.postgresql.org/support/versioning/
+          #   https://www.postgresql.org/docs/10/static/libpq-status.html -> PQserverVersion()
+          # for more info
+
+          if version.size >= 3
+            (version[0] * 100 + version[1]) * 100 + version[2]
+          elsif version.size == 2
+            if version[0] >= 10
+              version[0] * 100 * 100 + version[1]
+            else
+              (version[0] * 100 + version[1]) * 100
+            end
+          elsif version.size == 1
+            version[0] * 100 * 100
+          else
+            0
+          end
+        else
+          0
+        end
+      end
+    end
+
+    def default_index_type?(index) # :nodoc:
+      index.using == :btree || super
+    end
+
+    def build_insert_sql(insert) # :nodoc:
+      sql = +"INSERT #{insert.into} #{insert.values_list}"
+
+      if insert.skip_duplicates?
+        sql << " ON CONFLICT #{insert.conflict_target} DO NOTHING"
+      elsif insert.update_duplicates?
+        sql << " ON CONFLICT #{insert.conflict_target} DO UPDATE SET "
+        sql << insert.touch_model_timestamps_unless { |column| "#{insert.model.quoted_table_name}.#{column} IS NOT DISTINCT FROM excluded.#{column}" }
+        sql << insert.updatable_columns.map { |column| "#{column}=excluded.#{column}" }.join(",")
+      end
+
+      sql << " RETURNING #{insert.returning}" if insert.returning
+      sql
+    end
+
+    def check_version # :nodoc:
+      if database_version < 90300
+        raise "Your version of PostgreSQL (#{database_version}) is too old. Active Record supports PostgreSQL >= 9.3."
+      end
+    end
+
+
     def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
       val = super
       if !use_insert_returning? && pk
@@ -384,11 +409,7 @@ module ArJdbc
     end
 
     def execute_batch(statements, name = nil)
-      if statements.is_a? Array
-        execute(combine_multi_statements(statements), name)
-      else
-        execute(statements, name)
-      end
+      execute(combine_multi_statements(statements), name)
     end
 
     def explain(arel, binds = [])
@@ -398,7 +419,7 @@ module ArJdbc
 
     # from ActiveRecord::ConnectionAdapters::PostgreSQL::DatabaseStatements
     READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
-      :begin, :commit, :explain, :select, :set, :show, :release, :savepoint, :rollback, :with
+      :close, :declare, :fetch, :move, :set, :show
     ) # :nodoc:
     private_constant :READ_QUERY
 
@@ -434,27 +455,8 @@ module ArJdbc
       exec_query("SELECT currval('#{sequence_name}')", 'SQL')
     end
 
-    def build_insert_sql(insert) # :nodoc:
-      sql = +"INSERT #{insert.into} #{insert.values_list}"
-
-      if insert.skip_duplicates?
-        sql << " ON CONFLICT #{insert.conflict_target} DO NOTHING"
-      elsif insert.update_duplicates?
-        sql << " ON CONFLICT #{insert.conflict_target} DO UPDATE SET "
-        sql << insert.updatable_columns.map { |column| "#{column}=excluded.#{column}" }.join(",")
-      end
-
-      sql << " RETURNING #{insert.returning}" if insert.returning
-      sql
-    end
-
-    def build_truncate_statements(*table_names)
-      ["TRUNCATE TABLE #{table_names.flatten.map(&method(:quote_table_name)).join(", ")}"]
-    end
-
-    def truncate(table_name, name = nil)
-      ActiveRecord::Base.clear_query_caches_for_current_thread if @query_cache_enabled
-      execute("TRUNCATE TABLE #{quote_table_name(table_name)}", name)
+    def build_truncate_statements(table_names)
+      ["TRUNCATE TABLE #{table_names.map(&method(:quote_table_name)).join(", ")}"]
     end
 
     def all_schemas
@@ -541,6 +543,16 @@ module ArJdbc
 
     # Returns the list of a table's column names, data types, and default values.
     #
+    # The underlying query is roughly:
+    #  SELECT column.name, column.type, default.value, column.comment
+    #    FROM column LEFT JOIN default
+    #      ON column.table_id = default.table_id
+    #     AND column.num = default.column_num
+    #   WHERE column.table_id = get_table_id('table_name')
+    #     AND column.num > 0
+    #     AND NOT column.is_dropped
+    #   ORDER BY column.num
+    #
     # If the table name is not prefixed with a schema, the database will
     # take the first match from the schema search path.
     #

data/lib/arjdbc/postgresql/column.rb

@@ -48,7 +48,7 @@ module ArJdbc
       end
 
       def has_default_function?(default_value, default)
-        !default_value && %r{\w+\(.*\)|\(.*\)::\w+|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
+        !default_value && default && %r{\w+\(.*\)|\(.*\)::\w+|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
       end
     end
 

data/lib/arjdbc/postgresql/oid_types.rb

@@ -145,7 +145,7 @@ module ArJdbc
         m.register_type 'uuid', OID::Uuid.new
         m.register_type 'xml', OID::Xml.new
         m.register_type 'tsvector', OID::SpecializedString.new(:tsvector)
-        m.register_type 'macaddr', OID::SpecializedString.new(:macaddr)
+        m.register_type 'macaddr', OID::Macaddr.new
         m.register_type 'citext', OID::SpecializedString.new(:citext)
         m.register_type 'ltree', OID::SpecializedString.new(:ltree)
         m.register_type 'line', OID::SpecializedString.new(:line)
@@ -155,9 +155,9 @@ module ArJdbc
         m.register_type 'polygon', OID::SpecializedString.new(:polygon)
         m.register_type 'circle', OID::SpecializedString.new(:circle)
 
-        m.register_type 'interval' do |_, _, sql_type|
+        m.register_type 'interval' do |*args, sql_type|
           precision = extract_precision(sql_type)
-          OID::SpecializedString.new(:interval, precision: precision)
+          OID::Interval.new(precision: precision)
         end
 
         register_class_with_precision m, 'time', Type::Time
@@ -244,6 +244,7 @@ module ArJdbc
       ActiveRecord::Type.register(:enum, OID::Enum, adapter: :postgresql)
       ActiveRecord::Type.register(:hstore, OID::Hstore, adapter: :postgresql)
       ActiveRecord::Type.register(:inet, OID::Inet, adapter: :postgresql)
+      ActiveRecord::Type.register(:interval, OID::Interval, adapter: :postgresql)
       ActiveRecord::Type.register(:json, Type::Json, adapter: :postgresql)
       ActiveRecord::Type.register(:jsonb, OID::Jsonb, adapter: :postgresql)
       ActiveRecord::Type.register(:money, OID::Money, adapter: :postgresql)

data/lib/arjdbc/sqlite3/adapter.rb

@@ -16,6 +16,33 @@ require "active_record/connection_adapters/sqlite3/schema_dumper"
 require "active_record/connection_adapters/sqlite3/schema_statements"
 require "active_support/core_ext/class/attribute"
 
+module SQLite3
+  module Constants
+    module Open
+      READONLY       = 0x00000001
+      READWRITE      = 0x00000002
+      CREATE         = 0x00000004
+      DELETEONCLOSE  = 0x00000008
+      EXCLUSIVE      = 0x00000010
+      AUTOPROXY      = 0x00000020
+      URI            = 0x00000040
+      MEMORY         = 0x00000080
+      MAIN_DB        = 0x00000100
+      TEMP_DB        = 0x00000200
+      TRANSIENT_DB   = 0x00000400
+      MAIN_JOURNAL   = 0x00000800
+      TEMP_JOURNAL   = 0x00001000
+      SUBJOURNAL     = 0x00002000
+      MASTER_JOURNAL = 0x00004000
+      NOMUTEX        = 0x00008000
+      FULLMUTEX      = 0x00010000
+      SHAREDCACHE    = 0x00020000
+      PRIVATECACHE   = 0x00040000
+      WAL            = 0x00080000
+    end
+  end
+end
+
 module ArJdbc
   # All the code in this module is a copy of ConnectionAdapters::SQLite3Adapter from active_record 5.
   # The constants at the front of this file are to allow the rest of the file to remain with no modifications
@@ -69,6 +96,10 @@ module ArJdbc
       true
     end
 
+    def supports_transaction_isolation?
+      true
+    end
+
     def supports_partial_index?
       database_version >= "3.9.0"
     end
@@ -85,6 +116,10 @@ module ArJdbc
       true
     end
 
+    def supports_check_constraints?
+      true
+    end
+
     def supports_views?
       true
     end
@@ -114,13 +149,6 @@ module ArJdbc
       true
     end
 
-    # Returns 62. SQLite supports index names up to 64
-    # characters. The rest is used by Rails internally to perform
-    # temporary rename operations
-    def allowed_index_name_length
-      index_name_length - 2
-    end
-
     def native_database_types #:nodoc:
       NATIVE_DATABASE_TYPES
     end
@@ -159,7 +187,7 @@ module ArJdbc
     #++
 
     READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
-      :begin, :commit, :explain, :select, :pragma, :release, :savepoint, :rollback, :with
+      :pragma
     ) # :nodoc:
     private_constant :READ_QUERY
 
@@ -187,15 +215,15 @@ module ArJdbc
     #def execute(sql, name = nil) #:nodoc:
 
     def begin_db_transaction #:nodoc:
-      log("begin transaction", nil) { @connection.transaction }
+      log("begin transaction", 'TRANSACTION') { @connection.transaction }
     end
 
     def commit_db_transaction #:nodoc:
-      log("commit transaction", nil) { @connection.commit }
+      log("commit transaction", 'TRANSACTION') { @connection.commit }
     end
 
     def exec_rollback_db_transaction #:nodoc:
-      log("rollback transaction", nil) { @connection.rollback }
+      log("rollback transaction", 'TRANSACTION') { @connection.rollback }
     end
 
     # SCHEMA STATEMENTS ========================================
@@ -205,8 +233,11 @@ module ArJdbc
       pks.sort_by { |f| f["pk"] }.map { |f| f["name"] }
     end
 
-    def remove_index(table_name, options = {}) #:nodoc:
-      index_name = index_name_for_remove(table_name, options)
+      def remove_index(table_name, column_name = nil, **options) # :nodoc:
+        return if options[:if_exists] && !index_exists?(table_name, column_name, **options)
+
+      index_name = index_name_for_remove(table_name, column_name, options)
+
       exec_query "DROP INDEX #{quote_column_name(index_name)}"
     end
 
@@ -215,14 +246,16 @@ module ArJdbc
     # Example:
     #   rename_table('octopuses', 'octopi')
     def rename_table(table_name, new_name)
+      schema_cache.clear_data_source_cache!(table_name.to_s)
+      schema_cache.clear_data_source_cache!(new_name.to_s)
       exec_query "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
       rename_table_indexes(table_name, new_name)
     end
 
-    def add_column(table_name, column_name, type, options = {}) #:nodoc:
+    def add_column(table_name, column_name, type, **options) #:nodoc:
       if invalid_alter_table_type?(type, options)
         alter_table(table_name) do |definition|
-          definition.column(column_name, type, options)
+          definition.column(column_name, type, **options)
         end
       else
         super
@@ -255,16 +288,11 @@ module ArJdbc
       end
     end
 
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+    def change_column(table_name, column_name, type, **options) #:nodoc:
       alter_table(table_name) do |definition|
         definition[column_name].instance_eval do
           self.type    = type
-          self.limit   = options[:limit] if options.include?(:limit)
-          self.default = options[:default] if options.include?(:default)
-          self.null    = options[:null] if options.include?(:null)
-          self.precision = options[:precision] if options.include?(:precision)
-          self.scale   = options[:scale] if options.include?(:scale)
-          self.collation = options[:collation] if options.include?(:collation)
+            self.options.merge!(options)
         end
       end
     end
@@ -313,12 +341,17 @@ module ArJdbc
         sql << " ON CONFLICT #{insert.conflict_target} DO NOTHING"
       elsif insert.update_duplicates?
         sql << " ON CONFLICT #{insert.conflict_target} DO UPDATE SET "
+        sql << insert.touch_model_timestamps_unless { |column| "#{column} IS excluded.#{column}" }
         sql << insert.updatable_columns.map { |column| "#{column}=excluded.#{column}" }.join(",")
       end
 
       sql
     end
 
+    def shared_cache?
+      config[:properties] && config[:properties][:shared_cache] == true
+    end
+
     def get_database_version # :nodoc:
       SQLite3Adapter::Version.new(query_value("SELECT sqlite_version(*)"))
     end
@@ -327,15 +360,6 @@ module ArJdbc
       "DELETE FROM #{quote_table_name(table_name)}"
     end
 
-    def build_truncate_statements(*table_names)
-      table_names.flatten.map { |table_name| build_truncate_statement table_name }
-    end
-
-    def truncate(table_name, name = nil)
-      ActiveRecord::Base.clear_query_caches_for_current_thread if @query_cache_enabled
-      execute(build_truncate_statement(table_name), name)
-    end
-
     def check_version
       if database_version < "3.8.0"
         raise "Your version of SQLite (#{database_version}) is too old. Active Record supports SQLite >= 3.8."
@@ -349,11 +373,6 @@ module ArJdbc
       999
     end
 
-    def initialize_type_map(m = type_map)
-      super
-      register_class_with_limit m, %r(int)i, SQLite3Integer
-    end
-
     def table_structure(table_name)
       structure = exec_query("PRAGMA table_info(#{quote_table_name(table_name)})", "SCHEMA")
       raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty?
@@ -368,7 +387,12 @@ module ArJdbc
         options[:null] == false && options[:default].nil?
     end
 
-    def alter_table(table_name, foreign_keys = foreign_keys(table_name), **options)
+    def alter_table(
+      table_name,
+      foreign_keys = foreign_keys(table_name),
+      check_constraints = check_constraints(table_name),
+      **options
+    )
       altered_table_name = "a#{table_name}"
 
       caller = lambda do |definition|
@@ -378,7 +402,11 @@ module ArJdbc
             fk.options[:column] = column
           end
           to_table = strip_table_name_prefix_and_suffix(fk.to_table)
-          definition.foreign_key(to_table, fk.options)
+          definition.foreign_key(to_table, **fk.options)
+        end
+
+        check_constraints.each do |chk|
+          definition.check_constraint(chk.expression, **chk.options)
         end
 
         yield definition if block_given?
@@ -400,11 +428,12 @@ module ArJdbc
     def copy_table(from, to, options = {})
       from_primary_key = primary_key(from)
       options[:id] = false
-      create_table(to, options) do |definition|
+      create_table(to, **options) do |definition|
         @definition = definition
         if from_primary_key.is_a?(Array)
           @definition.primary_keys from_primary_key
         end
+
         columns(from).each do |column|
           column_name = options[:rename] ?
             (options[:rename][column.name] ||
@@ -432,7 +461,7 @@ module ArJdbc
         name = index.name
         # indexes sqlite creates for internal use start with `sqlite_` and
         # don't need to be copied
-        next if name.starts_with?("sqlite_")
+        next if name.start_with?("sqlite_")
         if to == "a#{from}"
           name = "t#{name}"
         elsif from == "a#{to}"
@@ -449,10 +478,10 @@ module ArJdbc
 
         unless columns.empty?
           # index name can't be the same
-          opts = { name: name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), internal: true }
-          opts[:unique] = true if index.unique
-          opts[:where] = index.where if index.where
-          add_index(to, columns, opts)
+          options = { name: name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), internal: true }
+          options[:unique] = true if index.unique
+          options[:where] = index.where if index.where
+          add_index(to, columns, **options)
         end
       end
     end
@@ -517,7 +546,7 @@ module ArJdbc
           collation_hash[$1] = $2 if COLLATE_REGEX =~ column_string
         end
 
-        basic_structure.map! do |column|
+        basic_structure.map do |column|
           column_name = column["name"]
 
           if collation_hash.has_key? column_name
@@ -539,18 +568,6 @@ module ArJdbc
       execute("PRAGMA foreign_keys = ON", "SCHEMA")
     end
 
-    # DIFFERENCE: FQN
-    class SQLite3Integer < ::ActiveRecord::Type::Integer # :nodoc:
-      private
-      def _limit
-        # INTEGER storage class can be stored 8 bytes value.
-        # See https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
-        limit || 8
-      end
-    end
-
-    # DIFFERENCE: FQN
-    ::ActiveRecord::Type.register(:integer, SQLite3Integer, adapter: :sqlite3)
   end
   # DIFFERENCE: A registration here is moved down to concrete class so we are not registering part of an adapter.
 end
@@ -671,7 +688,9 @@ module ActiveRecord::ConnectionAdapters
     end
 
     def begin_isolated_db_transaction(isolation)
-      raise ActiveRecord::TransactionIsolationError, 'adapter does not support setting transaction isolation'
+      raise ActiveRecord::TransactionIsolationError, "SQLite3 only supports the `read_uncommitted` transaction isolation level" if isolation != :read_uncommitted
+      raise StandardError, "You need to enable the shared-cache mode in SQLite mode before attempting to change the transaction isolation level" unless shared_cache?
+      super
     end
 
     # SQLite driver doesn't support all types of insert statements with executeUpdate so
@@ -707,5 +726,23 @@ module ActiveRecord::ConnectionAdapters
         total_sql
       end
     end
+
+    def initialize_type_map(m = type_map)
+      super
+      register_class_with_limit m, %r(int)i, SQLite3Integer
+    end
+
+    # DIFFERENCE: FQN
+    class SQLite3Integer < ::ActiveRecord::Type::Integer # :nodoc:
+      private
+      def _limit
+        # INTEGER storage class can be stored 8 bytes value.
+        # See https://www.sqlite.org/datatype3.html#storage_classes_and_datatypes
+        limit || 8
+      end
+    end
+
+    # DIFFERENCE: FQN
+    ::ActiveRecord::Type.register(:integer, SQLite3Integer, adapter: :sqlite3)
   end
 end

data/lib/arjdbc/sqlite3/connection_methods.rb

@@ -35,7 +35,17 @@ ArJdbc::ConnectionMethods.module_eval do
       # * http://sqlite.org/c3ref/open.html
       # * http://sqlite.org/c3ref/c_open_autoproxy.html
       # => 0x01 = readonly, 0x40 = uri (default in JDBC)
-      config[:properties][:open_mode] = 0x01 | 0x40
+      config[:properties][:open_mode] = ::SQLite3::Constants::Open::READONLY | ::SQLite3::Constants::Open::URI
+    end
+
+    if config[:flags]
+      config[:properties][:open_mode] ||= 0
+      config[:properties][:open_mode] |= config[:flags]
+
+      # JDBC driver has an extra flag for it
+      if config[:flags] & ::SQLite3::Constants::Open::SHAREDCACHE != 0
+        config[:properties][:shared_cache] = true
+      end
     end
 
     timeout = config[:timeout]

data/lib/arjdbc/tasks/databases.rake

@@ -5,15 +5,17 @@ module ActiveRecord::Tasks
   DatabaseTasks.module_eval do
 
     # @override patched to adapt jdbc configuration
-    def each_current_configuration(environment, spec_name = nil)
+    def each_current_configuration(environment, name = nil)
       environments = [environment]
       environments << 'test' if environment == 'development'
 
       environments.each do |env|
         ActiveRecord::Base.configurations.configs_for(env_name: env).each do |db_config|
-          next if spec_name && spec_name != db_config.spec_name
+          next if name && name != db_config.name
 
-          yield adapt_jdbc_config(db_config.config), db_config.spec_name, env unless db_config.config['database'].blank?
+          if db_config.database
+            yield adapt_jdbc_config(db_config), db_config.name, env
+          end
         end
       end
     end
@@ -21,21 +23,24 @@ module ActiveRecord::Tasks
     # @override patched to adapt jdbc configuration
     def each_local_configuration
       ActiveRecord::Base.configurations.configs_for.each do |db_config|
-        next unless db_config.config['database']
+        next unless db_config.database
 
-        if local_database?(db_config.config)
-          yield adapt_jdbc_config(db_config.config)
+        if local_database?(db_config)
+          yield adapt_jdbc_config(db_config)
         else
-          $stderr.puts "This task only modifies local databases. #{db_config.config['database']} is on a remote host."
+          $stderr.puts "This task only modifies local databases. #{db_config.database} is on a remote host."
         end
       end
     end
 
     private
 
-    def adapt_jdbc_config(config)
-      return config unless config['adapter']
-      config.merge 'adapter' => config['adapter'].sub(/^jdbc/, '')
+    def adapt_jdbc_config(db_config)
+      if db_config.adapter.start_with? 'jdbc'
+        config = db_config.configuration_hash.merge(adapter: db_config.adapter.sub(/^jdbc/, ''))
+        db_config = ActiveRecord::DatabaseConfigurations::HashConfig.new(db_config.env_name, db_config.name, config)
+      end
+      db_config
     end
 
   end

data/lib/arjdbc/version.rb

@@ -1,3 +1,3 @@
 module ArJdbc
-  VERSION = '60.4'
+  VERSION = '61.2'
 end