activerecord 4.2.11.3 → 5.0.7.2

data/lib/active_record/relation/from_clause.rb

@@ -0,0 +1,32 @@
+module ActiveRecord
+  class Relation
+    class FromClause # :nodoc:
+      attr_reader :value, :name
+
+      def initialize(value, name)
+        @value = value
+        @name = name
+      end
+
+      def binds
+        if value.is_a?(Relation)
+          value.bound_attributes
+        else
+          []
+        end
+      end
+
+      def merge(other)
+        self
+      end
+
+      def empty?
+        value.nil?
+      end
+
+      def self.empty
+        @empty ||= new(nil, nil)
+      end
+    end
+  end
+end

data/lib/active_record/relation/merger.rb

@@ -1,5 +1,4 @@
 require 'active_support/core_ext/hash/keys'
-require "set"
 
 module ActiveRecord
   class Relation
@@ -22,7 +21,7 @@ module ActiveRecord
       # build a relation to merge in rather than directly merging
       # the values.
       def other
-        other = Relation.create(relation.klass, relation.table)
+        other = Relation.create(relation.klass, relation.table, relation.predicate_builder)
         hash.each { |k, v|
           if k == :joins
             if Hash === v
@@ -49,10 +48,9 @@ module ActiveRecord
         @other    = other
       end
 
-      NORMAL_VALUES = Relation::SINGLE_VALUE_METHODS +
-                      Relation::MULTI_VALUE_METHODS -
-                      [:includes, :preload, :joins, :where, :order, :bind, :reverse_order, :lock, :create_with, :reordering, :from] # :nodoc:
-
+      NORMAL_VALUES = Relation::VALUE_METHODS -
+                      Relation::CLAUSE_METHODS -
+                      [:includes, :preload, :joins, :order, :reverse_order, :lock, :create_with, :reordering] # :nodoc:
 
       def normal_values
         NORMAL_VALUES
@@ -76,6 +74,7 @@ module ActiveRecord
 
         merge_multi_values
         merge_single_values
+        merge_clauses
         merge_preloads
         merge_joins
 
@@ -130,20 +129,6 @@ module ActiveRecord
       end
 
       def merge_multi_values
-        lhs_wheres = relation.where_values
-        rhs_wheres = other.where_values
-
-        lhs_binds  = relation.bind_values
-        rhs_binds  = other.bind_values
-
-        removed, kept = partition_overwrites(lhs_wheres, rhs_wheres)
-
-        where_values = kept + rhs_wheres
-        bind_values  = filter_binds(lhs_binds, removed) + rhs_binds
-
-        relation.where_values = where_values
-        relation.bind_values  = bind_values
-
         if other.reordering_value
           # override any order specified in the original relation
           relation.reorder! other.order_values
@@ -156,36 +141,25 @@ module ActiveRecord
       end
 
       def merge_single_values
-        relation.from_value          = other.from_value unless relation.from_value
-        relation.lock_value          = other.lock_value unless relation.lock_value
+        if relation.from_clause.empty?
+          relation.from_clause = other.from_clause
+        end
+        relation.lock_value ||= other.lock_value
 
         unless other.create_with_value.blank?
           relation.create_with_value = (relation.create_with_value || {}).merge(other.create_with_value)
         end
       end
 
-      def filter_binds(lhs_binds, removed_wheres)
-        return lhs_binds if removed_wheres.empty?
-
-        set = Set.new removed_wheres.map { |x| x.left.name.to_s }
-        lhs_binds.dup.delete_if { |col,_| set.include? col.name }
+      CLAUSE_METHOD_NAMES = CLAUSE_METHODS.map do |name|
+        ["#{name}_clause", "#{name}_clause="]
       end
 
-      # Remove equalities from the existing relation with a LHS which is
-      # present in the relation being merged in.
-      # returns [things_to_remove, things_to_keep]
-      def partition_overwrites(lhs_wheres, rhs_wheres)
-        if lhs_wheres.empty? || rhs_wheres.empty?
-          return [[], lhs_wheres]
-        end
-
-        nodes = rhs_wheres.find_all do |w|
-          w.respond_to?(:operator) && w.operator == :==
-        end
-        seen = Set.new(nodes) { |node| node.left }
-
-        lhs_wheres.partition do |w|
-          w.respond_to?(:operator) && w.operator == :== && seen.include?(w.left)
+      def merge_clauses
+        CLAUSE_METHOD_NAMES.each do |(reader, writer)|
+          clause = relation.send(reader)
+          other_clause = other.send(reader)
+          relation.send(writer, clause.merge(other_clause))
         end
       end
     end

data/lib/active_record/relation/predicate_builder.rb

@@ -1,91 +1,49 @@
 module ActiveRecord
   class PredicateBuilder # :nodoc:
-    @handlers = []
-
-    autoload :RelationHandler, 'active_record/relation/predicate_builder/relation_handler'
-    autoload :ArrayHandler, 'active_record/relation/predicate_builder/array_handler'
-
-    def self.resolve_column_aliases(klass, hash)
-      # This method is a hot spot, so for now, use Hash[] to dup the hash.
-      #   https://bugs.ruby-lang.org/issues/7166
-      hash = Hash[hash]
-      hash.keys.grep(Symbol) do |key|
-        if klass.attribute_alias? key
-          hash[klass.attribute_alias(key)] = hash.delete key
-        end
-      end
-      hash
+    require 'active_record/relation/predicate_builder/array_handler'
+    require 'active_record/relation/predicate_builder/association_query_handler'
+    require 'active_record/relation/predicate_builder/base_handler'
+    require 'active_record/relation/predicate_builder/basic_object_handler'
+    require 'active_record/relation/predicate_builder/class_handler'
+    require 'active_record/relation/predicate_builder/polymorphic_array_handler'
+    require 'active_record/relation/predicate_builder/range_handler'
+    require 'active_record/relation/predicate_builder/relation_handler'
+
+    delegate :resolve_column_aliases, to: :table
+
+    def initialize(table)
+      @table = table
+      @handlers = []
+
+      register_handler(BasicObject, BasicObjectHandler.new(self))
+      register_handler(Class, ClassHandler.new(self))
+      register_handler(Base, BaseHandler.new(self))
+      register_handler(Range, RangeHandler.new(self))
+      register_handler(RangeHandler::RangeWithBinds, RangeHandler.new(self))
+      register_handler(Relation, RelationHandler.new)
+      register_handler(Array, ArrayHandler.new(self))
+      register_handler(AssociationQueryValue, AssociationQueryHandler.new(self))
+      register_handler(PolymorphicArrayValue, PolymorphicArrayHandler.new(self))
     end
 
-    def self.build_from_hash(klass, attributes, default_table)
-      queries = []
-
-      attributes.each do |column, value|
-        table = default_table
-
-        if value.is_a?(Hash)
-          if value.empty?
-            queries << '1=0'
-          else
-            table       = Arel::Table.new(column, default_table.engine)
-            association = klass._reflect_on_association(column)
-
-            value.each do |k, v|
-              queries.concat expand(association && association.klass, table, k, v)
-            end
-          end
-        else
-          column = column.to_s
-
-          if column.include?('.')
-            table_name, column = column.split('.', 2)
-            table = Arel::Table.new(table_name, default_table.engine)
-          end
-
-          queries.concat expand(klass, table, column, value)
-        end
-      end
-
-      queries
+    def build_from_hash(attributes)
+      attributes = convert_dot_notation_to_hash(attributes)
+      expand_from_hash(attributes)
     end
 
-    def self.expand(klass, table, column, value)
-      queries = []
+    def create_binds(attributes)
+      attributes = convert_dot_notation_to_hash(attributes)
+      create_binds_for_hash(attributes)
+    end
 
+    def expand(column, value)
       # Find the foreign key when using queries such as:
       # Post.where(author: author)
       #
       # For polymorphic relationships, find the foreign key and type:
       # PriceEstimate.where(estimate_of: treasure)
-      if klass && reflection = klass._reflect_on_association(column)
-        base_class = polymorphic_base_class_from_value(value)
-
-        if reflection.polymorphic? && base_class
-          queries << build(table[reflection.foreign_type], base_class)
-        end
-
-        column = reflection.foreign_key
-
-        if base_class
-          primary_key = reflection.association_primary_key(base_class)
-          value = convert_value_to_association_ids(value, primary_key)
-        end
-      end
-
-      queries << build(table[column], value)
-      queries
-    end
-
-    def self.polymorphic_base_class_from_value(value)
-      case value
-      when Relation
-        value.klass.base_class
-      when Array
-        val = value.compact.first
-        val.class.base_class if val.is_a?(Base)
-      when Base
-        value.class.base_class
-      end
+      value = AssociationQueryHandler.value_for(table, column, value) if table.associated_with?(column)
+      build(table.arel_attribute(column), value)
     end
 
     def self.references(attributes)
@@ -94,7 +52,7 @@ module ActiveRecord
           key
         else
           key = key.to_s
-          key.split('.').first if key.include?('.')
+          key.split('.'.freeze).first if key.include?('.'.freeze)
         end
       end.compact
     end
@@ -109,47 +67,102 @@ module ActiveRecord
     #         Arel::Nodes::And.new([range.start, range.end])
     #       )
     #     end
-    #     ActiveRecord::PredicateBuilder.register_handler(MyCustomDateRange, handler)
-    def self.register_handler(klass, handler)
+    #     ActiveRecord::PredicateBuilder.new("users").register_handler(MyCustomDateRange, handler)
+    def register_handler(klass, handler)
       @handlers.unshift([klass, handler])
     end
 
-    BASIC_OBJECT_HANDLER = ->(attribute, value) { attribute.eq(value) } # :nodoc:
-    register_handler(BasicObject, BASIC_OBJECT_HANDLER)
-    # FIXME: I think we need to deprecate this behavior
-    register_handler(Class, ->(attribute, value) { attribute.eq(value.name) })
-    register_handler(Base, ->(attribute, value) { attribute.eq(value.id) })
-    register_handler(Range, ->(attribute, value) { attribute.between(value) })
-    register_handler(Relation, RelationHandler.new)
-    register_handler(Array, ArrayHandler.new)
-
-    def self.build(attribute, value)
+    def build(attribute, value)
       handler_for(value).call(attribute, value)
     end
-    private_class_method :build
 
-    def self.handler_for(object)
-      @handlers.detect { |klass, _| klass === object }.last
+    protected
+
+    attr_reader :table
+
+    def expand_from_hash(attributes)
+      return ["1=0"] if attributes.empty?
+
+      attributes.flat_map do |key, value|
+        if value.is_a?(Hash)
+          associated_predicate_builder(key).expand_from_hash(value)
+        else
+          expand(key, value)
+        end
+      end
+    end
+
+
+    def create_binds_for_hash(attributes)
+      result = attributes.dup
+      binds = []
+
+      attributes.each do |column_name, value|
+        case value
+        when Hash
+          attrs, bvs = associated_predicate_builder(column_name).create_binds_for_hash(value)
+          result[column_name] = attrs
+          binds += bvs
+        when Relation
+          binds += value.bound_attributes
+        when Range
+          first = value.begin
+          last = value.end
+          unless first.respond_to?(:infinite?) && first.infinite?
+            binds << build_bind_param(column_name, first)
+            first = Arel::Nodes::BindParam.new
+          end
+          unless last.respond_to?(:infinite?) && last.infinite?
+            binds << build_bind_param(column_name, last)
+            last = Arel::Nodes::BindParam.new
+          end
+
+          result[column_name] = RangeHandler::RangeWithBinds.new(first, last, value.exclude_end?)
+        else
+          if can_be_bound?(column_name, value)
+            result[column_name] = Arel::Nodes::BindParam.new
+            binds << build_bind_param(column_name, value)
+          end
+        end
+      end
+
+      [result, binds]
+    end
+
+    private
+
+    def associated_predicate_builder(association_name)
+      self.class.new(table.associated_table(association_name))
     end
-    private_class_method :handler_for
-
-    def self.convert_value_to_association_ids(value, primary_key)
-      case value
-      when Relation
-        value.select(primary_key)
-      when Array
-        value.map { |v| convert_value_to_association_ids(v, primary_key) }
-      when Base
-        value._read_attribute(primary_key)
-      else
-        value
+
+    def convert_dot_notation_to_hash(attributes)
+      dot_notation = attributes.select do |k, v|
+        k.include?(".".freeze) && !v.is_a?(Hash)
+      end
+
+      dot_notation.each_key do |key|
+        table_name, column_name = key.split(".".freeze)
+        value = attributes.delete(key)
+        attributes[table_name] ||= {}
+
+        attributes[table_name] = attributes[table_name].merge(column_name => value)
       end
+
+      attributes
     end
 
-    def self.can_be_bound?(value) # :nodoc:
+    def handler_for(object)
+      @handlers.detect { |klass, _| klass === object }.last
+    end
+
+    def can_be_bound?(column_name, value)
       !value.nil? &&
-        !value.is_a?(Hash) &&
-        handler_for(value) == BASIC_OBJECT_HANDLER
+        handler_for(value).is_a?(BasicObjectHandler) &&
+        !table.associated_with?(column_name)
+    end
+
+    def build_bind_param(column_name, value)
+      Relation::QueryAttribute.new(column_name.to_s, value, table.type(column_name))
     end
   end
 end

data/lib/active_record/relation/predicate_builder/array_handler.rb

@@ -1,23 +1,14 @@
-require 'active_support/core_ext/string/filters'
-
 module ActiveRecord
   class PredicateBuilder
     class ArrayHandler # :nodoc:
+      def initialize(predicate_builder)
+        @predicate_builder = predicate_builder
+      end
+
       def call(attribute, value)
         values = value.map { |x| x.is_a?(Base) ? x.id : x }
         nils, values = values.partition(&:nil?)
 
-        if values.any? { |val| val.is_a?(Array) }
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Passing a nested array to Active Record finder methods is
-            deprecated and will be removed. Flatten your array before using
-            it for 'IN' conditions.
-          MSG
-
-          flat_values = values.flatten
-          values = flat_values unless flat_values.include?(nil)
-        end
-
         return attribute.in([]) if values.empty? && nils.empty?
 
         ranges, values = values.partition { |v| v.is_a?(Range) }
@@ -25,19 +16,23 @@ module ActiveRecord
         values_predicate =
           case values.length
           when 0 then NullPredicate
-          when 1 then attribute.eq(values.first)
+          when 1 then predicate_builder.build(attribute, values.first)
           else attribute.in(values)
           end
 
         unless nils.empty?
-          values_predicate = values_predicate.or(attribute.eq(nil))
+          values_predicate = values_predicate.or(predicate_builder.build(attribute, nil))
         end
 
-        array_predicates = ranges.map { |range| attribute.between(range) }
+        array_predicates = ranges.map { |range| predicate_builder.build(attribute, range) }
         array_predicates.unshift(values_predicate)
         array_predicates.inject { |composite, predicate| composite.or(predicate) }
       end
 
+      protected
+
+      attr_reader :predicate_builder
+
       module NullPredicate # :nodoc:
         def self.or(other)
           other