activerecord 8.1.3.1 → 8.1.4

data/lib/active_record/nested_attributes.rb

@@ -103,7 +103,7 @@ module ActiveRecord
     #
     #   class Member < ActiveRecord::Base
     #     has_many :posts
-    #     accepts_nested_attributes_for :posts
+    #     accepts_nested_attributes_for :posts, allow_destroy: true
     #   end
     #
     # You can now set or update attributes on the associated posts through
@@ -112,7 +112,8 @@ module ActiveRecord
     #
     # For each hash that does _not_ have an <tt>id</tt> key a new record will
     # be instantiated, unless the hash also contains a <tt>_destroy</tt> key
-    # that evaluates to +true+.
+    # that evaluates to +true+ and the <tt>:allow_destroy</tt> option is
+    # enabled.
     #
     #   params = { member: {
     #     name: 'joe', posts_attributes: [
@@ -313,8 +314,9 @@ module ActiveRecord
       #   that checks whether a record should be built for a certain attribute
       #   hash. The hash is passed to the supplied Proc or the method
       #   and it should return either +true+ or +false+. When no +:reject_if+
-      #   is specified, a record will be built for all attribute hashes that
-      #   do not have a <tt>_destroy</tt> value that evaluates to true.
+      #   is specified, a record will be built for all attribute hashes, unless
+      #   the <tt>:allow_destroy</tt> option is enabled and the hash has a
+      #   <tt>_destroy</tt> value that evaluates to true.
       #   Passing <tt>:all_blank</tt> instead of a Proc will create a proc
       #   that will reject a record where all the attributes are blank excluding
       #   any value for +_destroy+.
@@ -496,8 +498,6 @@ module ActiveRecord
           raise ArgumentError, "Hash or Array expected for `#{association_name}` attributes, got #{attributes_collection.class.name}"
         end
 
-        check_record_limit!(options[:limit], attributes_collection)
-
         if attributes_collection.is_a? Hash
           keys = attributes_collection.keys
           attributes_collection = if keys.include?("id") || keys.include?(:id)
@@ -507,6 +507,8 @@ module ActiveRecord
           end
         end
 
+        check_record_limit!(options[:limit], attributes_collection)
+
         association = association(association_name)
 
         existing_records = if association.loaded?

data/lib/active_record/persistence.rb

@@ -494,6 +494,7 @@ module ActiveRecord
         becoming.instance_variable_set(:@new_record, new_record?)
         becoming.instance_variable_set(:@previously_new_record, previously_new_record?)
         becoming.instance_variable_set(:@destroyed, destroyed?)
+        becoming.instance_variable_set(:@marked_for_destruction, marked_for_destruction?)
         becoming.errors.copy!(errors)
       end
 

data/lib/active_record/querying.rb

@@ -17,12 +17,24 @@ module ActiveRecord
       :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, :with_recursive,
+      :pluck, :pick, :ids, :async_ids, :strict_loading, :excluding, :without, :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)
 
+    # Add a Common Table Expression (CTE) that you can then reference within another SELECT statement.
+    #
+    # See ActiveRecord::QueryMethods#with for more information.
+    #
+    # When given a block, and the Object#with core extension is loaded, this
+    # delegates to it instead, temporarily setting the given attributes on the
+    # class for the duration of the block and restoring them afterwards.
+    def with(...)
+      return super if block_given? && defined?(super)
+      all.with(...)
+    end
+
     # Executes a custom SQL query against your database and returns all the results. The results will
     # be returned as an array, with the requested columns encapsulated as attributes of the model you call
     # this method from. For example, if you call <tt>Product.find_by_sql</tt>, then the results will be returned in

data/lib/active_record/reflection.rb

@@ -250,7 +250,7 @@ module ActiveRecord
               counter_cache[:column] || -"#{active_record.name.demodulize.underscore.pluralize}_count"
             end
           else
-            -((counter_cache && -counter_cache[:column]) || "#{name}_count")
+            -((counter_cache && counter_cache[:column]) || "#{name}_count")
           end
         end
       end

data/lib/active_record/relation/calculations.rb

@@ -396,7 +396,7 @@ module ActiveRecord
       relation.select_values = columns
 
       result = if relation.where_clause.contradiction?
