activerecord 7.1.4 → 7.2.0.beta1

data/lib/active_record/connection_adapters.rb

@@ -1,9 +1,130 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/string/filters"
+
 module ActiveRecord
   module ConnectionAdapters
     extend ActiveSupport::Autoload
 
+    @adapters = {}
+
+    class << self
+      # Registers a custom database adapter.
+      #
+      # Can also be used to define aliases.
+      #
+      # == Example
+      #
+      #   ActiveRecord::ConnectionAdapters.register("megadb", "MegaDB::ActiveRecordAdapter", "mega_db/active_record_adapter")
+      #
+      #   ActiveRecord::ConnectionAdapters.register("mysql", "ActiveRecord::ConnectionAdapters::TrilogyAdapter", "active_record/connection_adapters/trilogy_adapter")
+      #
+      def register(name, class_name, path = class_name.underscore)
+        @adapters[name.to_s] = [class_name, path]
+      end
+
+      def resolve(adapter_name) # :nodoc:
+        # Require the adapter itself and give useful feedback about
+        #   1. Missing adapter gems.
+        #   2. Incorrectly registered adapters.
+        #   3. Adapter gems' missing dependencies.
+        class_name, path_to_adapter = @adapters[adapter_name.to_s]
+
+        unless class_name
+          # To provide better error messages for adapters expecting the pre-7.2 adapter registration API, we attempt
+          # to load the adapter file from the old location which was required by convention, and then raise an error
+          # describing how to upgrade the adapter to the new API.
+          legacy_adapter_path = "active_record/connection_adapters/#{adapter_name}_adapter"
+          legacy_adapter_connection_method_name = "#{adapter_name}_connection".to_sym
+
+          begin
+            require legacy_adapter_path
+            # If we reach here it means we found the found a file that may be the legacy adapter and should raise.
+            if ActiveRecord::ConnectionHandling.method_defined?(legacy_adapter_connection_method_name)
+              # If we find the connection method then we care certain it is a legacy adapter.
+              deprecation_message = <<~MSG.squish
+                Database configuration specifies '#{adapter_name}' adapter but that adapter has not been registered.
+                Rails 7.2 has changed the way Active Record database adapters are loaded. The adapter needs to be
+                updated to register itself rather than being loaded by convention.
+                Ensure that the adapter in the Gemfile is at the latest version. If it is, then the adapter may need to
+                be modified.
+                See:
+                https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters.html#method-c-register
+              MSG
+
+              exception_message = <<~MSG.squish
+                Database configuration specifies '#{adapter_name}' adapter but that adapter has not been registered.
+                Ensure that the adapter in the Gemfile is at the latest version. If it is, then the adapter may need to
+                be modified.
+              MSG
+            else
+              # If we do not find the connection method we are much less certain it is a legacy adapter. Even though the
+              # file exists in the location defined by convenntion, it does not necessarily mean that file is supposed
+              # to define the adapter the legacy way. So raise an error that explains both possibilities.
+              deprecation_message = <<~MSG.squish
+                Database configuration specifies nonexistent '#{adapter_name}' adapter.
+                Available adapters are: #{@adapters.keys.sort.join(", ")}.
+                Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary
+                adapter gem to your Gemfile if it's not in the list of available adapters.
+                Rails 7.2 has changed the way Active Record database adapters are loaded. Ensure that the adapter in
+                the Gemfile is at the latest version. If it is up to date, the adapter may need to be modified.
+                See:
+                https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters.html#method-c-register
+              MSG
+
+              exception_message = <<~MSG.squish
+                Database configuration specifies nonexistent '#{adapter_name}' adapter.
+                Available adapters are: #{@adapters.keys.sort.join(", ")}.
+                Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary
+                adapter gem to your Gemfile and that it is at its latest version. If it is up to date, the adapter may
+                need to be modified.
+              MSG
+            end
+
+            ActiveRecord.deprecator.warn(deprecation_message)
+            raise AdapterNotFound, exception_message
+          rescue LoadError => error
+            # The adapter was not found in the legacy location so fall through to the error handling for a missing adapter.
+          end
+
+          raise AdapterNotFound, <<~MSG.squish
+            Database configuration specifies nonexistent '#{adapter_name}' adapter.
+            Available adapters are: #{@adapters.keys.sort.join(", ")}.
+            Ensure that the adapter is spelled correctly in config/database.yml and that you've added the necessary
+            adapter gem to your Gemfile if it's not in the list of available adapters.
+          MSG
+        end
+
+        unless Object.const_defined?(class_name)
+          begin
+            require path_to_adapter
+          rescue LoadError => error
+            # We couldn't require the adapter itself.
+            if error.path == path_to_adapter
+              # We can assume here that a non-builtin adapter was specified and the path
+              # registered by the adapter gem is incorrect.
+              raise LoadError, "Error loading the '#{adapter_name}' Active Record adapter. Ensure that the path registered by the adapter gem is correct. #{error.message}", error.backtrace
+            else
+              # Bubbled up from the adapter require. Prefix the exception message
+              # with some guidance about how to address it and reraise.
+              raise LoadError, "Error loading the '#{adapter_name}' Active Record adapter. Missing a gem it depends on? #{error.message}", error.backtrace
+            end
+          end
+        end
+
+        begin
+          Object.const_get(class_name)
+        rescue NameError => error
+          raise AdapterNotFound, "Could not load the #{class_name} Active Record adapter (#{error.message})."
+        end
+      end
+    end
+
+    register "sqlite3", "ActiveRecord::ConnectionAdapters::SQLite3Adapter", "active_record/connection_adapters/sqlite3_adapter"
+    register "mysql2", "ActiveRecord::ConnectionAdapters::Mysql2Adapter", "active_record/connection_adapters/mysql2_adapter"
+    register "trilogy", "ActiveRecord::ConnectionAdapters::TrilogyAdapter", "active_record/connection_adapters/trilogy_adapter"
+    register "postgresql", "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter", "active_record/connection_adapters/postgresql_adapter"
+
     eager_autoload do
       autoload :AbstractAdapter
     end

