activerecord 3.2.19 → 5.0.0

data/lib/active_record/relation/predicate_builder.rb

@@ -1,63 +1,168 @@
 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
+    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'
 
-        if allow_table_name && value.is_a?(Hash)
-          table = Arel::Table.new(column, engine)
+    delegate :resolve_column_aliases, to: :table
 
-          if value.empty?
-            '1 = 2'
-          else
-            build_from_hash(engine, value, table, false)
-          end
+    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 build_from_hash(attributes)
+      attributes = convert_dot_notation_to_hash(attributes)
+      expand_from_hash(attributes)
+    end
+
+    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)
+      value = AssociationQueryHandler.value_for(table, column, value) if table.associated_with?(column)
+      build(table.arel_attribute(column), value)
+    end
+
+    def self.references(attributes)
+      attributes.map do |key, value|
+        if value.is_a?(Hash)
+          key
+        else
+          key = key.to_s
+          key.split('.'.freeze).first if key.include?('.'.freeze)
+        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.new("users").register_handler(MyCustomDateRange, handler)
+    def register_handler(klass, handler)
+      @handlers.unshift([klass, handler])
+    end
+
+    def build(attribute, value)
+      handler_for(value).call(attribute, value)
+    end
+
+    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
-          column = column.to_s
+          expand(key, value)
+        end
+      end
+    end
+
 
-          if allow_table_name && column.include?('.')
-            table_name, column = column.split('.', 2)
-            table = Arel::Table.new(table_name, engine)
+    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
 
-          attribute = table[column]
-
-          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}
-            ranges, values = values.partition {|v| v.is_a?(Range) || v.is_a?(Arel::Relation)}
-
-            array_predicates = ranges.map {|range| attribute.in(range)}
-
-            if values.include?(nil)
-              values = values.compact
-              if values.empty?
-                array_predicates << attribute.eq(nil)
-              else
-                array_predicates << attribute.in(values.compact).or(attribute.eq(nil))
-              end
-            else
-              array_predicates << attribute.in(values)
-            end
-
-            array_predicates.inject {|composite, predicate| composite.or(predicate)}
-          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)
+          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
 
-      predicates.flatten
+      [result, binds]
+    end
+
+    private
+
+    def associated_predicate_builder(association_name)
+      self.class.new(table.associated_table(association_name))
+    end
+
+    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 handler_for(object)
+      @handlers.detect { |klass, _| klass === object }.last
+    end
+
+    def can_be_bound?(column_name, value)
+      !value.nil? &&
+        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/query_attribute.rb

@@ -0,0 +1,19 @@
+require 'active_record/attribute'
+
+module ActiveRecord
+  class Relation
+    class QueryAttribute < Attribute # :nodoc:
+      def type_cast(value)
+        value
+      end
+
+      def value_for_database
+        @value_for_database ||= super
+      end
+
+      def with_cast_value(value)
+        QueryAttribute.new(name, value, type)
+      end
+    end
+  end
+end