activerecord 4.2.11.3 → 5.0.0

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

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

@@ -0,0 +1,88 @@
+module ActiveRecord
+  class PredicateBuilder
+    class AssociationQueryHandler # :nodoc:
+      def self.value_for(table, column, value)
+        klass = if table.associated_table(column).polymorphic_association? && ::Array === value && value.first.is_a?(Base)
+          PolymorphicArrayValue
+        else
+          AssociationQueryValue
+        end
+
+        klass.new(table.associated_table(column), value)
+      end
+
+      def initialize(predicate_builder)
+        @predicate_builder = predicate_builder
+      end
+
+      def call(attribute, value)
+        queries = {}
+
+        table = value.associated_table
+        if value.base_class
+          queries[table.association_foreign_type.to_s] = value.base_class.name
+        end
+
+        queries[table.association_foreign_key.to_s] = value.ids
+        predicate_builder.build_from_hash(queries)
+      end
+
+      protected
+
+      attr_reader :predicate_builder
+    end
+
+    class AssociationQueryValue # :nodoc:
+      attr_reader :associated_table, :value
+
+      def initialize(associated_table, value)
+        @associated_table = associated_table
+        @value = value
+      end
+
+      def ids
+        case value
+        when Relation
+          value.select(primary_key)
+        when Array
+          value.map { |v| convert_to_id(v) }
+        else
+          convert_to_id(value)
+        end
+      end
+
+      def base_class
+        if associated_table.polymorphic_association?
+          @base_class ||= polymorphic_base_class_from_value
+        end
+      end
+
+      private
+
+      def primary_key
+        associated_table.association_primary_key(base_class)
+      end
+
+      def polymorphic_base_class_from_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 convert_to_id(value)
+        case value
+        when Base
+          value._read_attribute(primary_key)
+        else
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module ActiveRecord
+  class PredicateBuilder
+    class BaseHandler # :nodoc:
+      def initialize(predicate_builder)
+        @predicate_builder = predicate_builder
+      end
+
+      def call(attribute, value)
+        predicate_builder.build(attribute, value.id)
+      end
+
+      protected
+
+      attr_reader :predicate_builder
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module ActiveRecord
+  class PredicateBuilder
+    class BasicObjectHandler # :nodoc:
+      def initialize(predicate_builder)
+        @predicate_builder = predicate_builder
+      end
+
+      def call(attribute, value)
+        attribute.eq(value)
+      end
+
+      protected
+
+      attr_reader :predicate_builder
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module ActiveRecord
+  class PredicateBuilder
+    class ClassHandler # :nodoc:
+      def initialize(predicate_builder)
+        @predicate_builder = predicate_builder
+      end
+
+      def call(attribute, value)
+        print_deprecation_warning
+        predicate_builder.build(attribute, value.name)
+      end
+
+      protected
+
+      attr_reader :predicate_builder
+
+      private
+
+      def print_deprecation_warning
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          Passing a class as a value in an Active Record query is deprecated and
+          will be removed. Pass a string instead.
+        MSG
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module ActiveRecord
+  class PredicateBuilder
+    class PolymorphicArrayHandler # :nodoc:
+      def initialize(predicate_builder)
+        @predicate_builder = predicate_builder
+      end
+
+      def call(attribute, value)
+        table = value.associated_table
+        queries = value.type_to_ids_mapping.map do |type, ids|
+          { table.association_foreign_type.to_s => type, table.association_foreign_key.to_s => ids }
+        end
+
+        predicates = queries.map { |query| predicate_builder.build_from_hash(query) }
+
+        if predicates.size > 1
+          type_and_ids_predicates = predicates.map { |type_predicate, id_predicate| Arel::Nodes::Grouping.new(type_predicate.and(id_predicate)) }
+          type_and_ids_predicates.inject(&:or)
+        else
+          predicates.first
+        end
+      end
+
+      protected
+
+      attr_reader :predicate_builder
+    end
+
+    class PolymorphicArrayValue # :nodoc:
+      attr_reader :associated_table, :values
+
+      def initialize(associated_table, values)
+        @associated_table = associated_table
+        @values = values
+      end
+
+      def type_to_ids_mapping
+        default_hash = Hash.new { |hsh, key| hsh[key] = [] }
+        values.each_with_object(default_hash) { |value, hash| hash[base_class(value).name] << convert_to_id(value) }
+      end
+
+      private
+
+      def primary_key(value)
+        associated_table.association_primary_key(base_class(value))
+      end
+
+      def base_class(value)
+        value.class.base_class
+      end
+
+      def convert_to_id(value)
+        value._read_attribute(primary_key(value))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module ActiveRecord
+  class PredicateBuilder
+    class RangeHandler # :nodoc:
+      RangeWithBinds = Struct.new(:begin, :end, :exclude_end?)
+
+      def initialize(predicate_builder)
+        @predicate_builder = predicate_builder
+      end
+
+      def call(attribute, value)
+        if value.begin.respond_to?(:infinite?) && value.begin.infinite?
+          if value.end.respond_to?(:infinite?) && value.end.infinite?
+            attribute.not_in([])
+          elsif value.exclude_end?
+            attribute.lt(value.end)
+          else
+            attribute.lteq(value.end)
+          end
+        elsif value.end.respond_to?(:infinite?) && value.end.infinite?
+          attribute.gteq(value.begin)
+        elsif value.exclude_end?
+          attribute.gteq(value.begin).and(attribute.lt(value.end))
+        else
+          attribute.between(value)
+        end
+      end
+
+      protected
+
+      attr_reader :predicate_builder
+    end
+  end
+end

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

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

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/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