activerecord 7.1.5.2 → 8.1.2.1

data/lib/active_record/relation/finder_methods.rb

@@ -24,22 +24,22 @@ module ActiveRecord
     #   TravelRoute.primary_key = [:origin, :destination]
     #
     #   TravelRoute.find(["Ottawa", "London"])
-    #   => #<TravelRoute origin: "Ottawa", destination: "London">
+    #   # => #<TravelRoute origin: "Ottawa", destination: "London">
     #
     #   TravelRoute.find([["Paris", "Montreal"]])
-    #   => [#<TravelRoute origin: "Paris", destination: "Montreal">]
+    #   # => [#<TravelRoute origin: "Paris", destination: "Montreal">]
     #
     #   TravelRoute.find(["New York", "Las Vegas"], ["New York", "Portland"])
-    #   => [
-    #        #<TravelRoute origin: "New York", destination: "Las Vegas">,
-    #        #<TravelRoute origin: "New York", destination: "Portland">
-    #      ]
+    #   # => [
+    #   #      #<TravelRoute origin: "New York", destination: "Las Vegas">,
+    #   #      #<TravelRoute origin: "New York", destination: "Portland">
+    #   #    ]
     #
     #   TravelRoute.find([["Berlin", "London"], ["Barcelona", "Lisbon"]])
-    #   => [
-    #        #<TravelRoute origin: "Berlin", destination: "London">,
-    #        #<TravelRoute origin: "Barcelona", destination: "Lisbon">
-    #      ]
+    #   # => [
+    #   #      #<TravelRoute origin: "Berlin", destination: "London">,
+    #   #      #<TravelRoute origin: "Barcelona", destination: "Lisbon">
+    #   #    ]
     #
     # NOTE: The returned records are in the same order as the ids you provide.
     # If you want the results to be sorted by database, you can use ActiveRecord::QueryMethods#where
@@ -87,6 +87,14 @@ module ActiveRecord
     #
     #   Person.where(name: 'Spartacus', rating: 4).pluck(:field1, :field2)
     #   # returns an Array of the required fields.
+    #
+    # ==== Edge Cases
+    #
+    #   Person.find(37)          # raises ActiveRecord::RecordNotFound exception if the record with the given ID does not exist.
+    #   Person.find([37])        # raises ActiveRecord::RecordNotFound exception if the record with the given ID in the input array does not exist.
+    #   Person.find(nil)         # raises ActiveRecord::RecordNotFound exception if the argument is nil.
+    #   Person.find([])          # returns an empty array if the argument is an empty array.
+    #   Person.find              # raises ActiveRecord::RecordNotFound exception if the argument is not provided.
     def find(*args)
       return super if block_given?
       find_with_ids(*args)
@@ -133,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
 
@@ -366,7 +374,11 @@ module ActiveRecord
       relation = construct_relation_for_exists(conditions)
       return false if relation.where_clause.contradiction?
 
-      skip_query_cache_if_necessary { connection.select_rows(relation.arel, "#{name} Exists?").size == 1 }
+      skip_query_cache_if_necessary do
+        with_connection do |c|
+          c.select_rows(relation.arel, "#{model.name} Exists?").size == 1
+        end
+      end
     end
 
     # Returns true if the relation contains the given record or false otherwise.
@@ -377,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)
@@ -403,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}"
@@ -430,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
@@ -460,7 +472,9 @@ module ActiveRecord
             )
           )
           relation = skip_query_cache_if_necessary do
-            klass.connection.distinct_relation_for_primary_key(relation)
+            model.with_connection do |c|
+              c.distinct_relation_for_primary_key(relation)
+            end
           end
         end
 
@@ -476,9 +490,9 @@ module ActiveRecord
       end
 
       def find_with_ids(*ids)
-        raise UnknownPrimaryKey.new(@klass) if primary_key.nil?
+        raise UnknownPrimaryKey.new(model) if primary_key.nil?
 
-        expects_array = if klass.composite_primary_key?
+        expects_array = if model.composite_primary_key?
           ids.first.first.is_a?(Array)
         else
           ids.first.is_a?(Array)
@@ -490,7 +504,7 @@ module ActiveRecord
 
         ids = ids.compact.uniq
 
-        model_name = @klass.name
+        model_name = model.name
 
         case ids.size
         when 0
@@ -512,7 +526,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)
@@ -560,7 +574,7 @@ 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| model.type_for_attribute(primary_key).cast(id) })
         else
           raise_record_not_found_exception!(ids, result.size, ids.size)
         end
