activerecord 6.0.0 → 7.2.3

data/lib/active_record/relation/record_fetch_warning.rb

@@ -3,6 +3,9 @@
 module ActiveRecord
   class Relation
     module RecordFetchWarning
+      # Deprecated: subscribe to sql.active_record notifications and
+      # access the row count field to detect large result set sizes.
+      #
       # When this module is prepended to ActiveRecord::Relation and
       # +config.active_record.warn_on_records_fetched_greater_than+ is
       # set to an integer, if the number of records a query returns is
@@ -16,10 +19,10 @@ module ActiveRecord
       def exec_queries
         QueryRegistry.reset
 
-        super.tap do
-          if logger && warn_on_records_fetched_greater_than
-            if @records.length > warn_on_records_fetched_greater_than
-              logger.warn "Query fetched #{@records.size} #{@klass} records: #{QueryRegistry.queries.join(";")}"
+        super.tap do |records|
+          if logger && ActiveRecord.warn_on_records_fetched_greater_than
+            if records.length > ActiveRecord.warn_on_records_fetched_greater_than
+              logger.warn "Query fetched #{records.size} #{@klass} records: #{QueryRegistry.queries.join(";")}"
             end
           end
         end
@@ -31,17 +34,15 @@ module ActiveRecord
       end
       # :startdoc:
 
-      class QueryRegistry # :nodoc:
-        extend ActiveSupport::PerThreadRegistry
-
-        attr_reader :queries
+      module QueryRegistry # :nodoc:
+        extend self
 
-        def initialize
-          @queries = []
+        def queries
+          ActiveSupport::IsolatedExecutionState[:active_record_query_registry] ||= []
         end
 
         def reset
-          @queries.clear
+          queries.clear
         end
       end
     end

data/lib/active_record/relation/spawn_methods.rb

@@ -6,9 +6,8 @@ require "active_record/relation/merger"
 
 module ActiveRecord
   module SpawnMethods
-    # This is overridden by Associations::CollectionProxy
-    def spawn #:nodoc:
-      already_in_scope? ? klass.all : clone
+    def spawn # :nodoc:
+      already_in_scope?(klass.scope_registry) ? klass.all : clone
     end
 
     # Merges in the conditions from <tt>other</tt>, if <tt>other</tt> is an ActiveRecord::Relation.
@@ -28,17 +27,20 @@ module ActiveRecord
     #   # => Post.where(published: true).joins(:comments)
     #
     # This is mainly intended for sharing common conditions between multiple associations.
-    def merge(other)
+    #
+    # For conditions that exist in both relations, those from <tt>other</tt> will take precedence.
+    # To find the intersection of two relations, use QueryMethods#and.
+    def merge(other, *rest)
       if other.is_a?(Array)
         records & other
       elsif other
-        spawn.merge!(other)
+        spawn.merge!(other, *rest)
       else
         raise ArgumentError, "invalid argument: #{other.inspect}."
       end
     end
 
-    def merge!(other) # :nodoc:
+    def merge!(other, *rest) # :nodoc:
       if other.is_a?(Hash)
         Relation::HashMerger.new(self, other).merge
       elsif other.is_a?(Relation)
@@ -67,10 +69,9 @@ module ActiveRecord
     end
 
     private
-
       def relation_with(values)
-        result = Relation.create(klass, values: values)
-        result.extend(*extending_values) if extending_values.any?
+        result = spawn
+        result.instance_variable_set(:@values, values)
         result
       end
   end

data/lib/active_record/relation/where_clause.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/array/extract"
+
 module ActiveRecord
   class Relation
     class WhereClause # :nodoc:
@@ -10,21 +12,21 @@ module ActiveRecord
       end
 
       def +(other)
-        WhereClause.new(
-          predicates + other.predicates,
-        )
+        WhereClause.new(predicates + other.predicates)
       end
 
       def -(other)
-        WhereClause.new(
-          predicates - other.predicates,
-        )
+        WhereClause.new(predicates - other.predicates)
+      end
+
+      def |(other)
+        WhereClause.new(predicates | other.predicates)
       end
 
       def merge(other)
-        WhereClause.new(
-          predicates_unreferenced_by(other) + other.predicates,
-        )
+        predicates = except_predicates(other.extract_attributes)
+
+        WhereClause.new(predicates | other.predicates)
       end
 
       def except(*columns)
@@ -39,42 +41,50 @@ module ActiveRecord
         if left.empty? || right.empty?
           common
         else
-          or_clause = WhereClause.new(
-            [left.ast.or(right.ast)],
-          )
-          common + or_clause
-        end
-      end
+          left = left.ast
+          left = left.expr if left.is_a?(Arel::Nodes::Grouping)
 
-      def to_h(table_name = nil)
-        equalities = equalities(predicates)
-        if table_name
-          equalities = equalities.select do |node|
-            node.left.relation.name == table_name
+          right = right.ast
+          right = right.expr if right.is_a?(Arel::Nodes::Grouping)
+
+          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
         end
