activerecord 7.2.4 → 8.1.4

data/lib/active_record/relation/delegation.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/module/delegation"
 
 module ActiveRecord
   module Delegation # :nodoc:
@@ -22,6 +21,9 @@ module ActiveRecord
     end
 
     module DelegateCache # :nodoc:
+      @delegate_base_methods = true
+      singleton_class.attr_accessor :delegate_base_methods
+
       def relation_delegate_class(klass)
         @relation_delegate_cache[klass]
       end
@@ -75,12 +77,12 @@ module ActiveRecord
           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}(...) }
+                scoping { model.#{method}(...) }
               end
             RUBY
           else
             define_method(method) do |*args, **kwargs, &block|
-              scoping { klass.public_send(method, *args, **kwargs, &block) }
+              scoping { model.public_send(method, *args, **kwargs, &block) }
             end
           end
         end
@@ -92,15 +94,15 @@ module ActiveRecord
 
     # This module creates compiled delegation methods dynamically at runtime, which makes
     # subsequent calls to that method faster by avoiding method_missing. The delegations
-    # may vary depending on the klass of a relation, so we create a subclass of Relation
-    # for each different klass, and the delegations are compiled into that subclass only.
+    # may vary depending on the model of a relation, so we create a subclass of Relation
+    # for each different model, and the delegations are compiled into that subclass only.
 
     delegate :to_xml, :encode_with, :length, :each, :join, :intersect?,
              :[], :&, :|, :+, :-, :sample, :reverse, :rotate, :compact, :in_groups, :in_groups_of,
              :to_sentence, :to_fs, :to_formatted_s, :as_json,
              :shuffle, :split, :slice, :index, :rindex, to: :records
 
-    delegate :primary_key, :lease_connection, :connection, :with_connection, :transaction, to: :klass
+    delegate :primary_key, :with_connection, :connection, :table_name, :transaction, :sanitize_sql_like, :unscoped, :name, to: :model
 
     module ClassSpecificRelation # :nodoc:
       extend ActiveSupport::Concern
@@ -113,11 +115,19 @@ module ActiveRecord
 
       private
         def method_missing(method, ...)
-          if @klass.respond_to?(method)
-            unless Delegation.uncacheable_methods.include?(method)
-              @klass.generate_relation_method(method)
+          if model.respond_to?(method)
+            if !DelegateCache.delegate_base_methods && Base.respond_to?(method)
+              # A common mistake in Active Record's own code is to call `ActiveRecord::Base`
+              # class methods on Association. It works because it's automatically delegated, but
+              # can introduce subtle bugs because it sets the global scope.
+              # We can't deprecate this behavior because gems might depend on it, however we
+              # can ban it from Active Record's own test suite to avoid regressions.
+              raise NotImplementedError, "Active Record code shouldn't rely on association delegation into ActiveRecord::Base methods"
+            elsif !Delegation.uncacheable_methods.include?(method)
+              model.generate_relation_method(method)
             end
-            scoping { @klass.public_send(method, ...) }
+
+            scoping { model.public_send(method, ...) }
           else
             super
           end
@@ -125,19 +135,19 @@ module ActiveRecord
     end
 
     module ClassMethods # :nodoc:
-      def create(klass, *args, **kwargs)
-        relation_class_for(klass).new(klass, *args, **kwargs)
+      def create(model, ...)
+        relation_class_for(model).new(model, ...)
       end
 
       private
-        def relation_class_for(klass)
-          klass.relation_delegate_class(self)
+        def relation_class_for(model)
+          model.relation_delegate_class(self)
         end
     end
 
     private
       def respond_to_missing?(method, _)
-        super || @klass.respond_to?(method)
+        super || model.respond_to?(method)
       end
   end
 end

data/lib/active_record/relation/finder_methods.rb

@@ -141,14 +141,14 @@ module ActiveRecord
     #
     #   Product.where(["price = %?", price]).sole
     def sole
-      found, undesired = first(2)
+      found, undesired = take(2)
 
       if found.nil?
         raise_record_not_found_exception!
-      elsif undesired.present?
-        raise ActiveRecord::SoleRecordExceeded.new(self)
-      else
+      elsif undesired.nil?
         found
+      else
+        raise ActiveRecord::SoleRecordExceeded.new(self)
       end
     end
 
@@ -376,7 +376,7 @@ module ActiveRecord
 
       skip_query_cache_if_necessary do
         with_connection do |c|
-          c.select_rows(relation.arel, "#{name} Exists?").size == 1
+          c.select_rows(relation.arel, "#{model.name} Exists?").size == 1
         end
       end
     end
@@ -389,7 +389,7 @@ module ActiveRecord
     def include?(record)
       # The existing implementation relies on receiving an Active Record instance as the input parameter named record.
       # Any non-Active Record object passed to this implementation is guaranteed to return `false`.
-      return false unless record.is_a?(klass)
+      return false unless record.is_a?(model)
 
       if loaded? || offset_value || limit_value || having_clause.any?
         records.include?(record)
@@ -415,9 +415,9 @@ module ActiveRecord
     # the expected number of results should be provided in the +expected_size+
     # argument.
     def raise_record_not_found_exception!(ids = nil, result_size = nil, expected_size = nil, key = primary_key, not_found_ids = nil) # :nodoc:
-      conditions = " [#{arel.where_sql(klass)}]" unless where_clause.empty?
+      conditions = " [#{arel.where_sql(model)}]" unless where_clause.empty?
 
-      name = @klass.name
+      name = model.name
 
       if ids.nil?
         error = +"Couldn't find #{name}"
@@ -442,7 +442,7 @@ module ActiveRecord
         if distinct_value && offset_value
           relation = except(:order).limit!(1)
         else
-          relation = except(:select, :distinct, :order)._select!(ONE_AS_ONE).limit!(1)
+          relation = except(:select, :distinct, :order)._select!(Arel.sql(ONE_AS_ONE, retryable: true)).limit!(1)
         end
 
         case conditions
@@ -462,17 +462,17 @@ module ActiveRecord
         relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
 
         if eager_loading && has_limit_or_offset? && !(
-            using_limitable_reflections?(join_dependency.reflections) &&
-            using_limitable_reflections?(
-              construct_join_dependency(
-                select_association_list(joins_values).concat(
-                  select_association_list(left_outer_joins_values)
-                ), nil
-              ).reflections
-            )
+          using_limitable_reflections?(join_dependency.reflections) &&
+          using_limitable_reflections?(
+            construct_join_dependency(
+              select_association_list(joins_values).concat(
+                select_association_list(left_outer_joins_values)
+              ), nil
+            ).reflections
           )
+        )
           relation = skip_query_cache_if_necessary do
-            klass.with_connection do |c|
+            model.with_connection do |c|
               c.distinct_relation_for_primary_key(relation)
             end
           end
@@ -490,21 +490,22 @@ module ActiveRecord
       end
 
       def find_with_ids(*ids)
-        raise UnknownPrimaryKey.new(@klass) if primary_key.nil?
+        raise UnknownPrimaryKey.new(model) if primary_key.nil?
+
+        first_item = ids.first
+        return [] if first_item.is_a?(Array) && first_item.empty?
 
-        expects_array = if klass.composite_primary_key?
-          ids.first.first.is_a?(Array)
+        expects_array = if model.composite_primary_key?
+          first_item.first.is_a?(Array)
         else
-          ids.first.is_a?(Array)
+          first_item.is_a?(Array)
         end
 
-        return [] if expects_array && ids.first.empty?
-
-        ids = ids.first if expects_array
+        ids = first_item if expects_array
 
         ids = ids.compact.uniq
 
-        model_name = @klass.name
+        model_name = model.name
 
         case ids.size
         when 0
@@ -526,7 +527,7 @@ module ActiveRecord
           MSG
         end
 
-        relation = if klass.composite_primary_key?
+        relation = if model.composite_primary_key?
           where(primary_key.zip(id).to_h)
         else
           where(primary_key => id)
@@ -542,10 +543,6 @@ module ActiveRecord
       def find_some(ids)
         return find_some_ordered(ids) unless order_values.present?
 
-        relation = where(primary_key => ids)
-        relation = relation.select(table[primary_key]) unless select_values.empty?
-        result = relation.to_a
-
         expected_size =
           if limit_value && ids.size > limit_value
             limit_value
@@ -554,10 +551,18 @@ module ActiveRecord
           end
 
         # 11 ids with limit 3, offset 9 should give 2 results.
-        if offset_value && (ids.size - offset_value < expected_size)
-          expected_size = ids.size - offset_value
+        if offset_value
+          if ids.size <= offset_value
+            return []
+          elsif ids.size - offset_value < expected_size
+            expected_size = ids.size - offset_value
+          end
         end
 
+        relation = where(primary_key => ids)
+        relation = relation.select(table[primary_key]) unless select_values.empty?
+        result = relation.to_a
+
         if result.size == expected_size
           result
         else
@@ -567,6 +572,7 @@ module ActiveRecord
 
       def find_some_ordered(ids)
         ids = ids.slice(offset_value || 0, limit_value || ids.size) || []
+        return [] if ids.empty?
 
         relation = except(:limit, :offset)
         relation = relation.where(primary_key => ids)
@@ -574,12 +580,20 @@ module ActiveRecord
         result = relation.records
 
         if result.size == ids.size
-          result.in_order_of(:id, ids.map { |id| @klass.type_for_attribute(primary_key).cast(id) })
+          result.in_order_of(:id, ids.map { |id| cast_primary_key(id) })
         else
           raise_record_not_found_exception!(ids, result.size, ids.size)
         end
       end
 
+      def cast_primary_key(id)
+        if model.composite_primary_key?
+          primary_key.zip(id).map! { |attr, value| model.type_for_attribute(attr).cast(value) }
+        else
+          model.type_for_attribute(primary_key).cast(id)
+        end
+      end
+
       def find_take
         if loaded?
           records.first
@@ -639,24 +653,40 @@ module ActiveRecord
       end
 
       def ordered_relation
-        if order_values.empty? && (implicit_order_column || !query_constraints_list.nil? || primary_key)
-          order(_order_columns.map { |column| table[column].asc })
+        if order_values.empty?
+          if !_order_columns.empty?
+            return order(_order_columns.map { |column| table[column].asc })
+          end
+
+          if ActiveRecord.raise_on_missing_required_finder_order_columns
+            raise MissingRequiredOrderError, <<~MSG.squish
+              Relation has no order values, and #{model} has no order columns to use as a default.
+              Set at least one of `implicit_order_column`, `query_constraints` or `primary_key` on
+              the model when no `order `is specified on the relation.
+            MSG
+          else
+            ActiveRecord.deprecator.warn(<<~MSG)
+              Calling order dependent finder methods (e.g. `#first`, `#second`) without `order` values on the relation,
+              and on a model (#{model}) that does not have any order columns (`implicit_order_column`, `query_constraints`,
+              or `primary_key`) to fall back on is deprecated and will raise `ActiveRecord::MissingRequiredOrderError`
+              in Rails 8.2.
+            MSG
+
+            self
+          end
         else
           self
         end
       end
 
       def _order_columns
-        oc = []
+        columns = Array(model.implicit_order_column)
 
-        oc << implicit_order_column if implicit_order_column
-        oc << query_constraints_list if query_constraints_list
+        return columns.compact if columns.length.positive? && columns.last.nil?
 
-        if primary_key && query_constraints_list.nil?
-          oc << primary_key
-        end
+        columns += Array(model.query_constraints_list || model.primary_key)
 
-        oc.flatten.uniq.compact
+        columns.uniq.compact
       end
   end
 end

data/lib/active_record/relation/merger.rb

@@ -24,7 +24,7 @@ module ActiveRecord
       # the values.
       def other
         other = Relation.create(
-          relation.klass,
+          relation.model,
           table: relation.table,
           predicate_builder: relation.predicate_builder
         )
@@ -84,7 +84,7 @@ module ActiveRecord
         def merge_select_values
           return if other.select_values.empty?
 
-          if other.klass == relation.klass
+          if other.model == relation.model
             relation.select_values |= other.select_values
           else
             relation.select_values |= other.instance_eval do
@@ -96,12 +96,12 @@ module ActiveRecord
         def merge_preloads
           return if other.preload_values.empty? && other.includes_values.empty?
 
-          if other.klass == relation.klass
+          if other.model == relation.model
             relation.preload_values |= other.preload_values unless other.preload_values.empty?
             relation.includes_values |= other.includes_values unless other.includes_values.empty?
           else
-            reflection = relation.klass.reflect_on_all_associations.find do |r|
-              r.class_name == other.klass.name
+            reflection = relation.model.reflect_on_all_associations.find do |r|
+              r.class_name == other.model.name
             end || return
 
             unless other.preload_values.empty?
@@ -117,7 +117,7 @@ module ActiveRecord
         def merge_joins
           return if other.joins_values.empty?
 
-          if other.klass == relation.klass
+          if other.model == relation.model
             relation.joins_values |= other.joins_values
           else
             associations, others = other.joins_values.partition do |join|
@@ -136,7 +136,7 @@ module ActiveRecord
         def merge_outer_joins
           return if other.left_outer_joins_values.empty?
 
-          if other.klass == relation.klass
+          if other.model == relation.model
             relation.left_outer_joins_values |= other.left_outer_joins_values
           else
             associations, others = other.left_outer_joins_values.partition do |join|
@@ -161,8 +161,10 @@ module ActiveRecord
             relation.order!(*other.order_values)
           end
 
-          extensions = other.extensions - relation.extensions
-          relation.extending!(*extensions) if extensions.any?
+          unless other.extensions.empty?
+            extensions = other.extensions - relation.extensions
+            relation.extending!(*extensions) if extensions.any?
+          end
         end
 
         def merge_single_values
@@ -185,7 +187,7 @@ module ActiveRecord
 
         def replace_from_clause?
           relation.from_clause.empty? && !other.from_clause.empty? &&
-            relation.klass.base_class == other.klass.base_class
+            relation.model.base_class == other.model.base_class
         end
     end
   end

data/lib/active_record/relation/predicate_builder/array_handler.rb

@@ -31,7 +31,9 @@ module ActiveRecord
           values_predicate
         else
           array_predicates = ranges.map! { |range| predicate_builder.build(attribute, range) }
-          array_predicates.inject(values_predicate, &:or)
+          values_predicate.or(
+            Arel::Nodes::Grouping.new Arel::Nodes::Or.new(array_predicates)
+          )
         end
       end
 

data/lib/active_record/relation/predicate_builder/association_query_value.rb

@@ -3,24 +3,24 @@
 module ActiveRecord
   class PredicateBuilder
     class AssociationQueryValue # :nodoc:
-      def initialize(associated_table, value)
-        @associated_table = associated_table
+      def initialize(reflection, value)
+        @reflection = reflection
         @value = value
       end
 
       def queries
-        if associated_table.join_foreign_key.is_a?(Array)
+        if reflection.join_foreign_key.is_a?(Array)
           id_list = ids
           id_list = id_list.pluck(primary_key) if id_list.is_a?(Relation)
 
-          id_list.map { |ids_set| associated_table.join_foreign_key.zip(ids_set).to_h }
+          id_list.map { |ids_set| reflection.join_foreign_key.zip(ids_set).to_h }
         else
-          [ associated_table.join_foreign_key => ids ]
+          [ reflection.join_foreign_key => ids ]
         end
       end
 
       private
-        attr_reader :associated_table, :value
+        attr_reader :reflection, :value
 
         def ids
           case value
@@ -37,15 +37,15 @@ module ActiveRecord
         end
 
         def primary_key
-          associated_table.join_primary_key
+          reflection.join_primary_key
         end
 
         def primary_type
-          associated_table.join_primary_type
+          reflection.join_primary_type
         end
 
         def polymorphic_name
-          associated_table.polymorphic_name_association
+          reflection.polymorphic_name
         end
 
         def select_clause?

data/lib/active_record/relation/predicate_builder/polymorphic_array_value.rb

@@ -3,24 +3,24 @@
 module ActiveRecord
   class PredicateBuilder
     class PolymorphicArrayValue # :nodoc:
-      def initialize(associated_table, values)
-        @associated_table = associated_table
+      def initialize(reflection, values)
+        @reflection = reflection
         @values = values
       end
 
       def queries
-        return [ associated_table.join_foreign_key => values ] if values.empty?
+        return [ reflection.join_foreign_key => values ] if values.empty?
 
         type_to_ids_mapping.map do |type, ids|
           query = {}
-          query[associated_table.join_foreign_type] = type if type
-          query[associated_table.join_foreign_key] = ids
+          query[reflection.join_foreign_type] = type if type
+          query[reflection.join_foreign_key] = ids
           query
         end
       end
 
       private
-        attr_reader :associated_table, :values
+        attr_reader :reflection, :values
 
         def type_to_ids_mapping
           default_hash = Hash.new { |hsh, key| hsh[key] = [] }
@@ -30,14 +30,14 @@ module ActiveRecord
         end
 
         def primary_key(value)
-          associated_table.join_primary_key(klass(value))
+          reflection.join_primary_key(klass(value))
         end
 
         def klass(value)
           if value.is_a?(Base)
             value.class
           elsif value.is_a?(Relation)
-            value.klass
+            value.model
           end
         end
 

data/lib/active_record/relation/predicate_builder/relation_handler.rb

@@ -9,10 +9,11 @@ module ActiveRecord
         end
 
         if value.select_values.empty?
-          if value.klass.composite_primary_key?
-            raise ArgumentError, "Cannot map composite primary key #{value.klass.primary_key} to #{attribute.name}"
+          model = value.model
+          if model.composite_primary_key?
+            raise ArgumentError, "Cannot map composite primary key #{model.primary_key} to #{attribute.name}"
           else
-            value = value.select(value.table[value.klass.primary_key])
+            value = value.select(value.table[model.primary_key])
           end
         end
 

data/lib/active_record/relation/predicate_builder.rb

@@ -37,7 +37,7 @@ module ActiveRecord
 
     # Define how a class is converted to Arel nodes when passed to +where+.
     # The handler can be any object that responds to +call+, and will be used
-    # for any value that +===+ the class given. For example:
+    # for any value that <tt>===</tt> the class given. For example:
     #
     #     MyCustomDateRange = Struct.new(:start, :end)
     #     handler = proc do |column, range|
@@ -72,38 +72,53 @@ module ActiveRecord
       table.associated_table(table_name, &block).arel_table[column_name]
     end
 
+    def with(table)
+      other = dup
+      other.table = table
+      other
+    end
+
     protected
+      attr_writer :table
+
       def expand_from_hash(attributes, &block)
-        return ["1=0"] if attributes.empty?
+        return [Arel.sql("1=0", retryable: true)] if attributes.empty?
 
         attributes.flat_map do |key, value|
+          if key.is_a?(Array) && key.size == 1
+            key = key.first
+            value = value.flatten
+          end
+
           if key.is_a?(Array)
             queries = Array(value).map do |ids_set|
               raise ArgumentError, "Expected corresponding value for #{key} to be an Array" unless ids_set.is_a?(Array)
-              expand_from_hash(key.zip(ids_set).to_h)
+              expand_from_hash(convert_dot_notation_to_hash(key.zip(ids_set).to_h))
             end
             grouping_queries(queries)
           elsif value.is_a?(Hash) && !table.has_column?(key)
             table.associated_table(key, &block)
               .predicate_builder.expand_from_hash(value.stringify_keys)
-          elsif table.associated_with?(key)
+          elsif (associated_reflection = table.associated_with(key))
             # Find the foreign key when using queries such as:
             # Post.where(author: author)
             #
             # For polymorphic relationships, find the foreign key and type:
             # PriceEstimate.where(estimate_of: treasure)
-            associated_table = table.associated_table(key)
-            if associated_table.polymorphic_association?
+
+            if associated_reflection.polymorphic?
               value = [value] unless value.is_a?(Array)
               klass = PolymorphicArrayValue
-            elsif associated_table.through_association?
+            elsif associated_reflection.through_reflection?
+              associated_table = table.associated_table(key)
+
               next associated_table.predicate_builder.expand_from_hash(
                 associated_table.primary_key => value
               )
             end
 
             klass ||= AssociationQueryValue
-            queries = klass.new(associated_table, value).queries.map! do |query|
+            queries = klass.new(associated_reflection, value).queries.map! do |query|
               # If the query produced is identical to attributes don't go any deeper.
               # Prevents stack level too deep errors when association and foreign_key are identical.
               query == attributes ? self[key, value] : expand_from_hash(query)

data/lib/active_record/relation/query_attribute.rb

@@ -15,7 +15,9 @@ module ActiveRecord
         elsif @type.serialized?
           value_for_database
         elsif @type.mutable? # If the type is simply mutable, we deep_dup it.
-          @value_before_type_cast = @value_before_type_cast.deep_dup
+          unless @value_before_type_cast.frozen?
+            @value_before_type_cast = @value_before_type_cast.deep_dup
+          end
         end
       end