activerecord 7.1.4.1 → 7.2.2.1

data/lib/active_record/querying.rb

@@ -10,15 +10,16 @@ module ActiveRecord
       :first_or_create, :first_or_create!, :first_or_initialize,
       :find_or_create_by, :find_or_create_by!, :find_or_initialize_by,
       :create_or_find_by, :create_or_find_by!,
-      :destroy_all, :delete_all, :update_all, :touch_all, :destroy_by, :delete_by,
+      :destroy, :destroy_all, :delete, :delete_all, :update_all, :touch_all, :destroy_by, :delete_by,
       :find_each, :find_in_batches, :in_batches,
       :select, :reselect, :order, :regroup, :in_order_of, :reorder, :group, :limit, :offset, :joins, :left_joins, :left_outer_joins,
       :where, :rewhere, :invert_where, :preload, :extract_associated, :eager_load, :includes, :from, :lock, :readonly,
       :and, :or, :annotate, :optimizer_hints, :extending,
       :having, :create_with, :distinct, :references, :none, :unscope, :merge, :except, :only,
       :count, :average, :minimum, :maximum, :sum, :calculate,
-      :pluck, :pick, :ids, :async_ids, :strict_loading, :excluding, :without, :with,
+      :pluck, :pick, :ids, :async_ids, :strict_loading, :excluding, :without, :with, :with_recursive,
       :async_count, :async_average, :async_minimum, :async_maximum, :async_sum, :async_pluck, :async_pick,
+      :insert, :insert_all, :insert!, :insert_all!, :upsert, :upsert_all
     ].freeze # :nodoc:
     delegate(*QUERYING_METHODS, to: :all)
 
@@ -47,19 +48,26 @@ module ActiveRecord
     #
     # Note that building your own SQL query string from user input may expose your application to
     # injection attacks (https://guides.rubyonrails.org/security.html#sql-injection).
-    def find_by_sql(sql, binds = [], preparable: nil, &block)
-      _load_from_sql(_query_by_sql(sql, binds, preparable: preparable), &block)
+    def find_by_sql(sql, binds = [], preparable: nil, allow_retry: false, &block)
+      result = with_connection do |c|
+        _query_by_sql(c, sql, binds, preparable: preparable, allow_retry: allow_retry)
+      end
+      _load_from_sql(result, &block)
     end
 
     # Same as <tt>#find_by_sql</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
     def async_find_by_sql(sql, binds = [], preparable: nil, &block)
-      _query_by_sql(sql, binds, preparable: preparable, async: true).then do |result|
+      result = with_connection do |c|
+        _query_by_sql(c, sql, binds, preparable: preparable, async: true)
+      end
+
+      result.then do |result|
         _load_from_sql(result, &block)
       end
     end
 
-    def _query_by_sql(sql, binds = [], preparable: nil, async: false) # :nodoc:
-      connection.select_all(sanitize_sql(sql), "#{name} Load", binds, preparable: preparable, async: async)
+    def _query_by_sql(connection, sql, binds = [], preparable: nil, async: false, allow_retry: false) # :nodoc:
+      connection.select_all(sanitize_sql(sql), "#{name} Load", binds, preparable: preparable, async: async, allow_retry: allow_retry)
     end
 
     def _load_from_sql(result_set, &block) # :nodoc:
@@ -99,12 +107,16 @@ module ActiveRecord
     #
     # * +sql+ - An SQL statement which should return a count query from the database, see the example above.
     def count_by_sql(sql)
-      connection.select_value(sanitize_sql(sql), "#{name} Count").to_i
+      with_connection do |c|
+        c.select_value(sanitize_sql(sql), "#{name} Count").to_i
+      end
     end
 
     # Same as <tt>#count_by_sql</tt> but perform the query asynchronously and returns an ActiveRecord::Promise.
     def async_count_by_sql(sql)
-      connection.select_value(sanitize_sql(sql), "#{name} Count", async: true).then(&:to_i)
+      with_connection do |c|
+        c.select_value(sanitize_sql(sql), "#{name} Count", async: true).then(&:to_i)
+      end
     end
   end
 end

data/lib/active_record/railtie.rb

@@ -31,7 +31,6 @@ module ActiveRecord
     config.active_record.check_schema_cache_dump_version = true
     config.active_record.maintain_test_schema = true
     config.active_record.has_many_inversing = false