+      end
 
-        equalities.map { |node|
+      def to_h(table_name = nil, equality_only: false)
+        equalities(predicates, equality_only).each_with_object({}) do |node, hash|
+          next if table_name&.!= node.left.relation.name
           name = node.left.name.to_s
           value = extract_node_value(node.right)
-          [name, value]
-        }.to_h
+          hash[name] = value
+        end
       end
 
       def ast
-        Arel::Nodes::And.new(predicates_with_wrapped_sql_literals)
+        predicates = predicates_with_wrapped_sql_literals
+        predicates.one? ? predicates.first : Arel::Nodes::And.new(predicates)
       end
 
       def ==(other)
         other.is_a?(WhereClause) &&
           predicates == other.predicates
       end
+      alias :eql? :==
 
-      def invert(as = :nand)
+      def hash
+        [self.class, predicates].hash
+      end
+
+      def invert
         if predicates.size == 1
           inverted_predicates = [ invert_predicate(predicates.first) ]
-        elsif as == :nor
-          inverted_predicates = predicates.map { |node| invert_predicate(node) }
         else
           inverted_predicates = [ Arel::Nodes::Not.new(ast) ]
         end
@@ -83,68 +93,100 @@ module ActiveRecord
       end
 
       def self.empty
-        @empty ||= new([])
+        @empty ||= new([]).freeze
       end
 
-      protected
+      def contradiction?
+        predicates.any? do |x|
+          case x
+          when Arel::Nodes::In
+            Array === x.right && x.right.empty?
+          when Arel::Nodes::Equality
+            x.right.respond_to?(:unboundable?) && x.right.unboundable?
+          end
+        end
+      end
 
+      def extract_attributes
+        attrs = []
+        each_attributes { |attr, _| attrs << attr }
+        attrs
+      end
+
+      protected
         attr_reader :predicates
 
         def referenced_columns
-          @referenced_columns ||= begin
-            equality_nodes = predicates.select { |n| equality_node?(n) }
-            Set.new(equality_nodes, &:left)
-          end
+          hash = {}
+          each_attributes { |attr, node| hash[attr] = node }
+          hash
         end
 
       private
-        def equalities(predicates)
+        def each_attributes
+          predicates.each do |node|
+            attr = extract_attribute(node) || begin
+              node.left if equality_node?(node) && node.left.is_a?(Arel::Predications)
+            end
+
+            yield attr, node if attr
+          end
+        end
+
+        def extract_attribute(node)
+          attr_node = nil
+
+          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
+
+        def equalities(predicates, equality_only)
           equalities = []
 
           predicates.each do |node|
-            case node
-            when Arel::Nodes::Equality
+            if equality_only ? Arel::Nodes::Equality === node : equality_node?(node)
               equalities << node
-            when Arel::Nodes::And
-              equalities.concat equalities(node.children)
+            elsif node.is_a?(Arel::Nodes::And)
+              equalities.concat equalities(node.children, equality_only)
             end
           end
 
           equalities
         end
 
-        def predicates_unreferenced_by(other)
-          predicates.reject do |n|
-            equality_node?(n) && other.referenced_columns.include?(n.left)
-          end
-        end
-
         def equality_node?(node)
-          node.respond_to?(:operator) && node.operator == :==
+          !node.is_a?(String) && node.equality?
         end
 
         def invert_predicate(node)
           case node
           when NilClass
             raise ArgumentError, "Invalid argument for .where.not(), got nil."
-          when Arel::Nodes::In
-            Arel::Nodes::NotIn.new(node.left, node.right)
-          when Arel::Nodes::IsNotDistinctFrom
-            Arel::Nodes::IsDistinctFrom.new(node.left, node.right)
-          when Arel::Nodes::IsDistinctFrom
-            Arel::Nodes::IsNotDistinctFrom.new(node.left, node.right)
-          when Arel::Nodes::Equality
-            Arel::Nodes::NotEqual.new(node.left, node.right)
           when String
             Arel::Nodes::Not.new(Arel::Nodes::SqlLiteral.new(node))
           else
-            Arel::Nodes::Not.new(node)
+            node.invert
           end
         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|
-            Arel.fetch_attribute(node) { |attr| columns.include?(attr.name.to_s) }
+            if !non_attrs.empty? && node.equality? && 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)
+            end
           end
         end
 
@@ -171,18 +213,10 @@ module ActiveRecord
         end
 
         def extract_node_value(node)
-          case node
-          when Array
+          if node.respond_to?(:value_before_type_cast)
+            node.value_before_type_cast
+          elsif Array === node
             node.map { |v| extract_node_value(v) }
-          when Arel::Nodes::Casted, Arel::Nodes::Quoted
-            node.val
-          when Arel::Nodes::BindParam
-            value = node.value
-            if value.respond_to?(:value_before_type_cast)
-              value.value_before_type_cast
-            else
-              value
-            end
           end
         end
     end