activerecord 7.1.4 → 7.2.0.beta1

data/lib/active_record/reflection.rb

@@ -11,6 +11,7 @@ module ActiveRecord
       class_attribute :_reflections, instance_writer: false, default: {}
       class_attribute :aggregate_reflections, instance_writer: false, default: {}
       class_attribute :automatic_scope_inversing, instance_writer: false, default: false
+      class_attribute :automatically_invert_plural_associations, instance_writer: false, default: false
     end
 
     class << self
@@ -21,12 +22,12 @@ module ActiveRecord
 
       def add_reflection(ar, name, reflection)
         ar.clear_reflections_cache
-        name = -name.to_s
+        name = name.to_sym
         ar._reflections = ar._reflections.except(name).merge!(name => reflection)
       end
 
       def add_aggregate_reflection(ar, name, reflection)
-        ar.aggregate_reflections = ar.aggregate_reflections.merge(-name.to_s => reflection)
+        ar.aggregate_reflections = ar.aggregate_reflections.merge(name.to_sym => reflection)
       end
 
       private
@@ -67,7 +68,7 @@ module ActiveRecord
       #   Account.reflect_on_aggregation(:balance) # => the balance AggregateReflection
       #
       def reflect_on_aggregation(aggregation)
-        aggregate_reflections[aggregation.to_s]
+        aggregate_reflections[aggregation.to_sym]
       end
 
       # Returns a Hash of name of the reflection as the key and an AssociationReflection as the value.
@@ -75,6 +76,10 @@ module ActiveRecord
       #   Account.reflections # => {"balance" => AggregateReflection}
       #
       def reflections
+        normalized_reflections.stringify_keys
+      end
+
+      def normalized_reflections # :nodoc
         @__reflections ||= begin
           ref = {}
 
@@ -83,13 +88,13 @@ module ActiveRecord
 
             if parent_reflection
               parent_name = parent_reflection.name
-              ref[parent_name.to_s] = parent_reflection
+              ref[parent_name] = parent_reflection
             else
               ref[name] = reflection
             end
           end
 
-          ref
+          ref.freeze
         end
       end
 
@@ -104,7 +109,7 @@ module ActiveRecord
       #   Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
       #
       def reflect_on_all_associations(macro = nil)
-        association_reflections = reflections.values
+        association_reflections = normalized_reflections.values
         association_reflections.select! { |reflection| reflection.macro == macro } if macro
         association_reflections
       end
@@ -115,16 +120,18 @@ module ActiveRecord
       #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
       #
       def reflect_on_association(association)
-        reflections[association.to_s]
+        normalized_reflections[association.to_sym]
       end
 
       def _reflect_on_association(association) # :nodoc:
-        _reflections[association.to_s]
+        _reflections[association.to_sym]
       end
 
       # Returns an array of AssociationReflection objects for all associations which have <tt>:autosave</tt> enabled.
       def reflect_on_all_autosave_associations
-        reflections.values.select { |reflection| reflection.options[:autosave] }
+        reflections = normalized_reflections.values
+        reflections.select! { |reflection| reflection.options[:autosave] }
+        reflections
       end
 
       def clear_reflections_cache # :nodoc:
@@ -235,14 +242,16 @@ module ActiveRecord
       end
 
       def counter_cache_column
-        @counter_cache_column ||= if belongs_to?
-          if options[:counter_cache] == true
-            -"#{active_record.name.demodulize.underscore.pluralize}_count"
-          elsif options[:counter_cache]
-            -options[:counter_cache].to_s
+        @counter_cache_column ||= begin
+          counter_cache = options[:counter_cache]
+
+          if belongs_to?
+            if counter_cache
+              counter_cache[:column] || -"#{active_record.name.demodulize.underscore.pluralize}_count"
+            end
+          else
+            -((counter_cache && -counter_cache[:column]) || "#{name}_count")
           end
-        else
-          -(options[:counter_cache]&.to_s || "#{name}_count")
         end
       end
 
@@ -291,7 +300,7 @@ module ActiveRecord
         inverse_of && inverse_which_updates_counter_cache == inverse_of
       end
 
