activerecord 7.0.8.1 → 7.1.4

data/lib/active_record/base.rb

@@ -311,11 +311,12 @@ module ActiveRecord # :nodoc:
     include Attributes
     include Locking::Optimistic
     include Locking::Pessimistic
+    include Encryption::EncryptableRecord
     include AttributeMethods
     include Callbacks
     include Timestamp
     include Associations
-    include ActiveModel::SecurePassword
+    include SecurePassword
     include AutosaveAssociation
     include NestedAttributes
     include Transactions
@@ -325,9 +326,13 @@ module ActiveRecord # :nodoc:
     include Serialization
     include Store
     include SecureToken
+    include TokenFor
     include SignedId
     include Suppressor
-    include Encryption::EncryptableRecord
+    include Normalization
+    include Marshalling::Methods
+
+    self.param_delimiter = "_"
   end
 
   ActiveSupport.run_load_hooks(:active_record, Base)

data/lib/active_record/callbacks.rb

@@ -84,7 +84,7 @@ module ActiveRecord
   # == Types of callbacks
   #
   # There are three types of callbacks accepted by the callback macros: method references (symbol), callback objects,
-  # inline methods (using a proc). Method references and callback objects are the recommended approaches,
+  # inline methods (using a proc). \Method references and callback objects are the recommended approaches,
   # inline methods using a proc are sometimes appropriate (such as for creating mix-ins).
   #
   # The method reference callbacks work by specifying a protected or private method available in the object, like this:
@@ -173,7 +173,7 @@ module ActiveRecord
   #
   # If a <tt>before_*</tt> callback throws +:abort+, all the later callbacks and
   # the associated action are cancelled.
-  # Callbacks are generally run in the order they are defined, with the exception of callbacks defined as
+  # \Callbacks are generally run in the order they are defined, with the exception of callbacks defined as
   # methods on the model, which are called last.
   #
   # == Ordering callbacks
@@ -234,30 +234,16 @@ module ActiveRecord
   #   end
   #
   # In this case the +log_children+ is executed before +do_something_else+.
-  # The same applies to all non-transactional callbacks.
+  # This applies to all non-transactional callbacks, and to +before_commit+.
   #
-  # As seen below, in case there are multiple transactional callbacks the order
-  # is reversed.
+  # For transactional +after_+ callbacks (+after_commit+, +after_rollback+, etc), the order
+  # can be set via configuration.
   #
-  # For example:
-  #
-  #   class Topic < ActiveRecord::Base
-  #     has_many :children
-  #
-  #     after_commit :log_children
-  #     after_commit :do_something_else
-  #
-  #     private
-  #       def log_children
-  #         # Child processing
-  #       end
-  #
-  #       def do_something_else
-  #         # Something else
-  #       end
-  #   end
+  #   config.active_record.run_after_transaction_callbacks_in_order_defined = false
   #
-  # In this case the +do_something_else+ is executed before +log_children+.
+  # When set to +true+ (the default from \Rails 7.1), callbacks are executed in the order they
+  # are defined, just like the example above. When set to +false+, the order is reversed, so
+  # +do_something_else+ is executed before +log_children+.
   #
   # == \Transactions
   #
@@ -460,7 +446,7 @@ module ActiveRecord
     end
 
     def _update_record
-      _run_update_callbacks { super }
+      _run_update_callbacks { record_update_timestamps { super } }
     end
   end
 end

data/lib/active_record/coders/column_serializer.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Coders # :nodoc:
+    class ColumnSerializer # :nodoc:
+      attr_reader :object_class
+      attr_reader :coder
+
+      def initialize(attr_name, coder, object_class = Object)
+        @attr_name = attr_name
+        @object_class = object_class
+        @coder = coder
+        check_arity_of_constructor
+      end
+
+      def init_with(coder) # :nodoc:
+        @attr_name = coder["attr_name"]
+        @object_class = coder["object_class"]
+        @coder = coder["coder"]
+      end
+
+      def dump(object)
+        return if object.nil?
+
+        assert_valid_value(object, action: "dump")
+        coder.dump(object)
+      end
+
+      def load(payload)
+        if payload.nil?
+          if @object_class != ::Object
+            return @object_class.new
+          end
+          return nil
+        end
+
+        object = coder.load(payload)
+
+        assert_valid_value(object, action: "load")
+        object ||= object_class.new if object_class != Object
+
+        object
+      end
+
+      # Public because it's called by Type::Serialized
+      def assert_valid_value(object, action:)
+        unless object.nil? || object_class === object
+          raise SerializationTypeMismatch,
+            "can't #{action} `#{@attr_name}`: was supposed to be a #{object_class}, but was a #{object.class}. -- #{object.inspect}"
+        end
+      end
+
+      private
+        def check_arity_of_constructor
+          load(nil)
+        rescue ArgumentError
+          raise ArgumentError, "Cannot serialize #{object_class}. Classes passed to `serialize` must have a 0 argument constructor."
+        end
+    end
+  end
+end

