activerecord 3.1.10 → 4.2.11

data/lib/active_record/relation/merger.rb

@@ -0,0 +1,193 @@
+require 'active_support/core_ext/hash/keys'
+require "set"
+
+module ActiveRecord
+  class Relation
+    class HashMerger # :nodoc:
+      attr_reader :relation, :hash
+
+      def initialize(relation, hash)
+        hash.assert_valid_keys(*Relation::VALUE_METHODS)
+
+        @relation = relation
+        @hash     = hash
+      end
+
+      def merge #:nodoc:
+        Merger.new(relation, other).merge
+      end
+
+      # Applying values to a relation has some side effects. E.g.
+      # interpolation might take place for where values. So we should
+      # build a relation to merge in rather than directly merging
+      # the values.
+      def other
+        other = Relation.create(relation.klass, relation.table)
+        hash.each { |k, v|
+          if k == :joins
+            if Hash === v
+              other.joins!(v)
+            else
+              other.joins!(*v)
+            end
+          elsif k == :select
+            other._select!(v)
+          else
+            other.send("#{k}!", v)
+          end
+        }
+        other
+      end
+    end
+
+    class Merger # :nodoc:
+      attr_reader :relation, :values, :other
+
+      def initialize(relation, other)
+        @relation = relation
+        @values   = other.values
+        @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:
+
+
+      def normal_values
+        NORMAL_VALUES
+      end
+
+      def merge
+        normal_values.each do |name|
+          value = values[name]
+          # The unless clause is here mostly for performance reasons (since the `send` call might be moderately
+          # expensive), most of the time the value is going to be `nil` or `.blank?`, the only catch is that
+          # `false.blank?` returns `true`, so there needs to be an extra check so that explicit `false` values
+          # don't fall through the cracks.
+          unless value.nil? || (value.blank? && false != value)
+            if name == :select
+              relation._select!(*value)
+            else
+              relation.send("#{name}!", *value)
+            end
+          end
+        end
+
+        merge_multi_values
+        merge_single_values
+        merge_preloads
+        merge_joins
+
+        relation
+      end
+
+      private
+
+      def merge_preloads
+        return if other.preload_values.empty? && other.includes_values.empty?
+
+        if other.klass == relation.klass
+          relation.preload!(*other.preload_values) unless other.preload_values.empty?
+          relation.includes!(other.includes_values) unless other.includes_values.empty?
+        else
+          reflection = relation.klass.reflect_on_all_associations.find do |r|
+            r.class_name == other.klass.name
+          end || return
+
+          unless other.preload_values.empty?
+            relation.preload! reflection.name => other.preload_values
+          end
+
+          unless other.includes_values.empty?
+            relation.includes! reflection.name => other.includes_values
+          end
+        end
+      end
+
+      def merge_joins
+        return if other.joins_values.blank?
+
+        if other.klass == relation.klass
+          relation.joins!(*other.joins_values)
+        else
+          joins_dependency, rest = other.joins_values.partition do |join|
+            case join
+            when Hash, Symbol, Array
+              true
+            else
+              false
+            end
+          end
+
+          join_dependency = ActiveRecord::Associations::JoinDependency.new(other.klass,
+                                                                           joins_dependency,
+                                                                           [])
+          relation.joins! rest
+
+          @relation = relation.joins join_dependency
+        end
+      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
+        elsif other.order_values
+          # merge in order_values from relation
+          relation.order! other.order_values
+        end
+
+        relation.extend(*other.extending_values) unless other.extending_values.blank?
+      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
+
+        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 }
+      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)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'active_support/core_ext/string/filters'
+
+module ActiveRecord
+  class PredicateBuilder
+    class ArrayHandler # :nodoc:
+      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) }
+
+        values_predicate =
+          case values.length
+          when 0 then NullPredicate
+          when 1 then attribute.eq(values.first)
+          else attribute.in(values)
+          end
+
+        unless nils.empty?
+          values_predicate = values_predicate.or(attribute.eq(nil))
+        end
+
+        array_predicates = ranges.map { |range| attribute.between(range) }
+        array_predicates.unshift(values_predicate)
+        array_predicates.inject { |composite, predicate| composite.or(predicate) }
+      end
+
+      module NullPredicate # :nodoc:
+        def self.or(other)
+          other
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module ActiveRecord
+  class PredicateBuilder
+    class RelationHandler # :nodoc:
+      def call(attribute, value)
+        if value.select_values.empty?
+          value = value.select(value.klass.arel_table[value.klass.primary_key])
+        end
+
+        attribute.in(value.arel)
+      end
+    end
+  end
+end