-    config.active_record.sqlite3_production_warning = true
     config.active_record.query_log_tags_enabled = false
     config.active_record.query_log_tags = [ :application ]
     config.active_record.query_log_tags_format = :legacy
@@ -70,6 +69,7 @@ module ActiveRecord
         Rails.logger.broadcast_to(console)
       end
       ActiveRecord.verbose_query_logs = false
+      ActiveRecord::Base.attributes_for_inspect = :all
     end
 
     runner do
@@ -88,7 +88,9 @@ module ActiveRecord
 
     initializer "active_record.postgresql_time_zone_aware_types" do
       ActiveSupport.on_load(:active_record_postgresqladapter) do
-        ActiveRecord::Base.time_zone_aware_types << :timestamptz
+        ActiveSupport.on_load(:active_record) do
+          ActiveRecord::Base.time_zone_aware_types << :timestamptz
+        end
       end
     end
 
@@ -133,49 +135,11 @@ To keep using the current cache store, you can turn off cache versioning entirel
       end
     end
 
-    initializer "active_record.use_schema_cache_dump" do
-      ActiveRecord::ConnectionAdapters::SchemaReflection.use_schema_cache_dump = config.active_record.use_schema_cache_dump
-    end
-
-    initializer "active_record.check_schema_cache_dump" do
-      check_schema_cache_dump_version = config.active_record.check_schema_cache_dump_version
-
-      ActiveRecord::ConnectionAdapters::SchemaReflection.check_schema_cache_dump_version = check_schema_cache_dump_version
-
-      if config.active_record.use_schema_cache_dump && !config.active_record.lazily_load_schema_cache
-        config.after_initialize do |app|
-          ActiveSupport.on_load(:active_record) do
-            db_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env).first
-            next if db_config.nil?
-
-            filename = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(
-              db_config.name,
-              schema_cache_path: db_config.schema_cache_path
-            )
-
-            cache = ActiveRecord::ConnectionAdapters::SchemaCache._load_from(filename)
-            next if cache.nil?
-
-            if check_schema_cache_dump_version
-              current_version = begin
-                ActiveRecord::Migrator.current_version
-              rescue ActiveRecordError => error
-                warn "Failed to validate the schema cache because of #{error.class}: #{error.message}"
-                nil
-              end
-              next if current_version.nil?
-
-              if cache.schema_version != current_version
-                warn "Ignoring #{filename} because it has expired. The current schema version is #{current_version}, but the one in the schema cache file is #{cache.schema_version}."
-                next
-              end
-            end
+    initializer "active_record.copy_schema_cache_config" do
+      active_record_config = config.active_record
 
-            Rails.logger.info("Using schema cache file #{filename}")
-            connection_pool.schema_reflection.set_schema_cache(cache)
-          end
-        end
-      end
+      ActiveRecord::ConnectionAdapters::SchemaReflection.use_schema_cache_dump = active_record_config.use_schema_cache_dump
+      ActiveRecord::ConnectionAdapters::SchemaReflection.check_schema_cache_dump_version = active_record_config.check_schema_cache_dump_version
     end
 
     initializer "active_record.define_attribute_methods" do |app|
@@ -198,7 +162,7 @@ To keep using the current cache store, you can turn off cache versioning entirel
           # Additionally if `check_schema_cache_dump_version` is enabled (which is the default),
           # loading the schema cache dump trigger a database connection to compare the schema
           # versions.
-          # This means the attribute methods will be lazily defined whent the model is accessed,
+          # This means the attribute methods will be lazily defined when the model is accessed,
           # likely as part of the first few requests or jobs. This isn't good for performance
           # but we unfortunately have to arbitrate between resiliency and performance, and chose
           # resiliency.
@@ -222,19 +186,25 @@ To keep using the current cache store, you can turn off cache versioning entirel
 
     initializer "active_record.warn_on_records_fetched_greater_than" do
       if config.active_record.warn_on_records_fetched_greater_than
+        ActiveRecord.deprecator.warn <<~MSG.squish
+          `config.active_record.warn_on_records_fetched_greater_than` is deprecated and will be
+          removed in Rails 8.0.
+          Please subscribe to `sql.active_record` notifications and access the row count field to
+          detect large result set sizes.
+        MSG
         ActiveSupport.on_load(:active_record) do
           require "active_record/relation/record_fetch_warning"
         end
       end
     end
 