data/lib/active_record/coders/json.rb

@@ -2,7 +2,7 @@
 
 module ActiveRecord
   module Coders # :nodoc:
-    class JSON # :nodoc:
+    module JSON # :nodoc:
       def self.dump(obj)
         ActiveSupport::JSON.encode(obj)
       end

data/lib/active_record/coders/yaml_column.rb

@@ -4,37 +4,83 @@ require "yaml"
 
 module ActiveRecord
   module Coders # :nodoc:
-    class YAMLColumn # :nodoc:
-      attr_accessor :object_class
-
-      def initialize(attr_name, object_class = Object)
-        @attr_name = attr_name
-        @object_class = object_class
-        check_arity_of_constructor
-      end
+    class YAMLColumn < ColumnSerializer # :nodoc:
+      class SafeCoder
+        def initialize(permitted_classes: [], unsafe_load: nil)
+          @permitted_classes = permitted_classes
+          @unsafe_load = unsafe_load
+        end
 
-      def dump(obj)
-        return if obj.nil?
+        if Gem::Version.new(Psych::VERSION) >= Gem::Version.new("5.1")
+          def dump(object)
+            if @unsafe_load.nil? ? ActiveRecord.use_yaml_unsafe_load : @unsafe_load
+              ::YAML.dump(object)
+            else
+              ::YAML.safe_dump(
+                object,
+                permitted_classes: @permitted_classes + ActiveRecord.yaml_column_permitted_classes,
+                aliases: true,
+              )
+            end
+          end
+        else
+          def dump(object)
+            YAML.dump(object)
+          end
+        end
 
-        assert_valid_value(obj, action: "dump")
-        YAML.dump obj
+        if YAML.respond_to?(:unsafe_load)
+          def load(payload)
+            if @unsafe_load.nil? ? ActiveRecord.use_yaml_unsafe_load : @unsafe_load
+              YAML.unsafe_load(payload)
+            else
+              YAML.safe_load(
+                payload,
+                permitted_classes: @permitted_classes + ActiveRecord.yaml_column_permitted_classes,
+                aliases: true,
+              )
+            end
+          end
+        else
+          def load(payload)
+            if @unsafe_load.nil? ? ActiveRecord.use_yaml_unsafe_load : @unsafe_load
+              YAML.load(payload)
+            else
+              YAML.safe_load(
+                payload,
+                permitted_classes: @permitted_classes + ActiveRecord.yaml_column_permitted_classes,
+                aliases: true,
+              )
+            end
+          end
+        end
       end
 
-      def load(yaml)
-        return object_class.new if object_class != Object && yaml.nil?
-        return yaml unless yaml.is_a?(String) && yaml.start_with?("---")
-        obj = yaml_load(yaml)
-
-        assert_valid_value(obj, action: "load")
-        obj ||= object_class.new if object_class != Object
+      def initialize(attr_name, object_class = Object, permitted_classes: [], unsafe_load: nil)
+        super(
+          attr_name,
+          SafeCoder.new(permitted_classes: permitted_classes || [], unsafe_load: unsafe_load),
+          object_class,
+        )
+        check_arity_of_constructor
+      end
 
-        obj
+      def init_with(coder) # :nodoc:
+        unless coder["coder"]
+          permitted_classes = coder["permitted_classes"] || []
+          unsafe_load = coder["unsafe_load"] || false
+          coder["coder"] = SafeCoder.new(permitted_classes: permitted_classes, unsafe_load: unsafe_load)
+        end
+        super(coder)
       end
 