-      # Returns whether a counter cache should be used for this association.
+      # Returns whether this association has a counter cache.
       #
       # The counter_cache option must be given on either the owner or inverse
       # association, and the column must be present on the owner.
@@ -301,6 +310,17 @@ module ActiveRecord
           active_record.has_attribute?(counter_cache_column)
       end
 
+      # Returns whether this association has a counter cache and its column values were backfilled
+      # (and so it is used internally by methods like +size+/+any?+/etc).
+      def has_active_cached_counter?
+        return false unless has_cached_counter?
+
+        counter_cache = options[:counter_cache] ||
+                        (inverse_which_updates_counter_cache && inverse_which_updates_counter_cache.options[:counter_cache])
+
+        counter_cache[:active] != false
+      end
+
       def counter_must_be_updated_by_has_many?
         !inverse_updates_counter_in_memory? && has_cached_counter?
       end
@@ -377,12 +397,11 @@ module ActiveRecord
         super()
         @name          = name
         @scope         = scope
-        @options       = options
+        @options       = normalize_options(options)
         @active_record = active_record
         @klass         = options[:anonymous_class]
         @plural_name   = active_record.pluralize_table_names ?
                             name.to_s.pluralize : name.to_s
-        validate_reflection!
       end
 
       def autosave=(autosave)
@@ -409,13 +428,17 @@ module ActiveRecord
       # a new association object. Use +build_association+ or +create_association+
       # instead. This allows plugins to hook into association object creation.
       def klass
-        @klass ||= compute_class(class_name)
+        @klass ||= compute_class(compute_name(class_name))
       end
 
       def compute_class(name)
         name.constantize
       end
 
+      def compute_name(name) # :nodoc:
+        active_record.name.demodulize == name ? "::#{name}" : name
+      end
+
       # Returns +true+ if +self+ and +other_aggregation+ have the same +name+ attribute, +active_record+ attribute,
       # and +other_aggregation+ has an options hash assigned to it.
       def ==(other_aggregation)
@@ -435,15 +458,24 @@ module ActiveRecord
           name.to_s.camelize
         end
 
-        def validate_reflection!
-          return unless options[:foreign_key].is_a?(Array)
+        def normalize_options(options)
+          counter_cache = options.delete(:counter_cache)
 
-          message = <<~MSG.squish
-            Passing #{options[:foreign_key]} array to :foreign_key option
-            on the #{active_record}##{name} association is not supported.
-            Use the query_constraints: #{options[:foreign_key]} option instead to represent a composite foreign key.
-          MSG
-          raise ArgumentError, message
+          if counter_cache
+            active = true
+
+            case counter_cache
+            when String, Symbol
+              column = -counter_cache.to_s
+            when Hash
+              active = counter_cache.fetch(:active, true)
+              column = counter_cache[:column]&.to_s
+            end
+
+            options[:counter_cache] = { active: active, column: column }
+          end
+
+          options
         end
     end
 
@@ -494,6 +526,17 @@ module ActiveRecord
         @foreign_key = nil
         @association_foreign_key = nil
         @association_primary_key = nil
+        if options[:query_constraints]
+          ActiveRecord.deprecator.warn <<~MSG.squish
+            Setting `query_constraints:` option on `#{active_record}.#{macro} :#{name}` is deprecated.
+            To maintain current behavior, use the `foreign_key` option instead.
+          MSG
+        end
+
+        # If the foreign key is an array, set query constraints options and don't use the foreign key
+        if options[:foreign_key].is_a?(Array)
+          options[:query_constraints] = options.delete(:foreign_key)
+        end
 
         ensure_option_not_given_as_class!(:class_name)
       end
@@ -503,7 +546,9 @@ module ActiveRecord
         if polymorphic?
           key = [key, owner._read_attribute(@foreign_type)]
         end
-        klass.cached_find_by_statement(key, &block)
+        klass.with_connection do |connection|
+          klass.cached_find_by_statement(connection, key, &block)
+        end
       end
 
       def join_table
@@ -511,10 +556,14 @@ module ActiveRecord
       end
 
       def foreign_key(infer_from_inverse_of: true)