@@ -625,24 +639,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

@@ -7,16 +7,15 @@ module ActiveRecord
     class HashMerger # :nodoc:
       attr_reader :relation, :hash
 
-      def initialize(relation, hash, rewhere = nil)
+      def initialize(relation, hash)
         hash.assert_valid_keys(*Relation::VALUE_METHODS)
 
         @relation = relation
         @hash     = hash
-        @rewhere  = rewhere
       end
 
       def merge
-        Merger.new(relation, other, @rewhere).merge
+        Merger.new(relation, other).merge
       end
 
       # Applying values to a relation has some side effects. E.g.
@@ -25,7 +24,7 @@ module ActiveRecord
       # the values.
       def other
         other = Relation.create(
-          relation.klass,
+          relation.model,
           table: relation.table,
           predicate_builder: relation.predicate_builder
         )
@@ -44,11 +43,10 @@ module ActiveRecord
     class Merger # :nodoc:
       attr_reader :relation, :values, :other
 
-      def initialize(relation, other, rewhere = nil)
+      def initialize(relation, other)
         @relation = relation
         @values   = other.values
         @other    = other
-        @rewhere  = rewhere
       end
 
       NORMAL_VALUES = Relation::VALUE_METHODS - Relation::CLAUSE_METHODS -
@@ -86,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
@@ -98,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?
@@ -119,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|
@@ -138,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|
@@ -178,7 +176,7 @@ module ActiveRecord
         def merge_clauses
           relation.from_clause = other.from_clause if replace_from_clause?
 
-          where_clause = relation.where_clause.merge(other.where_clause, @rewhere)
+          where_clause = relation.where_clause.merge(other.where_clause)
           relation.where_clause = where_clause unless where_clause.empty?
 
           having_clause = relation.having_clause.merge(other.having_clause)
@@ -187,7 +185,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

@@ -13,7 +13,7 @@ module ActiveRecord
         return attribute.in([]) if value.empty?
 
         values = value.map { |x| x.is_a?(Base) ? x.id : x }
-        nils = values.extract!(&:nil?)
+        nils = values.compact!
         ranges = values.extract! { |v| v.is_a?(Range) }
 
         values_predicate =
@@ -23,7 +23,7 @@ module ActiveRecord
           else Arel::Nodes::HomogeneousIn.new(values, attribute, :in)
           end
 
-        unless nils.empty?
+        if nils
           values_predicate = values_predicate.or(attribute.eq(nil))
         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?
@@ -57,9 +57,17 @@ module ActiveRecord
         end
 
         def convert_to_id(value)
-          return primary_key.map { |pk| value.public_send(pk) } if primary_key.is_a?(Array)
+          if primary_key.is_a?(Array)
+            primary_key.map do |attribute|
+              next nil if value.nil?
 
-          if value.respond_to?(primary_key)
+              if attribute == "id"
+                value.id_value
+              else
+                value.public_send(attribute)
+              end
+            end
+          elsif value.respond_to?(primary_key)
             value.public_send(primary_key)
           else
             value

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

@@ -28,16 +28,16 @@ module ActiveRecord
     def self.references(attributes)
       attributes.each_with_object([]) do |(key, value), result|
         if value.is_a?(Hash)
-          result << Arel.sql(key)
+          result << Arel.sql(key, retryable: true)
         elsif (idx = key.rindex("."))
-          result << Arel.sql(key[0, idx])
+          result << Arel.sql(key[0, idx], retryable: true)
         end
       end
     end
 
     # 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,11 +72,24 @@ 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)
@@ -86,24 +99,26 @@ module ActiveRecord
           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)
@@ -142,7 +157,7 @@ module ActiveRecord
           queries.first
         else
           queries.map! { |query| query.reduce(&:and) }
-          queries = queries.reduce { |result, query| Arel::Nodes::Or.new(result, query) }
+          queries = Arel::Nodes::Or.new(queries)
           Arel::Nodes::Grouping.new(queries)
         end
       end

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
 
@@ -35,7 +37,7 @@ module ActiveRecord
       def nil?
         unless value_before_type_cast.is_a?(StatementCache::Substitute)
           value_before_type_cast.nil? ||
-            type.respond_to?(:subtype) && serializable? && value_for_database.nil?
+            (type.respond_to?(:subtype) || type.respond_to?(:normalizer)) && serializable? && value_for_database.nil?
         end
       end