-      def assert_valid_value(obj, action:)
-        unless obj.nil? || obj.is_a?(object_class)
-          raise SerializationTypeMismatch,
-            "can't #{action} `#{@attr_name}`: was supposed to be a #{object_class}, but was a #{obj.class}. -- #{obj.inspect}"
+      def coder
+        # This is to retain forward compatibility when loading records serialized with Marshal
+        # from a previous version of Rails.
+        @coder ||= begin
+          permitted_classes = defined?(@permitted_classes) ? @permitted_classes : []
+          unsafe_load = defined?(@unsafe_load) && @unsafe_load.nil?
+          SafeCoder.new(permitted_classes: permitted_classes, unsafe_load: unsafe_load)
         end
       end
 
@@ -44,24 +90,6 @@ module ActiveRecord
         rescue ArgumentError
           raise ArgumentError, "Cannot serialize #{object_class}. Classes passed to `serialize` must have a 0 argument constructor."
         end
-
-        if YAML.respond_to?(:unsafe_load)
-          def yaml_load(payload)
-            if ActiveRecord.use_yaml_unsafe_load
-              YAML.unsafe_load(payload)
-            else
-              YAML.safe_load(payload, permitted_classes: ActiveRecord.yaml_column_permitted_classes, aliases: true)
-            end
-          end
-        else
-          def yaml_load(payload)
-            if ActiveRecord.use_yaml_unsafe_load
-              YAML.load(payload)
-            else
-              YAML.safe_load(payload, permitted_classes: ActiveRecord.yaml_column_permitted_classes, aliases: true)
-            end
-          end
-        end
     end
   end
 end

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

@@ -5,6 +5,8 @@ require "concurrent/map"
 
 module ActiveRecord
   module ConnectionAdapters
+    # = Active Record Connection Handler
+    #
     # ConnectionHandler is a collection of ConnectionPool objects. It is used
     # for keeping separate connection pools that connect to different databases.
     #
@@ -56,7 +58,7 @@ module ActiveRecord
       FINALIZER = lambda { |_| ActiveSupport::ForkTracker.check! }
       private_constant :FINALIZER
 
-      class StringConnectionOwner # :nodoc:
+      class StringConnectionName # :nodoc:
         attr_reader :name
 
         def initialize(name)
@@ -73,8 +75,8 @@ module ActiveRecord
       end
 
       def initialize
-        # These caches are keyed by pool_config.connection_specification_name (PoolConfig#connection_specification_name).
-        @owner_to_pool_manager = Concurrent::Map.new(initial_capacity: 2)
+        # 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
@@ -88,121 +90,154 @@ module ActiveRecord
         ActiveSupport::IsolatedExecutionState[:active_record_prevent_writes] = prevent_writes
       end
 
-      # Prevent writing to the database regardless of role.
-      #
-      # In some cases you may want to prevent writes to the database
-      # even if you are on a database that can write. +while_preventing_writes+
-      # will prevent writes to the database for the duration of the block.
-      #
-      # This method does not provide the same protection as a readonly
-      # user and is meant to be a safeguard against accidental writes.
-      #
-      # See +READ_QUERY+ for the queries that are blocked by this
-      # method.
-      def while_preventing_writes(enabled = true)
-        unless ActiveRecord.legacy_connection_handling
-          raise NotImplementedError, "`while_preventing_writes` is only available on the connection_handler with legacy_connection_handling"
-        end
-
-        original, self.prevent_writes = self.prevent_writes, enabled
-        yield
-      ensure
-        self.prevent_writes = original
-      end
-
       def connection_pool_names # :nodoc:
-        owner_to_pool_manager.keys
+        connection_name_to_pool_manager.keys
       end
 
       def all_connection_pools
-        owner_to_pool_manager.values.flat_map { |m| m.pool_configs.map(&:pool) }
+        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
 
-      def connection_pool_list(role = ActiveRecord::Base.current_role)
-        owner_to_pool_manager.values.flat_map { |m| m.pool_configs(role).map(&:pool) }
+      # 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
+          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) }
+        end
       end
       alias :connection_pools :connection_pool_list
 