-        ActiveRecord::Result.empty
+        ActiveRecord::Result.empty(async: @async)
       else
         skip_query_cache_if_necessary do
           model.with_connection do |c|
@@ -493,7 +493,7 @@ module ActiveRecord
 
           column = relation.aggregate_column(column_name)
           select_value = operation_over_aggregate_column(column, operation, distinct)
-          select_value.distinct = true if operation == "sum" && distinct
+          select_value.distinct = true if distinct && (operation == "sum" || operation == "average")
 
           relation.select_values = [select_value]
 
@@ -549,6 +549,7 @@ module ActiveRecord
           column = relation.aggregate_column(column_name)
           column_alias = column_alias_tracker.alias_for("#{operation} #{column_name.to_s.downcase}")
           select_value = operation_over_aggregate_column(column, operation, distinct)
+          select_value.distinct = true if distinct && (operation == "sum" || operation == "average")
           select_value = select_value.as(model.adapter_class.quote_column_name(column_alias))
 
           select_values = [select_value]
@@ -572,7 +573,11 @@ module ActiveRecord
 
           result.then do |calculated_data|
             if association
-              key_ids     = calculated_data.collect { |row| row[group_aliases.first] }
+              key_ids = if association.klass.base_class.composite_primary_key?
+                calculated_data.collect { |row| group_aliases.map { |group_alias| row[group_alias] } }
+              else
+                calculated_data.collect { |row| row[group_aliases.first] }
+              end
               key_records = association.klass.base_class.where(association.klass.base_class.primary_key => key_ids)
               key_records = key_records.index_by(&:id)
             end

data/lib/active_record/relation/finder_methods.rb

@@ -462,15 +462,15 @@ module ActiveRecord
         relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
 
         if eager_loading && has_limit_or_offset? && !(
-            using_limitable_reflections?(join_dependency.reflections) &&
-            using_limitable_reflections?(
-              construct_join_dependency(
-                select_association_list(joins_values).concat(
-                  select_association_list(left_outer_joins_values)
-                ), nil
-              ).reflections
-            )
+          using_limitable_reflections?(join_dependency.reflections) &&
+          using_limitable_reflections?(
+            construct_join_dependency(
+              select_association_list(joins_values).concat(
+                select_association_list(left_outer_joins_values)
+              ), nil
+            ).reflections
           )
+        )
           relation = skip_query_cache_if_necessary do
             model.with_connection do |c|
               c.distinct_relation_for_primary_key(relation)
@@ -492,15 +492,16 @@ module ActiveRecord
       def find_with_ids(*ids)
         raise UnknownPrimaryKey.new(model) if primary_key.nil?
 
+        first_item = ids.first
+        return [] if first_item.is_a?(Array) && first_item.empty?
+
         expects_array = if model.composite_primary_key?
-          ids.first.first.is_a?(Array)
+          first_item.first.is_a?(Array)
         else
-          ids.first.is_a?(Array)
+          first_item.is_a?(Array)
         end
 
-        return [] if expects_array && ids.first.empty?
-
-        ids = ids.first if expects_array
+        ids = first_item if expects_array
 
         ids = ids.compact.uniq
 
@@ -542,10 +543,6 @@ module ActiveRecord
       def find_some(ids)
         return find_some_ordered(ids) unless order_values.present?
 
-        relation = where(primary_key => ids)
-        relation = relation.select(table[primary_key]) unless select_values.empty?
-        result = relation.to_a
-
         expected_size =
           if limit_value && ids.size > limit_value
             limit_value
@@ -554,10 +551,18 @@ module ActiveRecord
           end
 
         # 11 ids with limit 3, offset 9 should give 2 results.
-        if offset_value && (ids.size - offset_value < expected_size)
-          expected_size = ids.size - offset_value
+        if offset_value
+          if ids.size <= offset_value
+            return []
+          elsif ids.size - offset_value < expected_size
+            expected_size = ids.size - offset_value
+          end
         end
 
+        relation = where(primary_key => ids)
+        relation = relation.select(table[primary_key]) unless select_values.empty?
+        result = relation.to_a
+
         if result.size == expected_size
           result
         else