data/lib/active_record/connection_handling.rb

@@ -243,22 +243,64 @@ module ActiveRecord
     # Clears the query cache for all connections associated with the current thread.
     def clear_query_caches_for_current_thread
       connection_handler.each_connection_pool do |pool|
-        pool.connection.clear_query_cache if pool.active_connection?
+        pool.clear_query_cache
       end
     end
 
     # Returns the connection currently associated with the class. This can
     # also be used to "borrow" the connection to do database work unrelated
     # to any of the specific Active Records.
+    # The connection will remain leased for the entire duration of the request
+    # or job, or until +#release_connection+ is called.
+    def lease_connection
+      connection_pool.lease_connection
+    end
+
+    # Soft deprecated. Use +#with_connection+ or +#lease_connection+ instead.
     def connection
-      retrieve_connection
+      pool = connection_pool
+      if pool.permanent_lease?
+        case ActiveRecord.permanent_connection_checkout
+        when :deprecated
+          ActiveRecord.deprecator.warn <<~MESSAGE
+            Called deprecated `ActiveRecord::Base.connection` method.
+
+            Either use `with_connection` or `lease_connection`.
+          MESSAGE
+        when :disallowed
+          raise ActiveRecordError, <<~MESSAGE
+            Called deprecated `ActiveRecord::Base.connection` method.
+
+            Either use `with_connection` or `lease_connection`.
+          MESSAGE
+        end
+        pool.lease_connection
+      else
+        pool.active_connection
+      end
+    end
+
+    # Return the currently leased connection into the pool
+    def release_connection
+      connection_pool.release_connection
+    end
+
+    # Checkouts a connection from the pool, yield it and then check it back in.
+    # If a connection was already leased via #lease_connection or a parent call to
+    # #with_connection, that same connection is yieled.
+    # If #lease_connection is called inside the block, the connection won't be checked
+    # back in.
+    # If #connection is called inside the block, the connection won't be checked back in
+    # unless the +prevent_permanent_checkout+ argument is set to +true+.
+    def with_connection(prevent_permanent_checkout: false, &block)
+      connection_pool.with_connection(prevent_permanent_checkout: prevent_permanent_checkout, &block)
     end
 
     attr_writer :connection_specification_name
 
     # Returns the connection specification name from the current class or its parent.
     def connection_specification_name