-    SQLITE3_PRODUCTION_WARN = "You are running SQLite in production, this is generally not recommended."\
-      " You can disable this warning by setting \"config.active_record.sqlite3_production_warning=false\"."
-    initializer "active_record.sqlite3_production_warning" do
-      if config.active_record.sqlite3_production_warning && Rails.env.production?
-        ActiveSupport.on_load(:active_record_sqlite3adapter) do
-          Rails.logger.warn(SQLITE3_PRODUCTION_WARN)
-        end
+    initializer "active_record.sqlite3_deprecated_warning" do
+      if config.active_record.key?(:sqlite3_production_warning)
+        config.active_record.delete(:sqlite3_production_warning)
+        ActiveRecord.deprecator.warn <<~MSG.squish
+          The `config.active_record.sqlite3_production_warning` configuration no longer has any effect
+          and can be safely removed.
+        MSG
       end
     end
 
@@ -248,6 +218,16 @@ To keep using the current cache store, you can turn off cache versioning entirel
       end
     end
 
+    initializer "active_record.postgresql_adapter_decode_dates" do
+      config.after_initialize do
+        if config.active_record.postgresql_adapter_decode_dates
+          ActiveSupport.on_load(:active_record_postgresqladapter) do
+            self.decode_dates = true
+          end
+        end
+      end
+    end
+
     initializer "active_record.set_configs" do |app|
       configs = app.config.active_record
 
@@ -273,10 +253,10 @@ To keep using the current cache store, you can turn off cache versioning entirel
           :query_log_tags,
           :query_log_tags_format,
           :cache_query_log_tags,
-          :sqlite3_production_warning,
           :sqlite3_adapter_strict_strings_by_default,
           :check_schema_cache_dump_version,
-          :use_schema_cache_dump
+          :use_schema_cache_dump,
+          :postgresql_adapter_decode_dates,
         )
 
         configs_used_in_other_initializers.each do |k, v|
@@ -332,6 +312,7 @@ To keep using the current cache store, you can turn off cache versioning entirel
     initializer "active_record.set_executor_hooks" do
       ActiveRecord::QueryCache.install_executor_hooks
       ActiveRecord::AsynchronousQueriesTracker.install_executor_hooks
+      ActiveRecord::ConnectionAdapters::ConnectionPool.install_executor_hooks
     end
 
     initializer "active_record.add_watchable_files" do |app|
@@ -377,16 +358,19 @@ To keep using the current cache store, you can turn off cache versioning entirel
     end
 
     initializer "active_record_encryption.configuration" do |app|
-      ActiveSupport.on_load(:active_record) do
-        ActiveRecord::Encryption.configure \
+      ActiveSupport.on_load(:active_record_encryption) do
+        ActiveRecord::Encryption.configure(
           primary_key: app.credentials.dig(:active_record_encryption, :primary_key),
           deterministic_key: app.credentials.dig(:active_record_encryption, :deterministic_key),
           key_derivation_salt: app.credentials.dig(:active_record_encryption, :key_derivation_salt),
           **app.config.active_record.encryption
+        )
 
         auto_filtered_parameters = ActiveRecord::Encryption::AutoFilteredParameters.new(app)
         auto_filtered_parameters.enable if ActiveRecord::Encryption.config.add_to_filter_parameters
+      end
 
+      ActiveSupport.on_load(:active_record) do
         # Support extended queries for deterministic attributes and validations
         if ActiveRecord::Encryption.config.extend_queries
           ActiveRecord::Encryption::ExtendedDeterministicQueries.install_support
@@ -411,7 +395,8 @@ To keep using the current cache store, you can turn off cache versioning entirel
             pid:          -> { Process.pid.to_s },
             socket:       ->(context) { context[:connection].pool.db_config.socket },
             db_host:      ->(context) { context[:connection].pool.db_config.host },
-            database:     ->(context) { context[:connection].pool.db_config.database }
+            database:     ->(context) { context[:connection].pool.db_config.database },
+            source_location: -> { QueryLogs.query_source_location }
           )
           ActiveRecord.disable_prepared_statements = true
 

data/lib/active_record/railties/controller_runtime.rb

@@ -11,7 +11,14 @@ module ActiveRecord
       module ClassMethods # :nodoc:
         def log_process_action(payload)
           messages, db_runtime = super, payload[:db_runtime]
