activerecord 4.2.11.3 → 5.0.0

data/lib/active_record/relation/record_fetch_warning.rb

@@ -0,0 +1,49 @@
+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 active_record/lib/relation/batches.rb 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

@@ -10,7 +10,7 @@ module ActiveRecord
       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 +29,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 +62,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)
+        result = Relation.create(klass, table, predicate_builder, values)
         result.extend(*extending_values) if extending_values.any?
         result
       end

data/lib/active_record/relation/where_clause.rb

@@ -0,0 +1,174 @@
+module ActiveRecord
+  class Relation
+    class WhereClause # :nodoc:
+      attr_reader :binds
+
+      delegate :any?, :empty?, to: :predicates
+
+      def initialize(predicates, binds)
+        @predicates = predicates
+        @binds = binds
+      end
+
+      def +(other)
+        WhereClause.new(
+          predicates + other.predicates,
+          binds + other.binds,
+        )
+      end
+
+      def merge(other)
+        WhereClause.new(
+          predicates_unreferenced_by(other) + other.predicates,
+          non_conflicting_binds(other) + other.binds,
+        )
+      end
+
+      def except(*columns)
+        WhereClause.new(
+          predicates_except(columns),
+          binds_except(columns),
+        )
+      end
+
+      def or(other)
+        if empty?
+          self
+        elsif other.empty?
+          other
+        else
+          WhereClause.new(
+            [ast.or(other.ast)],
+            binds + other.binds
+          )
+        end
+      end
+
+      def to_h(table_name = nil)
+        equalities = predicates.grep(Arel::Nodes::Equality)
+        if table_name
+          equalities = equalities.select do |node|
+            node.left.relation.name == table_name
+          end
+        end
+
+        binds = self.binds.map { |attr| [attr.name, attr.value] }.to_h
+
+        equalities.map { |node|
+          name = node.left.name
+          [name, binds.fetch(name.to_s) {
+            case node.right
+            when Array then node.right.map(&:val)
+            when Arel::Nodes::Casted, Arel::Nodes::Quoted
+              node.right.val
+            end
+          }]
+        }.to_h
+      end
+
+      def ast
+        Arel::Nodes::And.new(predicates_with_wrapped_sql_literals)
+      end
+
+      def ==(other)
+        other.is_a?(WhereClause) &&
+          predicates == other.predicates &&
+          binds == other.binds
+      end
+
+      def invert
+        WhereClause.new(inverted_predicates, binds)
+      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 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 non_conflicting_binds(other)
+        conflicts = referenced_columns & other.referenced_columns
+        conflicts.map! { |node| node.name.to_s }
+        binds.reject { |attr| conflicts.include?(attr.name) }
+      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 predicates_except(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 binds_except(columns)
+        binds.reject do |attr|
+          columns.include?(attr.name)
+        end
+      end
+
+      def predicates_with_wrapped_sql_literals
+        non_empty_predicates.map do |node|
+          if Arel::Nodes::Equality === node
+            node
+          else
+            wrap_sql_literal(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
+    end
+  end
+end

data/lib/active_record/relation/where_clause_factory.rb

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