-      if !defined?(@connection_specification_name) || @connection_specification_name.nil?
+      if @connection_specification_name.nil?
         return self == Base ? Base.name : superclass.connection_specification_name
       end
       @connection_specification_name
@@ -279,8 +321,12 @@ module ActiveRecord
       connection_pool.db_config
     end
 
+    def adapter_class # :nodoc:
+      connection_pool.db_config.adapter_class
+    end
+
     def connection_pool
-      connection_handler.retrieve_connection_pool(connection_specification_name, role: current_role, shard: current_shard) || raise(ConnectionNotEstablished)
+      connection_handler.retrieve_connection_pool(connection_specification_name, role: current_role, shard: current_shard, strict: true)
     end
 
     def retrieve_connection
@@ -292,16 +338,9 @@ module ActiveRecord
       connection_handler.connected?(connection_specification_name, role: current_role, shard: current_shard)
     end
 
-    def remove_connection(name = nil)
-      if name
-        ActiveRecord.deprecator.warn(<<-MSG.squish)
-          The name argument for `#remove_connection` is deprecated without replacement
-          and will be removed in Rails 7.2. `#remove_connection` should always be called
-          on the connection class directly, which makes the name argument obsolete.
-        MSG
-      end
+    def remove_connection
+      name = @connection_specification_name if defined?(@connection_specification_name)
 
-      name ||= @connection_specification_name if defined?(@connection_specification_name)
       # if removing a connection that has a pool, we reset the
       # connection_specification_name so it will use the parent
       # pool.
@@ -312,39 +351,15 @@ module ActiveRecord
       connection_handler.remove_connection_pool(name, role: current_role, shard: current_shard)
     end
 
-    def clear_cache! # :nodoc:
-      connection.schema_cache.clear!
-    end
-
-    def clear_active_connections!(role = nil)
-      deprecation_for_delegation(__method__)
-      connection_handler.clear_active_connections!(role)
-    end
-
-    def clear_reloadable_connections!(role = nil)
-      deprecation_for_delegation(__method__)
-      connection_handler.clear_reloadable_connections!(role)
+    def schema_cache # :nodoc:
+      connection_pool.schema_cache
     end
 
-    def clear_all_connections!(role = nil)
-      deprecation_for_delegation(__method__)
-      connection_handler.clear_all_connections!(role)
-    end
-
-    def flush_idle_connections!(role = nil)
-      deprecation_for_delegation(__method__)
-      connection_handler.flush_idle_connections!(role)
+    def clear_cache! # :nodoc:
+      connection_pool.schema_cache.clear!
     end
 
     private
-      def deprecation_for_delegation(method)
-        ActiveRecord.deprecator.warn(<<-MSG.squish)
-          Calling `ActiveRecord::Base.#{method} is deprecated. Please
-          call the method directly on the connection handler; for
-          example: `ActiveRecord::Base.connection_handler.#{method}`.
-        MSG
-      end
-
       def resolve_config_for_connection(config_or_env)
         raise "Anonymous class is not allowed." unless name
 

data/lib/active_record/core.rb

@@ -73,7 +73,7 @@ module ActiveRecord
       end
       self.configurations = {}
 
-      # Returns fully resolved ActiveRecord::DatabaseConfigurations object
+      # Returns a fully resolved ActiveRecord::DatabaseConfigurations object.
       def self.configurations
         @@configurations
       end
@@ -102,6 +102,9 @@ module ActiveRecord
 
       class_attribute :shard_selector, instance_accessor: false, default: nil
 
+      # Specifies the attributes that will be included in the output of the #inspect method
+      class_attribute :attributes_for_inspect, instance_accessor: false, default: [:id]
+
       def self.application_record_class? # :nodoc:
         if ActiveRecord.application_record_class
           self == ActiveRecord.application_record_class
@@ -351,7 +354,7 @@ module ActiveRecord
         elsif abstract_class?
           "#{super}(abstract)"
         elsif !connected?
-          "#{super} (call '#{super}.connection' to establish a connection)"
+          "#{super} (call '#{super}.lease_connection' to establish a connection)"
         elsif table_exists?
           attr_list = attribute_types.map { |name, type| "#{name}: #{type.type}" } * ", "
           "#{super}(#{attr_list})"
