activerecord 8.0.2.1 → 8.1.0.beta1

data/lib/active_record/connection_adapters/trilogy/database_statements.rb

@@ -29,7 +29,8 @@ module ActiveRecord
               raw_connection.next_result
             end
             verified!
-            handle_warnings(sql)
+
+            notification_payload[:affected_rows] = result.affected_rows
             notification_payload[:row_count] = result.count
             result
           ensure
@@ -40,9 +41,9 @@ module ActiveRecord
 
           def cast_result(result)
             if result.fields.empty?
-              ActiveRecord::Result.empty
+              ActiveRecord::Result.empty(affected_rows: result.affected_rows)
             else
-              ActiveRecord::Result.new(result.fields, result.rows)
+              ActiveRecord::Result.new(result.fields, result.rows, affected_rows: result.affected_rows)
             end
           end
 

data/lib/active_record/connection_adapters/trilogy_adapter.rb

@@ -181,7 +181,7 @@ module ActiveRecord
           end
 
           case exception
-          when ::Trilogy::ConnectionClosed, ::Trilogy::EOFError
+          when ::Trilogy::ConnectionClosed, ::Trilogy::EOFError, ::Trilogy::SSLError
             return ConnectionFailed.new(message, connection_pool: @pool)
           when ::Trilogy::Error
             if exception.is_a?(SystemCallError) || exception.message.include?("TRILOGY_INVALID_SEQUENCE_ID")

data/lib/active_record/connection_adapters.rb

@@ -84,6 +84,7 @@ module ActiveRecord
     autoload_at "active_record/connection_adapters/abstract/schema_definitions" do
       autoload :IndexDefinition
       autoload :ColumnDefinition
+      autoload :ColumnMethods
       autoload :ChangeColumnDefinition
       autoload :ChangeColumnDefaultDefinition
       autoload :ForeignKeyDefinition

data/lib/active_record/connection_handling.rb

@@ -301,7 +301,7 @@ module ActiveRecord
 
     # 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.
+    # #with_connection, that same connection is yielded.
     # 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

data/lib/active_record/core.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/enumerable"
-require "active_support/core_ext/module/delegation"
 require "active_support/parameter_filter"
 require "concurrent/map"
 
@@ -112,7 +111,7 @@ module ActiveRecord
       #   Post.attributes_for_inspect = [:id, :title]
       #   Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!">"
       #
-      # When set to `:all` inspect will list all the record's attributes:
+      # When set to +:all+ inspect will list all the record's attributes:
       #
       #   Post.attributes_for_inspect = :all
       #   Post.first.inspect #=> "#<Post id: 1, title: "Hello, World!", published_at: "2023-10-23 14:28:11 +0000">"
@@ -358,6 +357,8 @@ module ActiveRecord
       def filter_attributes=(filter_attributes)
         @inspection_filter = nil
         @filter_attributes = filter_attributes
+
+        FilterAttributeHandler.sensitive_attribute_was_declared(self, filter_attributes)
       end
 
       def inspection_filter # :nodoc:
@@ -451,7 +452,7 @@ module ActiveRecord
               where(wheres).limit(1)
             }
 
-            statement.execute(values.flatten, connection, allow_retry: true).then do |r|
+            statement.execute(values.flatten, connection).then do |r|
               r.first
             rescue TypeError
               raise ActiveRecord::StatementInvalid
@@ -600,7 +601,7 @@ module ActiveRecord
     #
     #   topic = Topic.new(title: "Budget", author_name: "Jason")
     #   topic.slice(:title, :author_name)
-    #   => { "title" => "Budget", "author_name" => "Jason" }
+    #   # => { "title" => "Budget", "author_name" => "Jason" }
     #
     #--
     # Implemented by ActiveModel::Access#slice.
@@ -614,7 +615,7 @@ module ActiveRecord
     #
     #   topic = Topic.new(title: "Budget", author_name: "Jason")
     #   topic.values_at(:title, :author_name)
-    #   => ["Budget", "Jason"]
+    #   # => ["Budget", "Jason"]
     #
     #--
     # Implemented by ActiveModel::Access#values_at.
@@ -641,7 +642,7 @@ module ActiveRecord
     def hash
       id = self.id
 
-      if primary_key_values_present?
+      if self.class.composite_primary_key? ? primary_key_values_present? : id
         self.class.hash ^ id.hash
       else
         super
@@ -691,12 +692,14 @@ module ActiveRecord
     # Sets the record to strict_loading mode. This will raise an error
     # if the record tries to lazily load an association.
     #
+    # NOTE: Strict loading is disabled during validation in order to let the record validate its association.
+    #
     #   user = User.first
     #   user.strict_loading! # => true
     #   user.address.city
-    #   => ActiveRecord::StrictLoadingViolationError
+    #   # => ActiveRecord::StrictLoadingViolationError
     #   user.comments.to_a
-    #   => ActiveRecord::StrictLoadingViolationError
+    #   # => ActiveRecord::StrictLoadingViolationError
     #
     # ==== Parameters
     #
@@ -716,7 +719,7 @@ module ActiveRecord
     #   user.address.city # => "Tatooine"
     #   user.comments.to_a # => [#<Comment:0x00...]
     #   user.comments.first.ratings.to_a
-    #   => ActiveRecord::StrictLoadingViolationError
+    #   # => ActiveRecord::StrictLoadingViolationError
     def strict_loading!(value = true, mode: :all)
       unless [:all, :n_plus_one_only].include?(mode)
         raise ArgumentError, "The :mode option must be one of [:all, :n_plus_one_only] but #{mode.inspect} was provided."

data/lib/active_record/counter_cache.rb

@@ -17,7 +17,7 @@ module ActiveRecord
       #
       # ==== Parameters
       #
-      # * +id+ - The id of the object you wish to reset a counter on.
+      # * +id+ - The id of the object you wish to reset a counter on or an array of ids.
       # * +counters+ - One or more association counters to reset. Association name or counter name can be given.
       # * <tt>:touch</tt> - Touch timestamp columns when updating.
       #   Pass +true+ to touch +updated_at+ and/or +updated_on+. Pass a symbol to
@@ -28,13 +28,25 @@ module ActiveRecord
       #   # For the Post with id #1, reset the comments_count
       #   Post.reset_counters(1, :comments)
       #
+      #   # For posts with ids #1 and #2, reset the comments_count
+      #   Post.reset_counters([1, 2], :comments)
+      #
       #   # Like above, but also touch the updated_at and/or updated_on
       #   # attributes.
       #   Post.reset_counters(1, :comments, touch: true)
       def reset_counters(id, *counters, touch: nil)
-        object = find(id)
+        ids = if composite_primary_key?
+          if id.first.is_a?(Array)
+            id
+          else
+            [id]
+          end
+        else
+          Array(id)
+        end
+
+        updates = Hash.new { |h, k| h[k] = {} }
 
-        updates = {}
         counters.each do |counter_association|
           has_many_association = _reflect_on_association(counter_association)
           unless has_many_association
@@ -48,14 +60,22 @@ module ActiveRecord
             has_many_association = has_many_association.through_reflection
           end
 
+          counter_association = counter_association.to_sym
           foreign_key  = has_many_association.foreign_key.to_s
           child_class  = has_many_association.klass
           reflection   = child_class._reflections.values.find { |e| e.belongs_to? && e.foreign_key.to_s == foreign_key && e.options[:counter_cache].present? }
           counter_name = reflection.counter_cache_column
 
-          count_was = object.send(counter_name)
-          count = object.send(counter_association).count(:all)
-          updates[counter_name] = count if count != count_was
+          counts =
+            unscoped
+              .joins(counter_association)
+              .where(primary_key => ids)
+              .group(primary_key)
+              .count(:all)
+
+          ids.each do |id|
+            updates[id].merge!(counter_name => counts[id] || 0)
+          end
         end
 
         if touch
@@ -63,10 +83,15 @@ module ActiveRecord
           names = Array.wrap(names)
           options = names.extract_options!
           touch_updates = touch_attributes_with_time(*names, **options)
-          updates.merge!(touch_updates)
+
+          updates.each_value do |record_updates|
+            record_updates.merge!(touch_updates)
+          end
         end
 
-        unscoped.where(primary_key => [object.id]).update_all(updates) if updates.any?
+        updates.each do |id, record_updates|
+          unscoped.where(primary_key => [id]).update_all(record_updates)
+        end
 
         true
       end

data/lib/active_record/database_configurations/database_config.rb

@@ -48,7 +48,11 @@ module ActiveRecord
         raise NotImplementedError
       end
 
-      def pool
+      def min_connections
+        raise NotImplementedError
+      end
+
+      def max_connections
         raise NotImplementedError
       end
 

data/lib/active_record/database_configurations/hash_config.rb

@@ -38,6 +38,7 @@ module ActiveRecord
       def initialize(env_name, name, configuration_hash)
         super(env_name, name)
         @configuration_hash = configuration_hash.symbolize_keys.freeze
+        validate_configuration!
       end
 
       # Determines whether a database configuration is for a replica / readonly
@@ -69,16 +70,32 @@ module ActiveRecord
         @configuration_hash = configuration_hash.merge(database: database).freeze
       end
 
-      def pool
-        (configuration_hash[:pool] || 5).to_i
+      def max_connections
+        (configuration_hash[:max_connections] || configuration_hash[:pool] || 5).to_i
       end
 
+      def min_connections
+        (configuration_hash[:min_connections] || 0).to_i
+      end
+
+      alias :pool :max_connections
+      deprecate pool: :max_connections, deprecator: ActiveRecord.deprecator
+
       def min_threads
         (configuration_hash[:min_threads] || 0).to_i
       end
 
       def max_threads
-        (configuration_hash[:max_threads] || pool).to_i
+        (configuration_hash[:max_threads] || max_connections).to_i
+      end
+
+      def max_age
+        v = configuration_hash[:max_age]&.to_i
+        if v && v > 0
+          v
+        else
+          Float::INFINITY
+        end
       end
 
       def query_cache
@@ -93,10 +110,8 @@ module ActiveRecord
         (configuration_hash[:checkout_timeout] || 5).to_f
       end
 
-      # `reaping_frequency` is configurable mostly for historical reasons, but it
-      # could also be useful if someone wants a very low `idle_timeout`.
-      def reaping_frequency
-        configuration_hash.fetch(:reaping_frequency, 60)&.to_f
+      def reaping_frequency # :nodoc:
+        configuration_hash.fetch(:reaping_frequency, default_reaping_frequency)&.to_f
       end
 
       def idle_timeout
@@ -104,6 +119,11 @@ module ActiveRecord
         timeout if timeout > 0
       end
 
+      def keepalive
+        keepalive = (configuration_hash[:keepalive] || 600).to_f
+        keepalive if keepalive > 0
+      end
+
       def adapter
         configuration_hash[:adapter]&.to_s
       end
@@ -146,7 +166,7 @@ module ActiveRecord
       #
       # If the config option is set that will be used. Otherwise Rails will generate
       # the filename from the database config name.
-      def schema_dump(format = ActiveRecord.schema_format)
+      def schema_dump(format = schema_format)
         if configuration_hash.key?(:schema_dump)
           if config = configuration_hash[:schema_dump]
             config
@@ -158,6 +178,12 @@ module ActiveRecord
         end
       end
 
+      def schema_format # :nodoc:
+        format = configuration_hash.fetch(:schema_format, ActiveRecord.schema_format).to_sym
+        raise "Invalid schema format" unless [:ruby, :sql].include?(format)
+        format
+      end
+
       def database_tasks? # :nodoc:
         !replica? && !!configuration_hash.fetch(:database_tasks, true)
       end
@@ -168,13 +194,34 @@ module ActiveRecord
 
       private
         def schema_file_type(format)
-          case format
+          case format.to_sym
           when :ruby
             "schema.rb"
           when :sql
             "structure.sql"
           end
         end
+
+        def default_reaping_frequency
+          # Reap every 20 seconds by default, but run more often as necessary to
+          # meet other configured timeouts.
+          [20, idle_timeout, max_age, keepalive].compact.min
+        end
+
+        def validate_configuration!
+          if configuration_hash[:pool] && configuration_hash[:max_connections]
+            pool_val = configuration_hash[:pool].to_i
+            max_conn_val = configuration_hash[:max_connections].to_i
+
+            if pool_val != max_conn_val
+              raise "Ambiguous configuration: 'pool' (#{pool_val}) and 'max_connections' (#{max_conn_val}) are set to different values. Prefer just 'max_connections'."
+            end
+          end
+
+          if configuration_hash[:pool] && configuration_hash[:min_connections]
+            raise "Ambiguous configuration: when setting 'min_connections', use 'max_connections' instead of 'pool'."
+          end
+        end
     end
   end
 end

data/lib/active_record/database_configurations/url_config.rb

@@ -47,9 +47,8 @@ module ActiveRecord
           @configuration_hash[:schema_dump] = false
         end
 
-        if @configuration_hash[:query_cache] == "false"
-          @configuration_hash[:query_cache] = false
-        end
+        query_cache = parse_query_cache
+        @configuration_hash[:query_cache] = query_cache unless query_cache.nil?
 
         to_boolean!(@configuration_hash, :replica)
         to_boolean!(@configuration_hash, :database_tasks)
@@ -58,6 +57,17 @@ module ActiveRecord
       end
 
       private
+        def parse_query_cache
+          case value = @configuration_hash[:query_cache]
+          when /\A\d+\z/
+            value.to_i
+          when "false"
+            false
+          else
+            value
+          end
+        end
+
         def to_boolean!(configuration_hash, key)
           if configuration_hash[key].is_a?(String)
             configuration_hash[key] = configuration_hash[key] != "false"

data/lib/active_record/database_configurations.rb

@@ -36,9 +36,11 @@ module ActiveRecord
     # to respond to `sharded?`. To implement this define the following in an
     # initializer:
     #
-    #   ActiveRecord::DatabaseConfigurations.register_db_config_handler do |env_name, name, url, config|
-    #     next unless config.key?(:vitess)
-    #     VitessConfig.new(env_name, name, config)
+    #   ActiveSupport.on_load(:active_record_database_configurations) do
+    #     ActiveRecord::DatabaseConfigurations.register_db_config_handler do |env_name, name, url, config|
+    #       next unless config.key?(:vitess)
+    #       VitessConfig.new(env_name, name, config)
+    #     end
     #   end
     #
     # Note: applications must handle the condition in which custom config should be
@@ -306,4 +308,6 @@ module ActiveRecord
         url
       end
   end
+
+  ActiveSupport.run_load_hooks(:active_record_database_configurations, DatabaseConfigurations)
 end

data/lib/active_record/delegated_type.rb

@@ -202,7 +202,7 @@ module ActiveRecord
     #   @entry.access_notice_message
     #   @entry.access_notice_message?
     #
-    # === Options
+    # ==== Options
     #
     # The +options+ are passed directly to the +belongs_to+ call, so this is where you declare +dependent+ etc.
     # The following options can be included to specialize the behavior of the delegated type convenience methods.
@@ -229,7 +229,7 @@ module ActiveRecord
     #   @entry.message_uuid # => returns entryable_uuid, when entryable_type == "Message", otherwise nil
     #   @entry.comment_uuid # => returns entryable_uuid, when entryable_type == "Comment", otherwise nil
     def delegated_type(role, types:, **options)
-      belongs_to role, options.delete(:scope), **options.merge(polymorphic: true)
+      belongs_to role, options.delete(:scope), **options, polymorphic: true
       define_delegated_type_methods role, types: types, options: options
     end
 

data/lib/active_record/dynamic_matchers.rb

@@ -7,16 +7,18 @@ module ActiveRecord
         if self == Base
           super
         else
-          match = Method.match(self, name)
-          match && match.valid? || super
+          super || begin
+            match = Method.match(name)
+            match && match.valid?(self, name)
+          end
         end
       end
 
       def method_missing(name, ...)
-        match = Method.match(self, name)
+        match = Method.match(name)
 
-        if match && match.valid?
-          match.define
+        if match && match.valid?(self, name)
+          match.define(self, name)
           send(name, ...)
         else
           super
@@ -24,97 +26,80 @@ module ActiveRecord
       end
 
       class Method
-        @matchers = []
-
         class << self
-          attr_reader :matchers
-
-          def match(model, name)
-            klass = matchers.find { |k| k.pattern.match?(name) }
-            klass.new(model, name) if klass
+          def match(name)
+            FindBy.match?(name) || FindByBang.match?(name)
           end
 
-          def pattern
-            @pattern ||= /\A#{prefix}_([_a-zA-Z]\w*)#{suffix}\Z/
+          def valid?(model, name)
+            attribute_names(model, name.to_s).all? { |name| model.columns_hash[name] || model.reflect_on_aggregation(name.to_sym) }
           end
 
-          def prefix
-            raise NotImplementedError
+          def define(model, name)
+            model.class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def self.#{name}(#{signature(model, name)})
+              #{body(model, name)}
+            end
+            CODE
           end
 
-          def suffix
-            ""
-          end
-        end
+          private
+            def make_pattern(prefix, suffix)
+              /\A#{prefix}_([_a-zA-Z]\w*)#{suffix}\Z/
+            end
 
-        attr_reader :model, :name, :attribute_names
+            def attribute_names(model, name)
+              attribute_names = name.match(pattern)[1].split("_and_")
+              attribute_names.map! { |name| model.attribute_aliases[name] || name }
+            end
 
-        def initialize(model, method_name)
-          @model           = model
-          @name            = method_name.to_s
-          @attribute_names = @name.match(self.class.pattern)[1].split("_and_")
-          @attribute_names.map! { |name| @model.attribute_aliases[name] || name }
-        end
+            def body(model, method_name)
+              "#{finder}(#{attributes_hash(model, method_name)})"
+            end
 