-          messages << ("ActiveRecord: %.1fms" % db_runtime.to_f) if db_runtime
+
+          if db_runtime
+            queries_count = payload[:queries_count] || 0
+            cached_queries_count = payload[:cached_queries_count] || 0
+            messages << ("ActiveRecord: %.1fms (%d %s, %d cached)" % [db_runtime.to_f, queries_count,
+                                                                      "query".pluralize(queries_count), cached_queries_count])
+          end
+
           messages
         end
       end
@@ -34,11 +41,11 @@ module ActiveRecord
 
         def cleanup_view_runtime
           if logger && logger.info?
-            db_rt_before_render = ActiveRecord::RuntimeRegistry.reset
+            db_rt_before_render = ActiveRecord::RuntimeRegistry.reset_runtimes
             self.db_runtime = (db_runtime || 0) + db_rt_before_render
             runtime = super
             queries_rt = ActiveRecord::RuntimeRegistry.sql_runtime - ActiveRecord::RuntimeRegistry.async_sql_runtime
-            db_rt_after_render = ActiveRecord::RuntimeRegistry.reset
+            db_rt_after_render = ActiveRecord::RuntimeRegistry.reset_runtimes
             self.db_runtime += db_rt_after_render
             runtime - queries_rt
           else
@@ -49,7 +56,9 @@ module ActiveRecord
         def append_info_to_payload(payload)
           super
 
-          payload[:db_runtime] = (db_runtime || 0) + ActiveRecord::RuntimeRegistry.reset
+          payload[:db_runtime] = (db_runtime || 0) + ActiveRecord::RuntimeRegistry.reset_runtimes
+          payload[:queries_count] = ActiveRecord::RuntimeRegistry.reset_queries_count
+          payload[:cached_queries_count] = ActiveRecord::RuntimeRegistry.reset_cached_queries_count
         end
     end
   end

data/lib/active_record/railties/databases.rake

@@ -9,10 +9,10 @@ databases = ActiveRecord::Tasks::DatabaseTasks.setup_initial_database_yaml
 db_namespace = namespace :db do
   desc "Set the environment value for the database"
   task "environment:set" => :load_config do
-    connection = ActiveRecord::Tasks::DatabaseTasks.migration_connection
-    raise ActiveRecord::EnvironmentStorageError unless connection.internal_metadata.enabled?
+    pool = ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool
+    raise ActiveRecord::EnvironmentStorageError unless pool.internal_metadata.enabled?
 
-    connection.internal_metadata.create_table_and_set_flags(connection.migration_context.current_environment)
+    pool.internal_metadata.create_table_and_set_flags(pool.migration_context.current_environment)
   end
 
   task check_protected_environments: :load_config do
@@ -135,7 +135,7 @@ db_namespace = namespace :db do
     ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
       desc "Migrate #{name} database for current environment"
       task name => :load_config do
-        ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each(env: Rails.env, name: name) do |conn|
+        ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: Rails.env, name: name) do
           ActiveRecord::Tasks::DatabaseTasks.migrate
         end
 
@@ -186,7 +186,7 @@ db_namespace = namespace :db do
 
       ActiveRecord::Tasks::DatabaseTasks.check_target_version
 
-      ActiveRecord::Tasks::DatabaseTasks.migration_connection.migration_context.run(
+      ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool.migration_context.run(
         :up,
         ActiveRecord::Tasks::DatabaseTasks.target_version
       )
@@ -199,9 +199,9 @@ db_namespace = namespace :db do
         task name => :load_config do
           raise "VERSION is required" if !ENV["VERSION"] || ENV["VERSION"].empty?
 
-          ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each(env: Rails.env, name: name) do |conn|
+          ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: Rails.env, name: name) do |pool|
             ActiveRecord::Tasks::DatabaseTasks.check_target_version
-            conn.migration_context.run(:up, ActiveRecord::Tasks::DatabaseTasks.target_version)
+            pool.migration_context.run(:up, ActiveRecord::Tasks::DatabaseTasks.target_version)
           end
 
           db_namespace["_dump:#{name}"].invoke
@@ -217,7 +217,7 @@ db_namespace = namespace :db do
 
       ActiveRecord::Tasks::DatabaseTasks.check_target_version
 
-      ActiveRecord::Tasks::DatabaseTasks.migration_connection.migration_context.run(
+      ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool.migration_context.run(
         :down,
         ActiveRecord::Tasks::DatabaseTasks.target_version
       )
@@ -230,9 +230,9 @@ db_namespace = namespace :db do
         task name => :load_config do
           raise "VERSION is required" if !ENV["VERSION"] || ENV["VERSION"].empty?
 
-          ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each(env: Rails.env, name: name) do |conn|
+          ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: Rails.env, name: name) do |pool|
             ActiveRecord::Tasks::DatabaseTasks.check_target_version
-            conn.migration_context.run(:down, ActiveRecord::Tasks::DatabaseTasks.target_version)
+            pool.migration_context.run(:down, ActiveRecord::Tasks::DatabaseTasks.target_version)
           end
 
           db_namespace["_dump:#{name}"].invoke
@@ -242,7 +242,7 @@ db_namespace = namespace :db do
 
     desc "Display status of migrations"
     task status: :load_config do
-      ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each do
+      ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each do
         ActiveRecord::Tasks::DatabaseTasks.migrate_status
       end
     end
@@ -251,7 +251,7 @@ db_namespace = namespace :db do
       ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
         desc "Display status of migrations for #{name} database"
         task name => :load_config do
-          ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each(env: Rails.env, name: name) do
+          ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: Rails.env, name: name) do
             ActiveRecord::Tasks::DatabaseTasks.migrate_status
           end
         end
@@ -265,8 +265,8 @@ db_namespace = namespace :db do
       task name => :load_config do
         step = ENV["STEP"] ? ENV["STEP"].to_i : 1
 
-        ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each(env: Rails.env, name: name) do |conn|
-          conn.migration_context.rollback(step)
+        ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: Rails.env, name: name) do |pool|
+          pool.migration_context.rollback(step)
         end
 
         db_namespace["_dump:#{name}"].invoke
@@ -281,7 +281,7 @@ db_namespace = namespace :db do
 
     step = ENV["STEP"] ? ENV["STEP"].to_i : 1
 
-    ActiveRecord::Tasks::DatabaseTasks.migration_connection.migration_context.rollback(step)
+    ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool.migration_context.rollback(step)
 
     db_namespace["_dump"].invoke
   end
@@ -290,7 +290,7 @@ db_namespace = namespace :db do
   task forward: :load_config do
     step = ENV["STEP"] ? ENV["STEP"].to_i : 1
 
-    ActiveRecord::Tasks::DatabaseTasks.migration_connection.migration_context.forward(step)
+    ActiveRecord::Tasks::DatabaseTasks.migration_connection_pool.migration_context.forward(step)
 
     db_namespace["_dump"].invoke
   end
@@ -321,9 +321,9 @@ db_namespace = namespace :db do
 
   desc "Retrieve the current schema version number"
   task version: :load_config do
-    ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each(env: Rails.env) do |connection|
-      puts "\ndatabase: #{connection.pool.db_config.database}\n"
-      puts "Current version: #{connection.schema_version}"
+    ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: Rails.env) do |pool|
+      puts "\ndatabase: #{pool.db_config.database}\n"
+      puts "Current version: #{pool.migration_context.current_version}"
       puts
     end
   end
@@ -344,8 +344,8 @@ db_namespace = namespace :db do
   task abort_if_pending_migrations: :load_config do
     pending_migrations = []
 
-    ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each do |conn|
-      pending_migrations << conn.migration_context.open.pending_migrations
+    ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each do |pool|
+      pending_migrations << pool.migration_context.open.pending_migrations
     end
 
     pending_migrations = pending_migrations.flatten!
@@ -365,8 +365,8 @@ db_namespace = namespace :db do
     ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
       # desc "Raise an error if there are pending migrations for #{name} database"
       task name => :load_config do
-        ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each(env: Rails.env, name: name) do |conn|
-          pending_migrations = conn.migration_context.open.pending_migrations
+        ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: Rails.env, name: name) do |pool|
+          pending_migrations = pool.migration_context.open.pending_migrations
 
           if pending_migrations.any?
             puts "You have #{pending_migrations.size} pending #{pending_migrations.size > 1 ? 'migrations:' : 'migration:'}"
@@ -462,8 +462,8 @@ db_namespace = namespace :db do
   namespace :schema do
     desc "Create a database schema file (either db/schema.rb or db/structure.sql, depending on `ENV['SCHEMA_FORMAT']` or `config.active_record.schema_format`)"
     task dump: :load_config do
