activerecord 7.1.5.2 → 8.1.2.1

data/lib/active_record/relation/spawn_methods.rb

@@ -7,7 +7,7 @@ require "active_record/relation/merger"
 module ActiveRecord
   module SpawnMethods
     def spawn # :nodoc:
-      already_in_scope?(klass.scope_registry) ? klass.all : clone
+      already_in_scope?(model.scope_registry) ? model.all : clone
     end
 
     # Merges in the conditions from <tt>other</tt>, if <tt>other</tt> is an ActiveRecord::Relation.
@@ -41,26 +41,10 @@ module ActiveRecord
     end
 
     def merge!(other, *rest) # :nodoc:
-      options = rest.extract_options!
-
-      if options.key?(:rewhere)
-        if options[:rewhere]
-          ActiveRecord.deprecator.warn(<<-MSG.squish)
-            Specifying `Relation#merge(rewhere: true)` is deprecated, as that has now been
-            the default since Rails 7.0. Setting the rewhere option will error in Rails 7.2
-          MSG
-        else
-          ActiveRecord.deprecator.warn(<<-MSG.squish)
-            `Relation#merge(rewhere: false)` is deprecated without replacement,
-            and will be removed in Rails 7.2
-          MSG
-        end
-      end
-
       if other.is_a?(Hash)
-        Relation::HashMerger.new(self, other, options[:rewhere]).merge
+        Relation::HashMerger.new(self, other).merge
       elsif other.is_a?(Relation)
-        Relation::Merger.new(self, other, options[:rewhere]).merge
+        Relation::Merger.new(self, other).merge
       elsif other.respond_to?(:to_proc)
         instance_exec(&other)
       else
@@ -68,18 +52,18 @@ module ActiveRecord
       end
     end
 
-    # Removes from the query the condition(s) specified in +skips+.
+    # Removes the condition(s) specified in +skips+ from the query.
     #
-    #   Post.order('id asc').except(:order)                  # discards the order condition
-    #   Post.where('id > 10').order('id asc').except(:where) # discards the where condition but keeps the order
+    #   Post.order('id asc').except(:order)                  # removes the order condition
+    #   Post.where('id > 10').order('id asc').except(:where) # removes the where condition but keeps the order
     def except(*skips)
       relation_with values.except(*skips)
     end
 
-    # Removes any condition from the query other than the one(s) specified in +onlies+.
+    # Keeps only the condition(s) specified in +onlies+ in the query, removing all others.
     #
-    #   Post.order('id asc').only(:where)         # discards the order condition
-    #   Post.order('id asc').only(:where, :order) # uses the specified order
+    #   Post.order('id asc').only(:where)         # keeps only the where condition, removes the order
+    #   Post.order('id asc').only(:where, :order) # keeps only the where and order conditions
     def only(*onlies)
       relation_with values.slice(*onlies)
     end

data/lib/active_record/relation/where_clause.rb

@@ -23,12 +23,8 @@ module ActiveRecord
         WhereClause.new(predicates | other.predicates)
       end
 
-      def merge(other, rewhere = nil)
-        predicates = if rewhere
-          except_predicates(other.extract_attributes)
-        else
-          predicates_unreferenced_by(other)
-        end
+      def merge(other)
+        predicates = except_predicates(other.extract_attributes)
 
         WhereClause.new(predicates | other.predicates)
       end
@@ -51,7 +47,11 @@ module ActiveRecord
           right = right.ast
           right = right.expr if right.is_a?(Arel::Nodes::Grouping)
 
-          or_clause = Arel::Nodes::Or.new(left, right)
+          or_clause = if left.is_a?(Arel::Nodes::Or)
+            Arel::Nodes::Or.new(left.children + [right])
+          else
+            Arel::Nodes::Or.new([left, right])
+          end
 
           common.predicates << Arel::Nodes::Grouping.new(or_clause)
           common
@@ -135,10 +135,14 @@ module ActiveRecord
 
         def extract_attribute(node)
           attr_node = nil
-          Arel.fetch_attribute(node) do |attr|
-            return if attr_node&.!= attr # all attr nodes should be the same
+
+          valid_attrs = Arel.fetch_attribute(node) do |attr|
+            !attr_node || attr_node == attr # all attr nodes should be the same
+          ensure
             attr_node = attr
           end
+          return unless valid_attrs # all nested nodes should yield an attribute
+
           attr_node
         end
 
@@ -156,18 +160,6 @@ module ActiveRecord
           equalities
         end
 
-        def predicates_unreferenced_by(other)
-          referenced_columns = other.referenced_columns
-
-          predicates.reject do |node|
-            attr = extract_attribute(node) || begin
-              node.left if equality_node?(node) && node.left.is_a?(Arel::Predications)
-            end
-
-            attr && referenced_columns[attr]
-          end
-        end
-
         def equality_node?(node)
           !node.is_a?(String) && node.equality?
         end
@@ -184,11 +176,13 @@ module ActiveRecord
         end
 
         def except_predicates(columns)
+          return predicates if columns.empty?
+
           attrs = columns.extract! { |node| node.is_a?(Arel::Attribute) }
           non_attrs = columns.extract! { |node| node.is_a?(Arel::Predications) }
 
           predicates.reject do |node|
-            if !non_attrs.empty? && node.equality? && node.left.is_a?(Arel::Predications)
+            if !non_attrs.empty? && equality_node?(node) && node.left.is_a?(Arel::Predications)
               non_attrs.include?(node.left)
             end || Arel.fetch_attribute(node) do |attr|
               attrs.include?(attr) || columns.include?(attr.name.to_s)
@@ -200,7 +194,7 @@ module ActiveRecord
           non_empty_predicates.map do |node|
             case node
             when Arel::Nodes::SqlLiteral, ::String
-              wrap_sql_literal(node)
+              Arel::Nodes::Grouping.new(node)
             else node
             end
           end
@@ -211,13 +205,6 @@ module ActiveRecord
           predicates - ARRAY_WITH_EMPTY_STRING
         end
 
-        def wrap_sql_literal(node)
-          if ::String === node
-            node = Arel.sql(node)
-          end
-          Arel::Nodes::Grouping.new(node)
-        end
-
         def extract_node_value(node)
           if node.respond_to?(:value_before_type_cast)
             node.value_before_type_cast