-        def valid?
-          attribute_names.all? { |name| model.columns_hash[name] || model.reflect_on_aggregation(name.to_sym) }
-        end
+            # The parameters in the signature may have reserved Ruby words, in order
+            # to prevent errors, we start each param name with `_`.
+            def signature(model, method_name)
+              attribute_names(model, method_name.to_s).map { |name| "_#{name}" }.join(", ")
+            end
 
-        def define
-          model.class_eval <<-CODE, __FILE__, __LINE__ + 1
-            def self.#{name}(#{signature})
-              #{body}
+            # Given that the parameters starts with `_`, the finder needs to use the
+            # same parameter name.
+            def attributes_hash(model, method_name)
+              "{" + attribute_names(model, method_name).map { |name| ":#{name} => _#{name}" }.join(",") + "}"
             end
-          CODE
         end
+      end
 
-        private
-          def body
-            "#{finder}(#{attributes_hash})"
-          end
+      class FindBy < Method
+        @pattern = make_pattern("find_by", "")
 
-          # The parameters in the signature may have reserved Ruby words, in order
-          # to prevent errors, we start each param name with `_`.
-          def signature
-            attribute_names.map { |name| "_#{name}" }.join(", ")
-          end
+        class << self
+          attr_reader :pattern
 
-          # Given that the parameters starts with `_`, the finder needs to use the
-          # same parameter name.
-          def attributes_hash
-            "{" + attribute_names.map { |name| ":#{name} => _#{name}" }.join(",") + "}"
+          def match?(name)
+            pattern.match?(name) && self
           end
 
           def finder
-            raise NotImplementedError
+            "find_by"
           end
-      end
-
-      class FindBy < Method
-        Method.matchers << self
-
-        def self.prefix
-          "find_by"
-        end
-
-        def finder
-          "find_by"
         end
       end
 
       class FindByBang < Method
-        Method.matchers << self
+        @pattern = make_pattern("find_by", "!")
 
-        def self.prefix
-          "find_by"
-        end
+        class << self
+          attr_reader :pattern
 
-        def self.suffix
-          "!"
-        end
+          def match?(name)
+            pattern.match?(name) && self
+          end
 
-        def finder
-          "find_by!"
+          def finder
+            "find_by!"
+          end
         end
       end
   end

data/lib/active_record/encryption/encryptable_record.rb

@@ -16,7 +16,7 @@ module ActiveRecord
       class_methods do
         # Encrypts the +name+ attribute.
         #
-        # === Options
+        # ==== Options
         #
         # * <tt>:key_provider</tt> - A key provider to provide encryption and decryption keys. Defaults to
         #   +ActiveRecord::Encryption.key_provider+.
@@ -30,10 +30,10 @@ module ActiveRecord
         #   will use the oldest encryption scheme to encrypt new data by default. You can change this by setting
         #   <tt>deterministic: { fixed: false }</tt>. That will make it use the newest encryption scheme for encrypting new
         #   data.
-        # * <tt>:support_unencrypted_data</tt> - If `config.active_record.encryption.support_unencrypted_data` is +true+,
-        #   you can set this to +false+ to opt out of unencrypted data support for this attribute. This is useful for
-        #   scenarios where you encrypt one column, and want to disable support for unencrypted data without having to tweak
-        #   the global setting.
+        # * <tt>:support_unencrypted_data</tt> - When true, unencrypted data can be read normally. When false, it will raise errors.
+        #   Falls back to +config.active_record.encryption.support_unencrypted_data+ if no value is provided.
+        #   This is useful for scenarios where you encrypt one column, and want to disable support for unencrypted data
+        #   without having to tweak the global setting.
         # * <tt>:downcase</tt> - When true, it converts the encrypted content to downcase automatically. This allows to
         #   effectively ignore case when querying data. Notice that the case is lost. Use +:ignore_case+ if you are interested
         #   in preserving it.

data/lib/active_record/encryption/encrypted_attribute_type.rb

@@ -15,7 +15,7 @@ module ActiveRecord
       delegate :key_provider, :downcase?, :deterministic?, :previous_schemes, :with_context, :fixed?, to: :scheme
       delegate :accessor, :type, to: :cast_type
 
-      # === Options
+      # ==== Options
       #
       # * <tt>:scheme</tt> - A +Scheme+ with the encryption properties for this attribute.
       # * <tt>:cast_type</tt> - A type that will be used to serialize (before encrypting) and deserialize
@@ -59,7 +59,7 @@ module ActiveRecord
       end
 
       def support_unencrypted_data?
-        ActiveRecord::Encryption.config.support_unencrypted_data && scheme.support_unencrypted_data? && !previous_type?
+        scheme.support_unencrypted_data? && !previous_type?
       end
 
       private