@@ -373,7 +376,7 @@ module ActiveRecord
         TypeCaster::Map.new(self)
       end
 
-      def cached_find_by_statement(key, &block) # :nodoc:
+      def cached_find_by_statement(connection, key, &block) # :nodoc:
         cache = @find_by_statement_cache[connection.prepared_statements]
         cache.compute_if_absent(key) { StatementCache.create(connection, &block) }
       end
@@ -416,21 +419,23 @@ module ActiveRecord
         end
 
         def cached_find_by(keys, values)
-          statement = cached_find_by_statement(keys) { |params|
-            wheres = keys.index_with do |key|
-              if key.is_a?(Array)
-                [key.map { params.bind }]
-              else
-                params.bind
+          with_connection do |connection|
+            statement = cached_find_by_statement(connection, keys) { |params|
+              wheres = keys.index_with do |key|
+                if key.is_a?(Array)
+                  [key.map { params.bind }]
+                else
+                  params.bind
+                end
               end
-            end
-            where(wheres).limit(1)
-          }
+              where(wheres).limit(1)
+            }
 
-          begin
-            statement.execute(values.flatten, connection).first
-          rescue TypeError
-            raise ActiveRecord::StatementInvalid
+            begin
+              statement.execute(values.flatten, connection, allow_retry: true).first
+            rescue TypeError
+              raise ActiveRecord::StatementInvalid
+            end
           end
         end
     end
@@ -450,7 +455,7 @@ module ActiveRecord
       init_internals
       initialize_internals_callback
 
-      assign_attributes(attributes) if attributes
+      super
 
       yield self if block_given?
       _run_initialize_callbacks
@@ -719,21 +724,14 @@ module ActiveRecord
       self.class.connection_handler
     end
 
-    # Returns the contents of the record as a nicely formatted string.
+    # Returns the attributes specified by <tt>.attributes_for_inspect</tt> as a nicely formatted string.
     def inspect
-      # We check defined?(@attributes) not to issue warnings if the object is
-      # allocated but not initialized.
-      inspection = if defined?(@attributes) && @attributes
-        attribute_names.filter_map do |name|
-          if _has_attribute?(name)
-            "#{name}: #{attribute_for_inspect(name)}"
-          end
-        end.join(", ")
-      else
-        "not initialized"
-      end
+      inspect_with_attributes(attributes_for_inspect)
+    end
 
-      "#<#{self.class} #{inspection}>"
+    # Returns the full contents of the record as a nicely formatted string.
+    def full_inspect
+      inspect_with_attributes(attribute_names)
     end
 
     # Takes a PP and prettily prints this record to it, allowing you to get a nice result from <tt>pp record</tt>
@@ -741,17 +739,17 @@ module ActiveRecord
     def pretty_print(pp)
       return super if custom_inspect_method_defined?
       pp.object_address_group(self) do
-        if defined?(@attributes) && @attributes
-          attr_names = self.class.attribute_names.select { |name| _has_attribute?(name) }
+        if @attributes
+          attr_names = attributes_for_inspect.select { |name| _has_attribute?(name.to_s) }
           pp.seplist(attr_names, proc { pp.text "," }) do |attr_name|
+            attr_name = attr_name.to_s
             pp.breakable " "
             pp.group(1) do
               pp.text attr_name
               pp.text ":"
               pp.breakable
-              value = _read_attribute(attr_name)
-              value = inspection_filter.filter_param(attr_name, value) unless value.nil?
-              pp.pp value
+              value = attribute_for_inspect(attr_name)
+              pp.text value
             end
           end
         else
@@ -789,7 +787,6 @@ module ActiveRecord
         @strict_loading_mode = :all
 
         klass.define_attribute_methods
-        klass.generate_alias_attributes
       end
 
       def initialize_internals_callback
@@ -809,5 +806,24 @@ module ActiveRecord
       def inspection_filter
         self.class.inspection_filter
       end