-      def establish_connection(config, owner_name: Base, role: ActiveRecord::Base.current_role, shard: Base.current_shard)
-        owner_name = StringConnectionOwner.new(config.to_s) if config.is_a?(Symbol)
+      def each_connection_pool(role = nil, &block) # :nodoc:
+        role = nil if role == :all
+        return enum_for(__method__, role) unless block_given?
+
+        connection_name_to_pool_manager.each_value do |manager|
+          manager.each_pool_config(role) do |pool_config|
+            yield pool_config.pool
+          end
+        end
+      end
+
+      def establish_connection(config, owner_name: Base, role: Base.current_role, shard: Base.current_shard, clobber: false)
+        owner_name = determine_owner_name(owner_name, config)
 
         pool_config = resolve_pool_config(config, owner_name, role, shard)
         db_config = pool_config.db_config
 
-        # Protects the connection named `ActiveRecord::Base` from being removed
-        # if the user calls `establish_connection :primary`.
-        if owner_to_pool_manager.key?(pool_config.connection_specification_name)
-          remove_connection_pool(pool_config.connection_specification_name, role: role, shard: shard)
-        end
+        pool_manager = set_pool_manager(pool_config.connection_name)
 
-        message_bus = ActiveSupport::Notifications.instrumenter
-        payload = {}
-        if pool_config
-          payload[:spec_name] = pool_config.connection_specification_name
-          payload[:shard] = shard
-          payload[:config] = db_config.configuration_hash
-        end
+        # If there is an existing pool with the same values as the pool_config
+        # don't remove the connection. Connections should only be removed if we are
+        # establishing a connection on a class that is already connected to a different
+        # configuration.
+        existing_pool_config = pool_manager.get_pool_config(role, shard)
 
-        if ActiveRecord.legacy_connection_handling
-          owner_to_pool_manager[pool_config.connection_specification_name] ||= LegacyPoolManager.new
-        else
-          owner_to_pool_manager[pool_config.connection_specification_name] ||= PoolManager.new
-        end
-        pool_manager = get_pool_manager(pool_config.connection_specification_name)
-        pool_manager.set_pool_config(role, shard, pool_config)
+        if !clobber && existing_pool_config && existing_pool_config.db_config == db_config
+          # Update the pool_config's connection class if it differs. This is used
+          # for ensuring that ActiveRecord::Base and the primary_abstract_class use
+          # the same pool. Without this granular swapping will not work correctly.
+          if owner_name.primary_class? && (existing_pool_config.connection_class != owner_name)
+            existing_pool_config.connection_class = owner_name
+          end
 
-        message_bus.instrument("!connection.active_record", payload) do
-          pool_config.pool
+          existing_pool_config.pool
+        else
+          disconnect_pool_from_pool_manager(pool_manager, role, shard)
+          pool_manager.set_pool_config(role, shard, pool_config)
+
+          payload = {
+            connection_name: pool_config.connection_name,
+            role: role,
+            shard: shard,
+            config: db_config.configuration_hash
+          }
+
+          ActiveSupport::Notifications.instrumenter.instrument("!connection.active_record", payload) do
+            pool_config.pool
+          end
         end
       end
 
       # Returns true if there are any active connections among the connection
       # pools that the ConnectionHandler is managing.
-      def active_connections?(role = ActiveRecord::Base.current_role)
-        connection_pool_list(role).any?(&:active_connection?)
+      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
 
       # Returns any connections in use by the current thread back to the pool,
       # and also returns connections to the pool cached by threads that are no
       # longer alive.
-      def clear_active_connections!(role = ActiveRecord::Base.current_role)
-        connection_pool_list(role).each(&:release_connection)
+      def clear_active_connections!(role = nil)
+        if role.nil?
+          deprecation_for_pool_handling(__method__)
+          role = ActiveRecord::Base.current_role
+        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 = ActiveRecord::Base.current_role)
-        connection_pool_list(role).each(&:clear_reloadable_connections!)
+      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 = ActiveRecord::Base.current_role)
-        connection_pool_list(role).each(&:disconnect!)
+      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
 
       # Disconnects all currently idle connections.
       #
       # See ConnectionPool#flush! for details.
-      def flush_idle_connections!(role = ActiveRecord::Base.current_role)
-        connection_pool_list(role).each(&:flush!)
+      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
 
       # Locate the connection of the nearest super class. This can be an
       # active or defined connection: if it is the latter, it will be
       # opened and set as the active connection for the class it was defined
       # for (not necessarily the current class).