-        @foreign_key ||= if options[:query_constraints]
+        @foreign_key ||= if options[:foreign_key]
+          if options[:foreign_key].is_a?(Array)
+            options[:foreign_key].map { |fk| fk.to_s.freeze }.freeze
+          else
+            options[:foreign_key].to_s.freeze
+          end
+        elsif options[:query_constraints]
           options[:query_constraints].map { |fk| fk.to_s.freeze }.freeze
-        elsif options[:foreign_key]
-          options[:foreign_key].to_s
         else
           derived_fk = derive_foreign_key(infer_from_inverse_of: infer_from_inverse_of)
 
@@ -711,6 +760,10 @@ module ActiveRecord
 
             begin
               reflection = klass._reflect_on_association(inverse_name)
+              if !reflection && active_record.automatically_invert_plural_associations
+                plural_inverse_name = ActiveSupport::Inflector.pluralize(inverse_name)
+                reflection = klass._reflect_on_association(plural_inverse_name)
+              end
             rescue NameError => error
               raise unless error.name.to_s == class_name
 
@@ -720,7 +773,7 @@ module ActiveRecord
             end
 
             if valid_inverse_reflection?(reflection)
-              inverse_name
+              reflection.name
             end
           end
         end
@@ -933,7 +986,7 @@ module ActiveRecord
       end
 
       def klass
-        @klass ||= delegate_reflection.compute_class(class_name)
+        @klass ||= delegate_reflection.compute_class(compute_name(class_name))
       end
 
       # Returns the source of the through reflection. It checks both a singularized
@@ -954,6 +1007,8 @@ module ActiveRecord
       #   # => <ActiveRecord::Reflection::BelongsToReflection: @name=:tag, @active_record=Tagging, @plural_name="tags">
       #
       def source_reflection
+        return unless source_reflection_name
+
         through_reflection.klass._reflect_on_association(source_reflection_name)
       end
 
@@ -1111,7 +1166,7 @@ module ActiveRecord
         end
 
         if parent_reflection.nil?
-          reflections = active_record.reflections.keys.map(&:to_sym)
+          reflections = active_record.normalized_reflections.keys
 
           if reflections.index(through_reflection.name) > reflections.index(name)
             raise HasManyThroughOrderError.new(active_record.name, self, through_reflection)

data/lib/active_record/relation/batches/batch_enumerator.rb

@@ -77,13 +77,26 @@ module ActiveRecord
         end
       end
 
-      # Destroys records in batches.
+      # Touches records in batches. Returns the total number of rows affected.
+      #
+      #   Person.in_batches.touch_all
+      #
+      # See Relation#touch_all for details of how each batch is touched.
+      def touch_all(...)
+        sum do |relation|
+          relation.touch_all(...)
+        end
+      end
+
+      # Destroys records in batches. Returns the total number of rows affected.
       #
       #   Person.where("age < 10").in_batches.destroy_all
       #
       # See Relation#destroy_all for details of how each batch is destroyed.
       def destroy_all
-        each(&:destroy_all)
+        sum do |relation|
+          relation.destroy_all.count(&:destroyed?)
+        end
       end
 
       # Yields an ActiveRecord::Relation object for each batch of records.

data/lib/active_record/relation/batches.rb

@@ -345,15 +345,15 @@ module ActiveRecord
           end
         end
 
-        records = records.sort_by { |record| record.id }
+        records.sort_by!(&:id)
 
         if order == :desc
           records.reverse!
         end
 
-        (0...records.size).step(batch_limit).each do |start|
+        records.each_slice(batch_limit) do |subrecords|
           subrelation = relation.spawn
-          subrelation.load_records(records[start, batch_limit])
+          subrelation.load_records(subrecords)
 
           yield subrelation
         end

data/lib/active_record/relation/calculations.rb

@@ -234,7 +234,7 @@ module ActiveRecord
         if operation == "count"
           unless distinct_value || distinct_select?(column_name || select_for_count)
             relation.distinct!
-            relation.select_values = [ klass.primary_key || table[Arel.star] ]
+            relation.select_values = Array(klass.primary_key || table[Arel.star])
           end
           # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
           relation.order_values = [] if group_values.empty?