+
+      def inspect_with_attributes(attributes_to_list)
+        inspection = if @attributes
+          attributes_to_list.filter_map do |name|
+            name = name.to_s
+            if _has_attribute?(name)
+              "#{name}: #{attribute_for_inspect(name)}"
+            end
+          end.join(", ")
+        else
+          "not initialized"
+        end
+
+        "#<#{self.class} #{inspection}>"
+      end
+
+      def attributes_for_inspect
+        self.class.attributes_for_inspect == :all ? attribute_names : self.class.attributes_for_inspect
+      end
   end
 end

data/lib/active_record/counter_cache.rb

@@ -7,6 +7,7 @@ module ActiveRecord
 
     included do
       class_attribute :_counter_cache_columns, instance_accessor: false, default: []
+      class_attribute :counter_cached_association_names, instance_writer: false, default: []
     end
 
     module ClassMethods
@@ -181,14 +182,26 @@ module ActiveRecord
       def counter_cache_column?(name) # :nodoc:
         _counter_cache_columns.include?(name)
       end
+
+      def load_schema! # :nodoc:
+        super
+
+        association_names = _reflections.filter_map do |name, reflection|
+          next unless reflection.belongs_to? && reflection.counter_cache_column
+
+          name.to_sym
+        end
+
+        self.counter_cached_association_names |= association_names
+      end
     end
 
     private
       def _create_record(attribute_names = self.attribute_names)
         id = super
 
-        each_counter_cached_associations do |association|
-          association.increment_counters
+        counter_cached_association_names.each do |association_name|
+          association(association_name).increment_counters
         end
 
         id
@@ -198,7 +211,9 @@ module ActiveRecord
         affected_rows = super
 
         if affected_rows > 0
-          each_counter_cached_associations do |association|
+          counter_cached_association_names.each do |association_name|
+            association = association(association_name)
+
             unless destroyed_by_association && _foreign_keys_equal?(destroyed_by_association.foreign_key, association.reflection.foreign_key)
               association.decrement_counters
             end
@@ -208,12 +223,6 @@ module ActiveRecord
         affected_rows
       end
 
-      def each_counter_cached_associations
-        _reflections.each do |name, reflection|
-          yield association(name.to_sym) if reflection.belongs_to? && reflection.counter_cache_column
-        end
-      end
-
       def _foreign_keys_equal?(fkey1, fkey2)
         fkey1 == fkey2 || Array(fkey1).map(&:to_sym) == Array(fkey2).map(&:to_sym)
       end

data/lib/active_record/database_configurations/connection_url_resolver.rb

@@ -25,8 +25,7 @@ module ActiveRecord
       def initialize(url)
         raise "Database URL cannot be empty" if url.blank?
         @uri     = uri_parser.parse(url)
-        @adapter = @uri.scheme && @uri.scheme.tr("-", "_")
-        @adapter = "postgresql" if @adapter == "postgres"
+        @adapter = resolved_adapter
 
         if @uri.opaque
           @uri.opaque, @query = @uri.opaque.split("?", 2)
@@ -80,6 +79,12 @@ module ActiveRecord
           end
         end
 
+        def resolved_adapter
+          adapter = uri.scheme && @uri.scheme.tr("-", "_")
+          adapter = ActiveRecord.protocol_adapters[adapter] || adapter
+          adapter
+        end
+
         # Returns name of the database.
         def database_from_path
           if @adapter == "sqlite3"

data/lib/active_record/database_configurations/database_config.rb

@@ -11,14 +11,21 @@ module ActiveRecord
       def initialize(env_name, name)
         @env_name = env_name
         @name = name
+        @adapter_class = nil
       end
 
-      def adapter_method
-        "#{adapter}_connection"
+      def adapter_class
+        @adapter_class ||= ActiveRecord::ConnectionAdapters.resolve(adapter)
       end
 
-      def adapter_class_method
-        "#{adapter}_adapter_class"
+      def new_connection
+        adapter_class.new(configuration_hash)
+      end
+
+      def validate!
+        adapter_class if adapter
+
+        true
       end
 
       def host
@@ -84,6 +91,10 @@ module ActiveRecord
       def schema_cache_path
         raise NotImplementedError
       end
+
+      def use_metadata_table?
+        raise NotImplementedError
+      end
     end
   end
 end