-      def retrieve_connection(spec_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard) # :nodoc:
-        pool = retrieve_connection_pool(spec_name, role: role, shard: shard)
+      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 '#{spec_name}' found for the '#{shard}' shard."
-          elsif ActiveRecord::Base.connection_handler != ActiveRecord::Base.default_connection_handler
-            message = "No connection pool for '#{spec_name}' found for the '#{ActiveRecord::Base.current_role}' role."
+            message = "No connection pool for '#{connection_name}' found for the '#{shard}' shard."
           elsif role != ActiveRecord::Base.default_role
-            message = "No connection pool for '#{spec_name}' found for the '#{role}' role."
+            message = "No connection pool for '#{connection_name}' found for the '#{role}' role."
           else
-            message = "No connection pool for '#{spec_name}' found."
+            message = "No connection pool for '#{connection_name}' found."
           end
 
           raise ConnectionNotEstablished, message
@@ -213,36 +248,66 @@ module ActiveRecord
 
       # Returns true if a connection that's accessible to this class has
       # already been opened.
-      def connected?(spec_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
-        pool = retrieve_connection_pool(spec_name, role: role, shard: shard)
+      def connected?(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
+        pool = retrieve_connection_pool(connection_name, role: role, shard: shard)
         pool && pool.connected?
       end
 
-      def remove_connection_pool(owner, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
-        if pool_manager = get_pool_manager(owner)
-          pool_config = pool_manager.remove_pool_config(role, shard)
-
-          if pool_config
-            pool_config.disconnect!
-            pool_config.db_config
-          end
+      def remove_connection_pool(connection_name, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
+        if pool_manager = get_pool_manager(connection_name)
+          disconnect_pool_from_pool_manager(pool_manager, role, shard)
         end
       end
 
-      # Retrieving the connection pool happens a lot, so we cache it in @owner_to_pool_manager.
+      # 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(owner, role: ActiveRecord::Base.current_role, shard: ActiveRecord::Base.current_shard)
-        pool_config = get_pool_manager(owner)&.get_pool_config(role, shard)
+      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
       end
 
       private
-        attr_reader :owner_to_pool_manager
+        attr_reader :connection_name_to_pool_manager
 
-        # Returns the pool manager for an owner.
-        def get_pool_manager(owner)
-          owner_to_pool_manager[owner]
+        # Returns the pool manager for a connection name / identifier.
+        def get_pool_manager(connection_name)
+          connection_name_to_pool_manager[connection_name]
+        end
+
+        # Get the existing pool manager or initialize and assign a new one.
+        def set_pool_manager(connection_name)
+          connection_name_to_pool_manager[connection_name] ||= PoolManager.new
+        end
+
+        def pool_managers
+          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)
+
+          if pool_config
+            pool_config.disconnect!
+            pool_config.db_config
+          end
         end
 
         # Returns an instance of PoolConfig for a given adapter.
@@ -255,7 +320,7 @@ module ActiveRecord
         #   pool_config.db_config.configuration_hash
         #   # => { host: "localhost", database: "foo", adapter: "sqlite3" }
         #
-        def resolve_pool_config(config, owner_name, role, shard)
+        def resolve_pool_config(config, connection_name, role, shard)
           db_config = Base.configurations.resolve(config)
 
           raise(AdapterNotSpecified, "database configuration does not specify adapter") unless db_config.adapter
@@ -285,7 +350,17 @@ module ActiveRecord
             raise AdapterNotFound, "database configuration specifies nonexistent #{db_config.adapter} adapter"
           end
 
-          ConnectionAdapters::PoolConfig.new(owner_name, db_config, role, shard)
+          ConnectionAdapters::PoolConfig.new(connection_name, db_config, role, shard)
+        end
+
+        def determine_owner_name(owner_name, config)
+          if owner_name.is_a?(String) || owner_name.is_a?(Symbol)
+            StringConnectionName.new(owner_name.to_s)
+          elsif config.is_a?(Symbol)
+            StringConnectionName.new(config.to_s)
+          else
+            owner_name
+          end
         end
     end
   end

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

@@ -6,6 +6,8 @@ require "monitor"
 module ActiveRecord
   module ConnectionAdapters
     class ConnectionPool
+      # = Active Record Connection Pool \Queue
+      #
       # Threadsafe, fair, LIFO queue.  Meant to be used by ConnectionPool
       # with which it shares a Monitor.
       class Queue