@@ -275,6 +275,10 @@ module ActiveRecord
     #   # SELECT people.id FROM people WHERE people.age = 21 LIMIT 5
     #   # => [2, 3]
     #
+    #   Comment.joins(:person).pluck(:id, person: [:id])
+    #   # SELECT comments.id, people.id FROM comments INNER JOIN people on comments.person_id = people.id
+    #   # => [[1, 2], [2, 2]]
+    #
     #   Person.pluck(Arel.sql('DATEDIFF(updated_at, created_at)'))
     #   # SELECT DATEDIFF(updated_at, created_at) FROM people
     #   # => ['0', '27761', '173']
@@ -302,7 +306,7 @@ module ActiveRecord
         relation = apply_join_dependency
         relation.pluck(*column_names)
       else
-        klass.disallow_raw_sql!(column_names.flatten)
+        klass.disallow_raw_sql!(flattened_args(column_names))
         columns = arel_columns(column_names)
         relation = spawn
         relation.select_values = columns
@@ -310,7 +314,9 @@ module ActiveRecord
           if where_clause.contradiction?
             ActiveRecord::Result.empty(async: @async)
           else
-            klass.connection.select_all(relation.arel, "#{klass.name} Pluck", async: @async)
+            klass.with_connection do |c|
+              c.select_all(relation.arel, "#{klass.name} Pluck", async: @async)
+            end
           end
         end
         result.then do |result|
@@ -357,7 +363,7 @@ module ActiveRecord
     # Returns the base model's ID's for the relation using the table's primary key
     #
     #   Person.ids # SELECT people.id FROM people
-    #   Person.joins(:companies).ids # SELECT people.id FROM people INNER JOIN companies ON companies.id = people.company_id
+    #   Person.joins(:company).ids # SELECT people.id FROM people INNER JOIN companies ON companies.id = people.company_id
     def ids
       primary_key_array = Array(primary_key)
 
@@ -385,7 +391,9 @@ module ActiveRecord
         ActiveRecord::Result.empty
       else
         skip_query_cache_if_necessary do
-          klass.connection.select_all(relation, "#{klass.name} Ids", async: @async)
+          klass.with_connection do |c|
+            c.select_all(relation, "#{klass.name} Ids", async: @async)
+          end
         end
       end
 
@@ -442,7 +450,7 @@ module ActiveRecord
         return column_name if Arel::Expressions === column_name
 
         arel_column(column_name.to_s) do |name|
-          Arel.sql(column_name == :all ? "*" : name)
+          column_name == :all ? Arel.sql("*", retryable: true) : Arel.sql(name)
         end
       end
 
@@ -451,7 +459,7 @@ module ActiveRecord
       end
 
       def execute_simple_calculation(operation, column_name, distinct) # :nodoc:
-        if operation == "count" && (column_name == :all && distinct || has_limit_or_offset?)
+        if build_count_subquery?(operation, column_name, distinct)
           # Shortcut when limit is zero.
           return 0 if limit_value == 0
 
@@ -474,7 +482,9 @@ module ActiveRecord
           ActiveRecord::Result.empty
         else
           skip_query_cache_if_necessary do
-            @klass.connection.select_all(query_builder, "#{@klass.name} #{operation.capitalize}", async: @async)
+            @klass.with_connection do |c|
+              c.select_all(query_builder, "#{@klass.name} #{operation.capitalize}", async: @async)
+            end
           end
         end
 
@@ -500,68 +510,73 @@ module ActiveRecord
         end
         group_fields = arel_columns(group_fields)
 
-        column_alias_tracker = ColumnAliasTracker.new(connection)
+        @klass.with_connection do |connection|
+          column_alias_tracker = ColumnAliasTracker.new(connection)
 
-        group_aliases = group_fields.map { |field|
-          field = connection.visitor.compile(field) if Arel.arel_node?(field)
-          column_alias_tracker.alias_for(field.to_s.downcase)
-        }
-        group_columns = group_aliases.zip(group_fields)
+          group_aliases = group_fields.map { |field|
+            field = connection.visitor.compile(field) if Arel.arel_node?(field)
+            column_alias_tracker.alias_for(field.to_s.downcase)
+          }
+          group_columns = group_aliases.zip(group_fields)
 
