omg-activerecord 8.0.0.alpha1

data/lib/active_record/relation/record_fetch_warning.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+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
+      # greater than the value of +warn_on_records_fetched_greater_than+,
+      # a warning is logged. This allows for the detection of queries that
+      # return a large number of records, which could cause memory bloat.
+      #
+      # In most cases, fetching large number of records can be performed
+      # efficiently using the ActiveRecord::Batches methods.
+      # See ActiveRecord::Batches for more information.
+      def exec_queries
+        QueryRegistry.reset
+
+        super.tap do |records|
+          if model.logger && ActiveRecord.warn_on_records_fetched_greater_than
+            if records.length > ActiveRecord.warn_on_records_fetched_greater_than
+              model.logger.warn "Query fetched #{records.size} #{@klass} records: #{QueryRegistry.queries.join(";")}"
+            end
+          end
+        end
+      end
+
+      # :stopdoc:
+      ActiveSupport::Notifications.subscribe("sql.active_record") do |*, payload|
+        QueryRegistry.queries << payload[:sql]
+      end
+      # :startdoc:
+
+      module QueryRegistry # :nodoc:
+        extend self
+
+        def queries
+          ActiveSupport::IsolatedExecutionState[:active_record_query_registry] ||= []
+        end
+
+        def reset
+          queries.clear
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.prepend ActiveRecord::Relation::RecordFetchWarning

data/lib/active_record/relation/spawn_methods.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/except"
+require "active_support/core_ext/hash/slice"
+require "active_record/relation/merger"
+
+module ActiveRecord
+  module SpawnMethods
+    def spawn # :nodoc:
+      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.
+    # Returns an array representing the intersection of the resulting records with <tt>other</tt>, if <tt>other</tt> is an array.
+    #
+    #   Post.where(published: true).joins(:comments).merge( Comment.where(spam: false) )
+    #   # Performs a single join query with both where conditions.
+    #
+    #   recent_posts = Post.order('created_at DESC').first(5)
+    #   Post.where(published: true).merge(recent_posts)
+    #   # Returns the intersection of all published posts with the 5 most recently created posts.
+    #   # (This is just an example. You'd probably want to do this with a single query!)
+    #
+    # Procs will be evaluated by merge:
+    #
+    #   Post.where(published: true).merge(-> { joins(:comments) })
+    #   # => Post.where(published: true).joins(:comments)
+    #
+    # This is mainly intended for sharing common conditions between multiple associations.
+    #
+    # 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, *rest)
+      else
+        raise ArgumentError, "invalid argument: #{other.inspect}."
+      end
+    end
+
+    def merge!(other, *rest) # :nodoc:
+      if other.is_a?(Hash)
+        Relation::HashMerger.new(self, other).merge
+      elsif other.is_a?(Relation)
+        Relation::Merger.new(self, other).merge
+      elsif other.respond_to?(:to_proc)
+        instance_exec(&other)
+      else
+        raise ArgumentError, "#{other.inspect} is not an ActiveRecord::Relation"
+      end
+    end
+
+    # Removes from the query the condition(s) specified in +skips+.
+    #
+    #   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
+    def except(*skips)
+      relation_with values.except(*skips)
+    end
+
+    # Removes any condition from the query other than the one(s) specified in +onlies+.
+    #
+    #   Post.order('id asc').only(:where)         # discards the order condition
+    #   Post.order('id asc').only(:where, :order) # uses the specified order
+    def only(*onlies)
+      relation_with values.slice(*onlies)
+    end
+
+    private
+      def relation_with(values)
+        result = spawn
+        result.instance_variable_set(:@values, values)
+        result
+      end
+  end
+end

data/lib/active_record/relation/where_clause.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/array/extract"
+
+module ActiveRecord
+  class Relation
+    class WhereClause # :nodoc:
+      delegate :any?, :empty?, to: :predicates
+
+      def initialize(predicates)
+        @predicates = predicates
+      end
+
+      def +(other)
+        WhereClause.new(predicates + other.predicates)
+      end
+
+      def -(other)
+        WhereClause.new(predicates - other.predicates)
+      end
+
+      def |(other)
+        WhereClause.new(predicates | other.predicates)
+      end
+
+      def merge(other)
+        predicates = except_predicates(other.extract_attributes)
+
+        WhereClause.new(predicates | other.predicates)
+      end
+
+      def except(*columns)
+        WhereClause.new(except_predicates(columns))
+      end
+
+      def or(other)
+        left = self - other
+        common = self - left
+        right = other - common
+
+        if left.empty? || right.empty?
+          common
+        else
+          left = left.ast
+          left = left.expr if left.is_a?(Arel::Nodes::Grouping)
+
+          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
+
+      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)
+          hash[name] = value
+        end
+      end
+
+      def ast
+        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 hash
+        [self.class, predicates].hash
+      end
+
+      def invert
+        if predicates.size == 1
+          inverted_predicates = [ invert_predicate(predicates.first) ]
+        else
+          inverted_predicates = [ Arel::Nodes::Not.new(ast) ]
+        end
+
+        WhereClause.new(inverted_predicates)
+      end
+
+      def self.empty
+        @empty ||= new([]).freeze
+      end
+
+      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
+          hash = {}
+          each_attributes { |attr, node| hash[attr] = node }
+          hash
+        end
+
+      private
+        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
+          Arel.fetch_attribute(node) do |attr|
+            return if attr_node&.!= attr # all attr nodes should be the same
+            attr_node = attr
+          end
+          attr_node
+        end
+
+        def equalities(predicates, equality_only)
+          equalities = []
+
+          predicates.each do |node|
+            if equality_only ? Arel::Nodes::Equality === node : equality_node?(node)
+              equalities << node
+            elsif node.is_a?(Arel::Nodes::And)
+              equalities.concat equalities(node.children, equality_only)
+            end
+          end
+
+          equalities
+        end
+
+        def equality_node?(node)
+          !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 String
+            Arel::Nodes::Not.new(Arel::Nodes::SqlLiteral.new(node))
+          else
+            node.invert
+          end
+        end
+
+        def except_predicates(columns)
+          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)
+              non_attrs.include?(node.left)
+            end || Arel.fetch_attribute(node) do |attr|
+              attrs.include?(attr) || columns.include?(attr.name.to_s)
+            end
+          end
+        end
+
+        def predicates_with_wrapped_sql_literals
+          non_empty_predicates.map do |node|
+            case node
+            when Arel::Nodes::SqlLiteral, ::String
+              wrap_sql_literal(node)
+            else node
+            end
+          end
+        end
+
+        ARRAY_WITH_EMPTY_STRING = [""]
+        def non_empty_predicates
+          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
+          elsif Array === node
+            node.map { |v| extract_node_value(v) }
+          end
+        end
+    end
+  end
+end