@@ -567,6 +572,7 @@ module ActiveRecord
 
       def find_some_ordered(ids)
         ids = ids.slice(offset_value || 0, limit_value || ids.size) || []
+        return [] if ids.empty?
 
         relation = except(:limit, :offset)
         relation = relation.where(primary_key => ids)
@@ -574,12 +580,20 @@ module ActiveRecord
         result = relation.records
 
         if result.size == ids.size
-          result.in_order_of(:id, ids.map { |id| model.type_for_attribute(primary_key).cast(id) })
+          result.in_order_of(:id, ids.map { |id| cast_primary_key(id) })
         else
           raise_record_not_found_exception!(ids, result.size, ids.size)
         end
       end
 
+      def cast_primary_key(id)
+        if model.composite_primary_key?
+          primary_key.zip(id).map! { |attr, value| model.type_for_attribute(attr).cast(value) }
+        else
+          model.type_for_attribute(primary_key).cast(id)
+        end
+      end
+
       def find_take
         if loaded?
           records.first

data/lib/active_record/relation/merger.rb

@@ -161,8 +161,10 @@ module ActiveRecord
             relation.order!(*other.order_values)
           end
 
-          extensions = other.extensions - relation.extensions
-          relation.extending!(*extensions) if extensions.any?
+          unless other.extensions.empty?
+            extensions = other.extensions - relation.extensions
+            relation.extending!(*extensions) if extensions.any?
+          end
         end
 
         def merge_single_values

data/lib/active_record/relation/predicate_builder.rb

@@ -93,7 +93,7 @@ module ActiveRecord
           if key.is_a?(Array)
             queries = Array(value).map do |ids_set|
               raise ArgumentError, "Expected corresponding value for #{key} to be an Array" unless ids_set.is_a?(Array)
-              expand_from_hash(key.zip(ids_set).to_h)
+              expand_from_hash(convert_dot_notation_to_hash(key.zip(ids_set).to_h))
             end
             grouping_queries(queries)
           elsif value.is_a?(Hash) && !table.has_column?(key)

data/lib/active_record/relation/query_methods.rb

@@ -721,8 +721,16 @@ module ActiveRecord
       references = column_references([column])
       self.references_values |= references unless references.empty?
 
-      values = values.map { |value| model.type_caster.type_cast_for_database(column, value) }
-      arel_column = column.is_a?(Arel::Nodes::SqlLiteral) ? column : order_column(column.to_s)
+      if column.is_a?(Arel::Nodes::SqlLiteral)
+        arel_column = column
+      else
+        arel_column = order_column(column.to_s)
+
+        unless arel_column.is_a?(Arel::Nodes::SqlLiteral)
+          values = cast_values_for_in_order_of(values, arel_column.type_caster)
+        end
+        return spawn.none! if values.empty?
+      end
 
       scope = spawn.order!(build_case_for_value_position(arel_column, values, filter: filter))
 
@@ -837,6 +845,26 @@ module ActiveRecord
       self
     end
 
+    def table_name_qualified_unscope_values
+      self.unscope_values.map do |scope|
+        case scope
+        when Hash
+          scope.transform_values do |target_value|
+            case target_value
+            when Array
+              target_value.map { |value| qualify_attribute_with_table_name(value) }
+            when Symbol, String
+              qualify_attribute_with_table_name(target_value)
+            else
+              target_value
+            end
+          end
+        else
+          scope
+        end
+      end
+    end
+
     # Performs JOINs on +args+. The given symbol(s) should match the name of
     # the association(s).
     #
@@ -1048,13 +1076,13 @@ module ActiveRecord
     # Allows you to change a previously set where condition for a given attribute, instead of appending to that condition.
     #
     #   Post.where(trashed: true).where(trashed: false)
-    #   # WHERE `trashed` = 1 AND `trashed` = 0
+    #   # WHERE `trashed` = true AND `trashed` = false
     #
     #   Post.where(trashed: true).rewhere(trashed: false)
-    #   # WHERE `trashed` = 0
+    #   # WHERE `trashed` = false
     #
     #   Post.where(active: true).where(trashed: true).rewhere(trashed: false)
