activerecord 4.2.11.1 → 5.2.4.5

data/lib/active_record/relation/record_fetch_warning.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Relation
+    module RecordFetchWarning
+      # 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
+          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(";")}"
+            end
+          end
+        end
+      end
+
+      # :stopdoc:
+      ActiveSupport::Notifications.subscribe("sql.active_record") do |*, payload|
+        QueryRegistry.queries << payload[:sql]
+      end
+      # :startdoc:
+
+      class QueryRegistry # :nodoc:
+        extend ActiveSupport::PerThreadRegistry
+
+        attr_reader :queries
+
+        def initialize
+          @queries = []
+        end
+
+        def reset
+          @queries.clear
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.prepend ActiveRecord::Relation::RecordFetchWarning

data/lib/active_record/relation/spawn_methods.rb

@@ -1,16 +1,17 @@
-require 'active_support/core_ext/hash/except'
-require 'active_support/core_ext/hash/slice'
-require 'active_record/relation/merger'
+# 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
-
     # This is overridden by Associations::CollectionProxy
     def spawn #:nodoc:
-      clone
+      @delegate_to_klass ? klass.all : clone
     end
 
-    # Merges in the conditions from <tt>other</tt>, if <tt>other</tt> is an <tt>ActiveRecord::Relation</tt>.
+    # 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) )
@@ -29,11 +30,11 @@ module ActiveRecord
     # This is mainly intended for sharing common conditions between multiple associations.
     def merge(other)
       if other.is_a?(Array)
-        to_a & other
+        records & other
       elsif other
         spawn.merge!(other)
       else
-        self
+        raise ArgumentError, "invalid argument: #{other.inspect}."
       end
     end
 
@@ -62,16 +63,13 @@ module ActiveRecord
     #   Post.order('id asc').only(:where)         # discards the order condition
     #   Post.order('id asc').only(:where, :order) # uses the specified order
     def only(*onlies)
-      if onlies.any? { |o| o == :where }
-        onlies << :bind
-      end
       relation_with values.slice(*onlies)
     end
 
     private
 
-      def relation_with(values) # :nodoc:
-        result = Relation.create(klass, table, values)
+      def relation_with(values)
+        result = Relation.create(klass, values: values)
         result.extend(*extending_values) if extending_values.any?
         result
       end

data/lib/active_record/relation/where_clause.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+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 merge(other)
+        WhereClause.new(
+          predicates_unreferenced_by(other) + 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
+          or_clause = WhereClause.new(
+            [left.ast.or(right.ast)],
+          )
+          common + or_clause
+        end
+      end
+
+      def to_h(table_name = nil)
+        equalities = equalities(predicates)
+        if table_name
+          equalities = equalities.select do |node|
+            node.left.relation.name == table_name
+          end
+        end
+
+        equalities.map { |node|
+          name = node.left.name.to_s
+          value = extract_node_value(node.right)
+          [name, value]
+        }.to_h
+      end
+
+      def ast
+        Arel::Nodes::And.new(predicates_with_wrapped_sql_literals)
+      end
+
+      def ==(other)
+        other.is_a?(WhereClause) &&
+          predicates == other.predicates
+      end
+
+      def invert
+        WhereClause.new(inverted_predicates)
+      end
+
+      def self.empty
+        @empty ||= new([])
+      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
+        end
+
+      private
+        def equalities(predicates)
+          equalities = []
+
+          predicates.each do |node|
+            case node
+            when Arel::Nodes::Equality
+              equalities << node
+            when Arel::Nodes::And
+              equalities.concat equalities(node.children)
+            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 == :==
+        end
+
+        def inverted_predicates
+          predicates.map { |node| invert_predicate(node) }
+        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::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)
+          end
+        end
+
+        def except_predicates(columns)
+          predicates.reject do |node|
+            case node
+            when Arel::Nodes::Between, Arel::Nodes::In, Arel::Nodes::NotIn, Arel::Nodes::Equality, Arel::Nodes::NotEqual, Arel::Nodes::LessThan, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThan, Arel::Nodes::GreaterThanOrEqual
+              subrelation = (node.left.kind_of?(Arel::Attributes::Attribute) ? node.left : node.right)
+              columns.include?(subrelation.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)
+          case node
+          when Array
+            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
+  end
+end

data/lib/active_record/relation/where_clause_factory.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Relation
+    class WhereClauseFactory # :nodoc:
+      def initialize(klass, predicate_builder)
+        @klass = klass
+        @predicate_builder = predicate_builder
+      end
+
+      def build(opts, other)
+        case opts
+        when String, Array
+          parts = [klass.sanitize_sql(other.empty? ? opts : ([opts] + other))]
+        when Hash
+          attributes = predicate_builder.resolve_column_aliases(opts)
+          attributes.stringify_keys!
+
+          parts = predicate_builder.build_from_hash(attributes)
+        when Arel::Nodes::Node
+          parts = [opts]
+        else
+          raise ArgumentError, "Unsupported argument type: #{opts} (#{opts.class})"
+        end
+
+        WhereClause.new(parts)
+      end
+
+      protected
+
+        attr_reader :klass, :predicate_builder
+    end
+  end
+end