data/lib/active_record/relation/predicate_builder.rb

@@ -1,61 +1,155 @@
 module ActiveRecord
   class PredicateBuilder # :nodoc:
-    def self.build_from_hash(engine, attributes, default_table, allow_table_name = true)
-      predicates = attributes.map do |column, value|
-        table = default_table
+    @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
+    end
 
-        if allow_table_name && value.is_a?(Hash)
-          table = Arel::Table.new(column, engine)
+    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?
-            '1 = 2'
+            queries << '1=0'
           else
-            build_from_hash(engine, value, table, false)
+            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 allow_table_name && column.include?('.')
+          if column.include?('.')
             table_name, column = column.split('.', 2)
-            table = Arel::Table.new(table_name, engine)
+            table = Arel::Table.new(table_name, default_table.engine)
           end
 
-          attribute = table[column.to_sym]
-
-          case value
-          when ActiveRecord::Relation
-            value = value.select(value.klass.arel_table[value.klass.primary_key]) if value.select_values.empty?
-            attribute.in(value.arel.ast)
-          when Array, ActiveRecord::Associations::CollectionProxy
-            values = value.to_a.map { |x|
-              x.is_a?(ActiveRecord::Base) ? x.id : x
-            }
-
-            if values.include?(nil)
-              values = values.compact
-              if values.empty?
-                attribute.eq nil
-              else
-                attribute.in(values.compact).or attribute.eq(nil)
-              end
-            else
-              attribute.in(values)
-            end
+          queries.concat expand(klass, table, column, value)
+        end
+      end
 
-          when Range, Arel::Relation
-            attribute.in(value)
-          when ActiveRecord::Base
-            attribute.eq(value.id)
-          when Class
-            # FIXME: I think we need to deprecate this behavior
-            attribute.eq(value.name)
-          else
-            attribute.eq(value)
-          end
+      queries
+    end
+
+    def self.expand(klass, table, column, value)
+      queries = []
+
+      # 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
+    end
+
+    def self.references(attributes)
+      attributes.map do |key, value|
+        if value.is_a?(Hash)
+          key
+        else
+          key = key.to_s
+          key.split('.').first if key.include?('.')
+        end
+      end.compact
+    end
+
+    # Define how a class is converted to Arel nodes when passed to +where+.
+    # The handler can be any object that responds to +call+, and will be used
+    # for any value that +===+ the class given. For example:
+    #
+    #     MyCustomDateRange = Struct.new(:start, :end)
+    #     handler = proc do |column, range|
+    #       Arel::Nodes::Between.new(column,
+    #         Arel::Nodes::And.new([range.start, range.end])
+    #       )
+    #     end
+    #     ActiveRecord::PredicateBuilder.register_handler(MyCustomDateRange, handler)
+    def self.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)
+      handler_for(value).call(attribute, value)
+    end
+    private_class_method :build
+
+    def self.handler_for(object)
+      @handlers.detect { |klass, _| klass === object }.last
+    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
       end
+    end
 
-      predicates.flatten
+    def self.can_be_bound?(value) # :nodoc:
+      !value.nil? &&
+        !value.is_a?(Hash) &&
+        handler_for(value) == BASIC_OBJECT_HANDLER
     end
   end
 end