-      ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each do |conn|
-        db_config = conn.pool.db_config
+      ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each do |pool|
+        db_config = pool.db_config
         schema_format = ENV.fetch("SCHEMA_FORMAT", ActiveRecord.schema_format).to_sym
         ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config, schema_format)
       end
@@ -480,8 +480,8 @@ db_namespace = namespace :db do
       ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
         desc "Create a database schema file (either db/schema.rb or db/structure.sql, depending on `ENV['SCHEMA_FORMAT']` or `config.active_record.schema_format`) for #{name} database"
         task name => :load_config do
-          ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each(name: name) do |conn|
-            db_config = conn.pool.db_config
+          ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(name: name) do |pool|
+            db_config = pool.db_config
             schema_format = ENV.fetch("SCHEMA_FORMAT", ActiveRecord.schema_format).to_sym
             ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config, schema_format)
           end
@@ -495,8 +495,8 @@ db_namespace = namespace :db do
       ActiveRecord::Tasks::DatabaseTasks.for_each(databases) do |name|
         desc "Load a database schema file (either db/schema.rb or db/structure.sql, depending on `ENV['SCHEMA_FORMAT']` or `config.active_record.schema_format`) into the #{name} database"
         task name => "db:test:purge:#{name}" do
-          ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each(name: name) do |conn|
-            db_config = conn.pool.db_config
+          ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(name: name) do |pool|
+            db_config = pool.db_config
             schema_format = ENV.fetch("SCHEMA_FORMAT", ActiveRecord.schema_format).to_sym
             ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config, schema_format)
           end
@@ -507,21 +507,18 @@ db_namespace = namespace :db do
     namespace :cache do
       desc "Create a db/schema_cache.yml file."
       task dump: :load_config do
-        ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each do |conn|
-          db_config = conn.pool.db_config
-          filename = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(db_config.name, schema_cache_path: db_config.schema_cache_path)
+        ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each do |pool|
+          db_config = pool.db_config
+          filename = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(db_config)
 
-          ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(conn, filename)
+          ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(pool, filename)
         end
       end
 
       desc "Clear a db/schema_cache.yml file."
       task clear: :load_config do
         ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
-          filename = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(
-            db_config.name,
-            schema_cache_path: db_config.schema_cache_path,
-          )
+          filename = ActiveRecord::Tasks::DatabaseTasks.cache_dump_filename(db_config)
           ActiveRecord::Tasks::DatabaseTasks.clear_schema_cache(
             filename,
           )
@@ -547,8 +544,8 @@ db_namespace = namespace :db do
   namespace :test do
     # desc "Recreate the test database from an existent schema file (schema.rb or structure.sql, depending on `ENV['SCHEMA_FORMAT']` or `config.active_record.schema_format`)"
     task load_schema: %w(db:test:purge) do
-      ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each(env: "test") do |conn|
-        db_config = conn.pool.db_config
+      ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: "test") do |pool|
+        db_config = pool.db_config
         ActiveRecord::Schema.verbose = false
         schema_format = ENV.fetch("SCHEMA_FORMAT", ActiveRecord.schema_format).to_sym
         ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config, schema_format)
@@ -573,8 +570,8 @@ db_namespace = namespace :db do
       # desc "Recreate the #{name} test database from an existent schema.rb file"
       namespace :load_schema do
         task name => "db:test:purge:#{name}" do
-          ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each(env: "test", name: name) do |conn|
-            db_config = conn.pool.db_config
+          ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: "test", name: name) do |pool|
+            db_config = pool.db_config
             ActiveRecord::Schema.verbose = false
             schema_format = ENV.fetch("SCHEMA_FORMAT", ActiveRecord.schema_format).to_sym
             ActiveRecord::Tasks::DatabaseTasks.load_schema(db_config, schema_format)
@@ -585,8 +582,8 @@ db_namespace = namespace :db do
       # desc "Empty the #{name} test database"
       namespace :purge do
         task name => %w(load_config check_protected_environments) do
-          ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection_for_each(env: "test", name: name) do |conn|
-            db_config = conn.pool.db_config
+          ActiveRecord::Tasks::DatabaseTasks.with_temporary_pool_for_each(env: "test", name: name) do |pool|
+            db_config = pool.db_config
             ActiveRecord::Tasks::DatabaseTasks.purge(db_config)
           end
         end