-    #   # WHERE `active` = 1 AND `trashed` = 0
+    #   # WHERE `active` = true AND `trashed` = false
     #
     # This is short-hand for <tt>unscope(where: conditions.keys).where(conditions)</tt>.
     # Note that unlike reorder, we're only unscoping the named conditions -- not the entire where statement.
@@ -1076,16 +1104,16 @@ module ActiveRecord
     #   end
     #
     #   User.where(accepted: true)
-    #   # WHERE `accepted` = 1
+    #   # WHERE `accepted` = true
     #
     #   User.where(accepted: true).invert_where
-    #   # WHERE `accepted` != 1
+    #   # WHERE `accepted` != true
     #
     #   User.active
-    #   # WHERE `accepted` = 1 AND `locked` = 0
+    #   # WHERE `accepted` = true AND `locked` = false
     #
     #   User.active.invert_where
-    #   # WHERE NOT (`accepted` = 1 AND `locked` = 0)
+    #   # WHERE NOT (`accepted` = true AND `locked` = false)
     #
     # Be careful because this inverts all conditions before +invert_where+ call.
     #
@@ -1096,7 +1124,7 @@ module ActiveRecord
     #
     #   # It also inverts `where(role: 'admin')` unexpectedly.
     #   User.where(role: 'admin').inactive
-    #   # WHERE NOT (`role` = 'admin' AND `accepted` = 1 AND `locked` = 0)
+    #   # WHERE NOT (`role` = 'admin' AND `accepted` = true AND `locked` = false)
     #
     def invert_where
       spawn.invert_where!
@@ -1586,8 +1614,8 @@ module ActiveRecord
     alias :without :excluding
 
     def excluding!(records) # :nodoc:
-      predicates = [ predicate_builder[primary_key, records].invert ]
-      self.where_clause += Relation::WhereClause.new(predicates)
+      ids = records.map { |record| record.is_a?(model) ? record.id : record }
+      self.where_clause += build_where_clause(primary_key => ids).invert
       self
     end
 
@@ -1898,7 +1926,7 @@ module ActiveRecord
       def build_select(arel)
         if select_values.any?
           arel.project(*arel_columns(select_values))
-        elsif model.ignored_columns.any? || model.enumerate_columns_in_select_statements
+        elsif model.ignored_columns.any? || model.enumerate_columns_in_select_statements || model.only_columns.any?
           arel.project(*model.column_names.map { |field| table[field] })
         else
           arel.project(table[Arel.star])
@@ -2205,6 +2233,10 @@ module ActiveRecord
         end
       end
 
+      def qualify_attribute_with_table_name(attr)
+        attr.to_s.include?(".") ? attr : predicate_builder.resolve_arel_attribute(table_name, attr)
+      end
+
       # Checks to make sure that the arguments are not blank. Note that if some
       # blank-like object were initially passed into the query method, then this
       # method will not raise an error.
@@ -2242,6 +2274,24 @@ module ActiveRecord
         end
       end
 
+      def cast_values_for_in_order_of(values, type_caster)
+        bad_value = Symbol # use some object that can not be a valid value
+
+        values = values.map do |value|
+          serialized = type_caster.serialize(value) if type_caster.serializable?(value)
+
+          if value.nil?
+            nil
+          elsif !serialized.nil?
+            serialized
+          else
+            bad_value
+          end
+        end
+
+        values.without(bad_value)
+      end
+
       def arel_column_aliases_from_hash(fields)
         fields.flat_map do |key, columns_aliases|
           table_name = key.is_a?(Symbol) ? key.name : key

data/lib/active_record/relation.rb

@@ -280,7 +280,7 @@ module ActiveRecord
         record
       rescue ActiveRecord::RecordNotUnique
         if connection.transaction_open?
-          where(attributes).lock.find_by!(attributes)
+          rewhere(attributes).lock(connection.create_or_find_by_lock).take!
         else
           find_by!(attributes)
         end
@@ -300,7 +300,7 @@ module ActiveRecord
         record
       rescue ActiveRecord::RecordNotUnique
         if connection.transaction_open?
-          where(attributes).lock.find_by!(attributes)
+          rewhere(attributes).lock(connection.create_or_find_by_lock).take!
         else
           find_by!(attributes)
         end
@@ -381,10 +381,11 @@ module ActiveRecord
 
     # Returns true if there are no records.
     #
-    # When a pattern argument is given, this method checks whether elements in
-    # the Enumerable match the pattern via the case-equality operator (<tt>===</tt>).
+    # When an argument is given, returns true if no records match the argument
+    # via the case-equality operator (<tt>===</tt>).
     #
-    #   posts.none?(Comment) # => true or false
+    #   posts.none?(Post)    # => true if posts is empty
+    #   posts.none?(Comment) # => true
     def none?(*args)
       return true if @none
 
@@ -394,10 +395,12 @@ module ActiveRecord
 
     # Returns true if there are any records.
     #
-    # When a pattern argument is given, this method checks whether elements in
-    # the Enumerable match the pattern via the case-equality operator (<tt>===</tt>).
     #
-    #    posts.any?(Post) # => true or false
+    # When an argument is given, returns true if at least one records matches
+    # the argument via the case-equality operator (<tt>===</tt>).
+    #
+    #    posts.any?(Post)    # => true if at least one record
+    #    posts.any?(Comment) # => false
     def any?(*args)
       return false if @none
 
@@ -407,10 +410,11 @@ module ActiveRecord
 
     # Returns true if there is exactly one record.
     #
-    # When a pattern argument is given, this method checks whether elements in
-    # the Enumerable match the pattern via the case-equality operator (<tt>===</tt>).
+    # When an argument is given, returns true if exactly one records matches the
+    # argument via the case-equality operator (<tt>===</tt>).
     #
-    #    posts.one?(Post) # => true or false
+    #    posts.one?(Post) # => true if exactly one record
+    #    posts.any?(Comment) # => false
     def one?(*args)
       return false if @none
 
@@ -485,7 +489,7 @@ module ActiveRecord
       if loaded?
         size = records.size
         if size > 0
-          timestamp = records.map { |record| record.read_attribute(timestamp_column) }.max
+          timestamp = records.filter_map { |record| record.read_attribute(timestamp_column) }.max
         end
       else
         collection = eager_loading? ? apply_join_dependency : self
@@ -1077,6 +1081,10 @@ module ActiveRecord
     def delete(id_or_array)
       return 0 if id_or_array.nil? || (id_or_array.is_a?(Array) && id_or_array.empty?)
 
+      if model.composite_primary_key? && !id_or_array.first.is_a?(Array)
+        id_or_array = [id_or_array]
+      end
+
       where(model.primary_key => id_or_array).delete_all
     end
 

data/lib/active_record/schema.rb

@@ -15,7 +15,7 @@ module ActiveRecord
   #       t.string :name, null: false
   #     end
   #
-  #     add_index :authors, :name, :unique
+  #     add_index :authors, :name, unique: true
   #
   #     create_table :posts do |t|
   #       t.integer :author_id, null: false

data/lib/active_record/schema_dumper.rb

@@ -192,7 +192,7 @@ module ActiveRecord
           tbl.puts ", force: :cascade do |t|"
 
           # then dump all non-primary key columns
-          columns.sort_by(&:name).each do |column|
+          columns.each do |column|
             raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
             next if column.name == pk
 

data/lib/active_record/signed_id.rb

@@ -70,7 +70,7 @@ module ActiveRecord
 
         options = { on_rotation: on_rotation }.compact
         if id = signed_id_verifier.verified(signed_id, purpose: combine_signed_id_purposes(purpose), **options)
-          find_by primary_key => id
+          find_by(primary_key => [id])
         end
       end
 

data/lib/active_record/statement_cache.rb

@@ -156,7 +156,7 @@ module ActiveRecord
         @model.find_by_sql(sql, bind_values, preparable: true, allow_retry: @query_builder.retryable, &block)
       end
     rescue ::RangeError
-      async ? Promise.wrap([]) : []
+      async ? Promise::Complete.new([]) : []
     end
 
     def self.unsupported_value?(value)

data/lib/active_record/store.rb

@@ -154,7 +154,8 @@ module ActiveRecord
               return unless attribute_changed?(store_attribute)
               prev_store, new_store = changes[store_attribute]
               accessor = store_accessor_for(store_attribute)
