activerecord 7.1.5 → 7.2.0.beta1

data/lib/active_record/connection_adapters/abstract/connection_handler.rb

@@ -55,9 +55,6 @@ module ActiveRecord
     # about the model. The model needs to pass a connection specification name to the handler,
     # in order to look up the correct connection pool.
     class ConnectionHandler
-      FINALIZER = lambda { |_| ActiveSupport::ForkTracker.check! }
-      private_constant :FINALIZER
-
       class StringConnectionName # :nodoc:
         attr_reader :name
 
@@ -77,9 +74,6 @@ module ActiveRecord
       def initialize
         # These caches are keyed by pool_config.connection_name (PoolConfig#connection_name).
         @connection_name_to_pool_manager = Concurrent::Map.new(initial_capacity: 2)
-
-        # Backup finalizer: if the forked child skipped Kernel#fork the early discard has not occurred
-        ObjectSpace.define_finalizer self, FINALIZER
       end
 
       def prevent_writes # :nodoc:
@@ -94,22 +88,10 @@ module ActiveRecord
         connection_name_to_pool_manager.keys
       end
 
-      def all_connection_pools
-        ActiveRecord.deprecator.warn(<<-MSG.squish)
-          The `all_connection_pools` method is deprecated in favor of `connection_pool_list`.
-          Call `connection_pool_list(:all)` to get the same behavior as `all_connection_pools`.
-        MSG
-        connection_name_to_pool_manager.values.flat_map { |m| m.pool_configs.map(&:pool) }
-      end
-
-      # Returns the pools for a connection handler and  given role. If +:all+ is passed,
+      # Returns the pools for a connection handler and given role. If +:all+ is passed,
       # all pools belonging to the connection handler will be returned.
       def connection_pool_list(role = nil)
-        if role.nil?
-          deprecation_for_pool_handling(__method__)
-          role = ActiveRecord::Base.current_role
-          connection_name_to_pool_manager.values.flat_map { |m| m.pool_configs(role).map(&:pool) }
-        elsif role == :all
+        if role.nil? || role == :all
           connection_name_to_pool_manager.values.flat_map { |m| m.pool_configs.map(&:pool) }
         else
           connection_name_to_pool_manager.values.flat_map { |m| m.pool_configs(role).map(&:pool) }
@@ -171,11 +153,6 @@ module ActiveRecord
       # Returns true if there are any active connections among the connection
       # pools that the ConnectionHandler is managing.
       def active_connections?(role = nil)
-        if role.nil?
-          deprecation_for_pool_handling(__method__)
-          role = ActiveRecord::Base.current_role
-        end
-
         each_connection_pool(role).any?(&:active_connection?)
       end
 
@@ -183,32 +160,20 @@ module ActiveRecord
       # and also returns connections to the pool cached by threads that are no
       # longer alive.
       def clear_active_connections!(role = nil)
-        if role.nil?
-          deprecation_for_pool_handling(__method__)
-          role = ActiveRecord::Base.current_role
+        each_connection_pool(role).each do |pool|
+          pool.release_connection
+          pool.disable_query_cache!
         end
-
-        each_connection_pool(role).each(&:release_connection)
       end
 
       # Clears the cache which maps classes.
       #
       # See ConnectionPool#clear_reloadable_connections! for details.
       def clear_reloadable_connections!(role = nil)
-        if role.nil?
-          deprecation_for_pool_handling(__method__)
-          role = ActiveRecord::Base.current_role
-        end
-
         each_connection_pool(role).each(&:clear_reloadable_connections!)
       end
 
       def clear_all_connections!(role = nil)
-        if role.nil?
-          deprecation_for_pool_handling(__method__)
-          role = ActiveRecord::Base.current_role
-        end
-
         each_connection_pool(role).each(&:disconnect!)
       end
 
@@ -216,11 +181,6 @@ module ActiveRecord
       #
       # See ConnectionPool#flush! for details.
       def flush_idle_connections!(role = nil)
-        if role.nil?
-          deprecation_for_pool_handling(__method__)
-          role = ActiveRecord::Base.current_role
-        end
-
         each_connection_pool(role).each(&:flush!)
       end
 
@@ -229,21 +189,8 @@ module ActiveRecord
       # opened and set as the active connection for the class it was defined
       # for (not necessarily the current class).
       def retrieve_connection(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard) # :nodoc:
-        pool = retrieve_connection_pool(connection_name, role: role, shard: shard)
-
-        unless pool
-          if shard != ActiveRecord::Base.default_shard
-            message = "No connection pool for '#{connection_name}' found for the '#{shard}' shard."
-          elsif role != ActiveRecord::Base.default_role
-            message = "No connection pool for '#{connection_name}' found for the '#{role}' role."
-          else
-            message = "No connection pool for '#{connection_name}' found."
-          end
-
-          raise ConnectionNotEstablished, message
-        end
-
-        pool.connection
+        pool = retrieve_connection_pool(connection_name, role: role, shard: shard, strict: true)
+        pool.lease_connection
       end
 
       # Returns true if a connection that's accessible to this class has
@@ -262,9 +209,22 @@ module ActiveRecord
       # Retrieving the connection pool happens a lot, so we cache it in @connection_name_to_pool_manager.
       # This makes retrieving the connection pool O(1) once the process is warm.
       # When a connection is established or removed, we invalidate the cache.
-      def retrieve_connection_pool(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
-        pool_config = get_pool_manager(connection_name)&.get_pool_config(role, shard)
-        pool_config&.pool
+      def retrieve_connection_pool(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard, strict: false)
+        pool = get_pool_manager(connection_name)&.get_pool_config(role, shard)&.pool
+
+        if strict && !pool
+          if shard != ActiveRecord::Base.default_shard
+            message = "No connection pool for '#{connection_name}' found for the '#{shard}' shard."
+          elsif role != ActiveRecord::Base.default_role
+            message = "No connection pool for '#{connection_name}' found for the '#{role}' role."
+          else
+            message = "No connection pool for '#{connection_name}' found."
+          end
+
+          raise ConnectionNotEstablished, message
+        end
+
+        pool
       end
 
       private
@@ -284,23 +244,6 @@ module ActiveRecord
           connection_name_to_pool_manager.values
         end
 
-        def deprecation_for_pool_handling(method)
-          roles = []
-          pool_managers.each do |pool_manager|
-            roles << pool_manager.role_names
-          end
-
-          if roles.flatten.uniq.count > 1
-            ActiveRecord.deprecator.warn(<<-MSG.squish)
-              `#{method}` currently only applies to connection pools in the current
-              role (`#{ActiveRecord::Base.current_role}`). In Rails 7.2, this method
-              will apply to all known pools, regardless of role. To affect only those
-              connections belonging to a specific role, pass the role name as an
-              argument. To switch to the new behavior, pass `:all` as the role name.
-            MSG
-          end
-        end
-
         def disconnect_pool_from_pool_manager(pool_manager, role, shard)
           pool_config = pool_manager.remove_pool_config(role, shard)
 
@@ -322,34 +265,8 @@ module ActiveRecord
         #
         def resolve_pool_config(config, connection_name, role, shard)
           db_config = Base.configurations.resolve(config)
-
+          db_config.validate!
           raise(AdapterNotSpecified, "database configuration does not specify adapter") unless db_config.adapter
-
-          # Require the adapter itself and give useful feedback about
-          #   1. Missing adapter gems and
-          #   2. Adapter gems' missing dependencies.
-          path_to_adapter = "active_record/connection_adapters/#{db_config.adapter}_adapter"
-          begin
-            require path_to_adapter
-          rescue LoadError => e
-            # We couldn't require the adapter itself. Raise an exception that
-            # points out config typos and missing gems.
-            if e.path == path_to_adapter
-              # We can assume that a non-builtin adapter was specified, so it's
-              # either misspelled or missing from Gemfile.
-              raise LoadError, "Could not load the '#{db_config.adapter}' Active Record adapter. Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary adapter gem to your Gemfile.", e.backtrace
-
-              # Bubbled up from the adapter require. Prefix the exception message
-              # with some guidance about how to address it and reraise.
-            else
-              raise LoadError, "Error loading the '#{db_config.adapter}' Active Record adapter. Missing a gem it depends on? #{e.message}", e.backtrace
-            end
-          end
-
-          unless ActiveRecord::Base.respond_to?(db_config.adapter_method)
-            raise AdapterNotFound, "database configuration specifies nonexistent #{db_config.adapter} adapter"
-          end
-
           ConnectionAdapters::PoolConfig.new(connection_name, db_config, role, shard)
         end
 

data/lib/active_record/connection_adapters/abstract/connection_pool/reaper.rb

@@ -43,6 +43,7 @@ module ActiveRecord
                 # Advise multi-threaded app servers to ignore this thread for
                 # the purposes of fork safety warnings
                 Thread.current.thread_variable_set(:fork_safe, true)
+                Thread.current.name = "AR Pool Reaper"
                 running = true
                 while running
                   sleep t