activerecord 7.2.4 → 8.1.4

data/lib/active_record/connection_handling.rb

@@ -87,6 +87,8 @@ module ActiveRecord
 
       connections = []
 
+      @shard_keys = shards.keys
+
       if shards.empty?
         shards[:default] = database
       end
@@ -98,7 +100,8 @@ module ActiveRecord
           db_config = resolve_config_for_connection(database_key)
 
           self.connection_class = true
-          connections << connection_handler.establish_connection(db_config, owner_name: self, role: role, shard: shard.to_sym)
+          shard = shard.to_sym unless shard.is_a? Integer
+          connections << connection_handler.establish_connection(db_config, owner_name: self, role: role, shard: shard)
         end
       end
 
@@ -177,6 +180,18 @@ module ActiveRecord
       end
     end
 
+    # Passes the block to +connected_to+ for every +shard+ the
+    # model is configured to connect to (if any), and returns the
+    # results in an array.
+    #
+    # Optionally, +role+ and/or +prevent_writes+ can be passed which
+    # will be forwarded to each +connected_to+ call.
+    def connected_to_all_shards(role: nil, prevent_writes: false, &blk)
+      shard_keys.map do |shard|
+        connected_to(shard: shard, role: role, prevent_writes: prevent_writes, &blk)
+      end
+    end
+
     # Use a specified connection.
     #
     # This method is useful for ensuring that a specific connection is
@@ -289,7 +304,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
@@ -361,6 +376,14 @@ module ActiveRecord
       connection_pool.schema_cache.clear!
     end
 
+    def shard_keys
+      connection_class_for_self.instance_variable_get(:@shard_keys) || []
+    end
+
+    def sharded?
+      shard_keys.any?
+    end
+
     private
       def resolve_config_for_connection(config_or_env)
         raise "Anonymous class is not allowed." unless name

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"
 
@@ -89,6 +88,7 @@ module ActiveRecord
       class_attribute :belongs_to_required_by_default, instance_accessor: false
 
       class_attribute :strict_loading_by_default, instance_accessor: false, default: false
+      class_attribute :strict_loading_mode, instance_accessor: false, default: :all
 
       class_attribute :has_many_inversing, instance_accessor: false, default: false
 
@@ -111,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">"
@@ -201,6 +201,17 @@ module ActiveRecord
         false
       end
 
+      # Intended to behave like `.current_preventing_writes` given the class name as input.
+      # See PoolConfig and ConnectionHandler::ConnectionDescriptor.
+      def self.preventing_writes?(class_name) # :nodoc:
+        connected_to_stack.reverse_each do |hash|
+          return hash[:prevent_writes] if !hash[:prevent_writes].nil? && hash[:klasses].include?(Base)
+          return hash[:prevent_writes] if !hash[:prevent_writes].nil? && hash[:klasses].any? { |klass| klass.name == class_name }
+        end
+
+        false
+      end
+
       def self.connected_to_stack # :nodoc:
         if connected_to_stack = ActiveSupport::IsolatedExecutionState[:active_record_connected_to_stack]
           connected_to_stack
@@ -346,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:
@@ -381,7 +394,7 @@ module ActiveRecord
       end
 
       def predicate_builder # :nodoc:
-        @predicate_builder ||= PredicateBuilder.new(table_metadata)
+        @predicate_builder ||= PredicateBuilder.new(TableMetadata.new(self, arel_table))
       end
 
       def type_caster # :nodoc:
@@ -426,10 +439,6 @@ module ActiveRecord
           end
         end
 
-        def table_metadata
-          TableMetadata.new(self, arel_table)
-        end
-
         def cached_find_by(keys, values)
           with_connection do |connection|
             statement = cached_find_by_statement(connection, keys) { |params|
@@ -443,8 +452,8 @@ module ActiveRecord
               where(wheres).limit(1)
             }
 
-            begin
-              statement.execute(values.flatten, connection, allow_retry: true).first
+            statement.execute(values.flatten, connection).then do |r|
+              r.first
             rescue TypeError
               raise ActiveRecord::StatementInvalid
             end
@@ -540,12 +549,7 @@ module ActiveRecord
 
     ##
     def initialize_dup(other) # :nodoc:
-      @attributes = @attributes.deep_dup
-      if self.class.composite_primary_key?
-        @primary_key.each { |key| @attributes.reset(key) }
-      else
-        @attributes.reset(@primary_key)
-      end
+      @attributes = init_attributes(other)
 
       _run_initialize_callbacks
 
@@ -557,6 +561,18 @@ module ActiveRecord
       super
     end
 
+    def init_attributes(_) # :nodoc:
+      attrs = @attributes.deep_dup
+
+      if self.class.composite_primary_key?
+        @primary_key.each { |key| attrs.reset(key) }
+      else
+        attrs.reset(@primary_key)
+      end
+
+      attrs
+    end
+
     # Populate +coder+ with attributes about this record that should be
     # serialized. The structure of +coder+ defined in this method is
     # guaranteed to match the structure of +coder+ passed to the #init_with
@@ -626,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
@@ -830,7 +846,7 @@ module ActiveRecord
 
         @primary_key         = klass.primary_key
         @strict_loading      = klass.strict_loading_by_default
-        @strict_loading_mode = :all
+        @strict_loading_mode = klass.strict_loading_mode
 
         klass.define_attribute_methods
       end

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,27 @@ 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)
+        if composite_primary_key?
+          ids = id.first.is_a?(Array) ? id : [id]
+          types = primary_key.map { |column| type_for_attribute(column) }
+          ids = ids.map do |id_value|
+            id_value.map.with_index { |id, i| types[i].cast(id) }
+          end
+        else
+          ids = Array(id)
+          type = type_for_attribute(primary_key)
+          ids = ids.map { |id| type.cast(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 +62,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 +85,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
 
@@ -99,6 +103,10 @@ module ActiveRecord
       def use_metadata_table?
         raise NotImplementedError
       end
+
+      def seeds?
+        raise NotImplementedError
+      end
     end
   end
 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,35 @@ module ActiveRecord
         @configuration_hash = configuration_hash.merge(database: database).freeze
       end
 
-      def pool
-        (configuration_hash[:pool] || 5).to_i
+      def max_connections
+        max_connections = configuration_hash.fetch(:max_connections) {
+          configuration_hash.fetch(:pool, 5)
+        }&.to_i
+        max_connections if max_connections && max_connections >= 0
       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 || 5).clamp(0, 5)).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 +113,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 +122,18 @@ module ActiveRecord
         timeout if timeout > 0
       end
 
+      def keepalive
+        case keepalive = configuration_hash[:keepalive]
+        when false
+          nil
+        when nil, true
+          600.0 # default
+        else
+          keepalive = keepalive.to_f
+          keepalive if keepalive > 0.0
+        end
+      end
+
       def adapter
         configuration_hash[:adapter]&.to_s
       end
@@ -130,6 +160,14 @@ module ActiveRecord
         Base.configurations.primary?(name)
       end
 
+      # Determines whether the db:prepare task should seed the database from db/seeds.rb.
+      #
+      # If the `seeds` key is present in the config, `seeds?` will return its value.  Otherwise, it
+      # will return `true` for the primary database and `false` for all other configs.
+      def seeds?
+        configuration_hash.fetch(:seeds, primary?)
+      end
+
       # Determines whether to dump the schema/structure files and the filename that
       # should be used.
       #
@@ -138,7 +176,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
@@ -150,6 +188,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
@@ -160,13 +204,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,17 +47,29 @@ 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)
+        to_boolean!(@configuration_hash, :seeds)
+        to_boolean!(@configuration_hash, :use_metadata_table)
 
         @configuration_hash.freeze
       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

@@ -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/disable_joins_association_relation.rb

@@ -27,7 +27,11 @@ module ActiveRecord
       records = @records
 
       records_by_id = records.group_by do |record|
-        record[key]
+        if key.is_a?(Array)
+          key.map { |column| record[column] }
+        else
+          record[key]
+        end
       end
 
       records = ids.flat_map { |id| records_by_id[id] }