-        column = aggregate_column(column_name)
-        column_alias = column_alias_tracker.alias_for("#{operation} #{column_name.to_s.downcase}")
-        select_value = operation_over_aggregate_column(column, operation, distinct)
-        select_value.as(connection.quote_column_name(column_alias))
+          column = aggregate_column(column_name)
+          column_alias = column_alias_tracker.alias_for("#{operation} #{column_name.to_s.downcase}")
+          select_value = operation_over_aggregate_column(column, operation, distinct)
+          select_value.as(adapter_class.quote_column_name(column_alias))
 
-        select_values = [select_value]
-        select_values += self.select_values unless having_clause.empty?
+          select_values = [select_value]
+          select_values += self.select_values unless having_clause.empty?
 
-        select_values.concat group_columns.map { |aliaz, field|
-          aliaz = connection.quote_column_name(aliaz)
-          if field.respond_to?(:as)
-            field.as(aliaz)
-          else
-            "#{field} AS #{aliaz}"
-          end
-        }
-
-        relation = except(:group).distinct!(false)
-        relation.group_values  = group_fields
-        relation.select_values = select_values
-
-        result = skip_query_cache_if_necessary { @klass.connection.select_all(relation.arel, "#{@klass.name} #{operation.capitalize}", async: @async) }
-        result.then do |calculated_data|
-          if association
-            key_ids     = calculated_data.collect { |row| row[group_aliases.first] }
-            key_records = association.klass.base_class.where(association.klass.base_class.primary_key => key_ids)
-            key_records = key_records.index_by(&:id)
-          end
+          select_values.concat group_columns.map { |aliaz, field|
+            aliaz = adapter_class.quote_column_name(aliaz)
+            if field.respond_to?(:as)
+              field.as(aliaz)
+            else
+              "#{field} AS #{aliaz}"
+            end
+          }
 
-          key_types = group_columns.each_with_object({}) do |(aliaz, col_name), types|
-            types[aliaz] = col_name.try(:type_caster) ||
-              type_for(col_name) do
-                calculated_data.column_types.fetch(aliaz, Type.default_value)
-              end
+          relation = except(:group).distinct!(false)
+          relation.group_values  = group_fields
+          relation.select_values = select_values
+
+          result = skip_query_cache_if_necessary do
+            connection.select_all(relation.arel, "#{@klass.name} #{operation.capitalize}", async: @async)
           end
 
-          hash_rows = calculated_data.cast_values(key_types).map! do |row|
-            calculated_data.columns.each_with_object({}).with_index do |(col_name, hash), i|
-              hash[col_name] = row[i]
+          result.then do |calculated_data|
+            if association
+              key_ids     = calculated_data.collect { |row| row[group_aliases.first] }
+              key_records = association.klass.base_class.where(association.klass.base_class.primary_key => key_ids)
+              key_records = key_records.index_by(&:id)
             end
-          end
 
-          if operation != "count"
-            type = column.try(:type_caster) ||
-              lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value
-            type = type.subtype if Enum::EnumType === type
-          end
+            key_types = group_columns.each_with_object({}) do |(aliaz, col_name), types|
+              types[aliaz] = col_name.try(:type_caster) ||
+                type_for(col_name) do
+                  calculated_data.column_types.fetch(aliaz, Type.default_value)
+                end
+            end
+
+            hash_rows = calculated_data.cast_values(key_types).map! do |row|
+              calculated_data.columns.each_with_object({}).with_index do |(col_name, hash), i|
+                hash[col_name] = row[i]
+              end
+            end
+
+            if operation != "count"
+              type = column.try(:type_caster) ||
+                lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value
+              type = type.subtype if Enum::EnumType === type
+            end
 