-              [accessor.get(prev_store, key), accessor.get(new_store, key)]
+              prev_value, new_value = accessor.get(prev_store, key), accessor.get(new_store, key)
+              [prev_value, new_value] unless prev_value == new_value
             end
 
             define_method("#{accessor_key}_was") do
@@ -175,7 +176,8 @@ module ActiveRecord
               return unless saved_change_to_attribute?(store_attribute)
               prev_store, new_store = saved_changes[store_attribute]
               accessor = store_accessor_for(store_attribute)
-              [accessor.get(prev_store, key), accessor.get(new_store, key)]
+              prev_value, new_value = accessor.get(prev_store, key), accessor.get(new_store, key)
+              [prev_value, new_value] unless prev_value == new_value
             end
 
             define_method("#{accessor_key}_before_last_save") do

data/lib/active_record/tasks/abstract_tasks.rb

@@ -58,11 +58,18 @@ module ActiveRecord
 
         def run_cmd_error(cmd, args)
           msg = +"failed to execute:\n"
-          msg << "#{cmd} #{args.join(' ')}\n\n"
+          msg << "#{cmd} #{filter_sensitive_args(args).join(' ')}\n\n"
           msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
           msg
         end
 
+        # The failed command is echoed back, so anything secret it was given has
+        # to be kept out of the message.
+        def filter_sensitive_args(args)
+          filtered = "--password=#{ActiveSupport::ParameterFilter::FILTERED}"
+          args.map { |arg| arg.to_s.sub(/\A--password=.+/m, filtered) }
+        end
+
         def with_temporary_pool(db_config, migration_class, clobber: false)
           original_db_config = migration_class.connection_db_config
           pool = migration_class.connection_handler.establish_connection(db_config, clobber: clobber)

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -61,22 +61,7 @@ module ActiveRecord
         end
 
         def prepare_command_options
-          args = {
-            host:      "--host",
-            port:      "--port",
-            socket:    "--socket",
-            username:  "--user",
-            password:  "--password",
-            encoding:  "--default-character-set",
-            sslca:     "--ssl-ca",
-            sslcert:   "--ssl-cert",
-            sslcapath: "--ssl-capath",
-            sslcipher: "--ssl-cipher",
-            sslkey:    "--ssl-key",
-            ssl_mode:  "--ssl-mode"
-          }.filter_map { |opt, arg| "#{arg}=#{configuration_hash[opt]}" if configuration_hash[opt] }
-
-          args
+          db_config.adapter_class.cli_args(configuration_hash)
         end
     end
   end

data/lib/active_record/test_databases.rb

@@ -16,6 +16,10 @@ module ActiveRecord
       end
     end
 
+    ActiveSupport::Testing::Parallelization.run_cleanup_hook do
+      ActiveRecord::Base.connection_handler.each_connection_pool.each(&:discard!)
+    end
+
     def self.create_and_load_schema(i, env_name:)
       old, ENV["VERBOSE"] = ENV["VERBOSE"], "false"
 

data/lib/active_record/test_fixtures.rb

@@ -263,19 +263,28 @@ module ActiveRecord
 
       def teardown_shared_connection_pool
         handler = ActiveRecord::Base.connection_handler
+        removed_pool_configs = []
+        pool_managers = handler.send(:connection_name_to_pool_manager)
 
         @saved_pool_configs.each_pair do |name, shards|
-          pool_manager = handler.send(:connection_name_to_pool_manager)[name]
+          pool_manager = pool_managers[name]
           shards.each_pair do |shard_name, roles|
             roles.each_pair do |role, pool_config|
-              next unless pool_manager.get_pool_config(role, shard_name)
-
-              pool_manager.set_pool_config(role, shard_name, pool_config)
+              if pool_manager.get_pool_config(role, shard_name)
+                pool_manager.set_pool_config(role, shard_name, pool_config)
+              else
+                removed_pool_configs << pool_config
+              end
             end
           end
         end
 
         @saved_pool_configs.clear
+
+        remaining_pool_configs = pool_managers.values.flat_map(&:pool_configs)
+        removed_pool_configs.compact.uniq.each do |pool_config|
+          pool_config.disconnect! unless remaining_pool_configs.include?(pool_config)
+        end
       end
 
       def load_fixtures(config)