-          hash_rows.each_with_object({}) do |row, result|
-            key = group_aliases.map { |aliaz| row[aliaz] }
-            key = key.first if key.size == 1
-            key = key_records[key] if associated
+            hash_rows.each_with_object({}) do |row, result|
+              key = group_aliases.map { |aliaz| row[aliaz] }
+              key = key.first if key.size == 1
+              key = key_records[key] if associated
 
-            result[key] = type_cast_calculated_value(row[column_alias], operation, type)
+              result[key] = type_cast_calculated_value(row[column_alias], operation, type)
+            end
           end
         end
       end
@@ -617,12 +632,30 @@ module ActiveRecord
       def select_for_count
         if select_values.present?
           return select_values.first if select_values.one?
-          select_values.join(", ")
+
+          select_values.map do |field|
+            column = arel_column(field.to_s) do |attr_name|
+              Arel.sql(attr_name)
+            end
+
+            if column.is_a?(Arel::Nodes::SqlLiteral)
+              column
+            else
+              "#{adapter_class.quote_table_name(column.relation.name)}.#{adapter_class.quote_column_name(column.name)}"
+            end
+          end.join(", ")
         else
           :all
         end
       end
 
+      def build_count_subquery?(operation, column_name, distinct)
+        # SQLite and older MySQL does not support `COUNT DISTINCT` with `*` or
+        # multiple columns, so we need to use subquery for this.
+        operation == "count" &&
+          (((column_name == :all || select_values.many?) && distinct) || has_limit_or_offset?)
+      end
+
       def build_count_subquery(relation, column_name, distinct)
         if column_name == :all
           column_alias = Arel.star
@@ -632,7 +665,7 @@ module ActiveRecord
           relation.select_values = [ aggregate_column(column_name).as(column_alias) ]
         end
 
-        subquery_alias = Arel.sql("subquery_for_count")
+        subquery_alias = Arel.sql("subquery_for_count", retryable: true)
         select_value = operation_over_aggregate_column(column_alias, "count", false)
 
         relation.build_subquery(subquery_alias, select_value)

data/lib/active_record/relation/delegation.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "mutex_m"
 require "active_support/core_ext/module/delegation"
 
 module ActiveRecord
@@ -67,23 +66,22 @@ module ActiveRecord
     end
 
     class GeneratedRelationMethods < Module # :nodoc:
-      include Mutex_m
+      MUTEX = Mutex.new
 
       def generate_method(method)
-        synchronize do
+        MUTEX.synchronize do
           return if method_defined?(method)
 
-          if /\A[a-zA-Z_]\w*[!?]?\z/.match?(method) && !DELEGATION_RESERVED_METHOD_NAMES.include?(method.to_s)
+          if /\A[a-zA-Z_]\w*[!?]?\z/.match?(method) && !::ActiveSupport::Delegation::RESERVED_METHOD_NAMES.include?(method.to_s)
             module_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{method}(...)
                 scoping { klass.#{method}(...) }
               end
             RUBY
           else
-            define_method(method) do |*args, &block|
-              scoping { klass.public_send(method, *args, &block) }
+            define_method(method) do |*args, **kwargs, &block|
+              scoping { klass.public_send(method, *args, **kwargs, &block) }
             end
-            ruby2_keywords(method)
           end
         end
       end
@@ -102,7 +100,7 @@ module ActiveRecord
              :to_sentence, :to_fs, :to_formatted_s, :as_json,
              :shuffle, :split, :slice, :index, :rindex, to: :records
 
-    delegate :primary_key, :connection, :transaction, to: :klass
+    delegate :primary_key, :lease_connection, :connection, :with_connection, :transaction, to: :klass
 
     module ClassSpecificRelation # :nodoc:
       extend ActiveSupport::Concern
@@ -114,17 +112,16 @@ module ActiveRecord
       end
 
       private
-        def method_missing(method, *args, &block)
+        def method_missing(method, ...)
           if @klass.respond_to?(method)
             unless Delegation.uncacheable_methods.include?(method)
               @klass.generate_relation_method(method)
             end
-            scoping { @klass.public_send(method, *args, &block) }
+            scoping { @klass.public_send(method, ...) }
           else
             super
           end
         end
-        ruby2_keywords(:method_missing)
     end
 
     module ClassMethods # :nodoc: