activerecord 4.2.9 → 6.1.4.1

data/lib/active_record/relation/predicate_builder.rb

@@ -1,102 +1,42 @@
+# frozen_string_literal: true
+
 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
-    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
+    require "active_record/relation/predicate_builder/array_handler"
+    require "active_record/relation/predicate_builder/basic_object_handler"
+    require "active_record/relation/predicate_builder/range_handler"
+    require "active_record/relation/predicate_builder/relation_handler"
+    require "active_record/relation/predicate_builder/association_query_value"
+    require "active_record/relation/predicate_builder/polymorphic_array_value"
+
+    # No-op BaseHandler to work Mashal.load(File.read("legacy_relation.dump")).
+    # TODO: Remove the constant alias once Rails 6.1 has released.
+    BaseHandler = BasicObjectHandler
+
+    def initialize(table)
+      @table = table
+      @handlers = []
+
+      register_handler(BasicObject, BasicObjectHandler.new(self))
+      register_handler(Range, RangeHandler.new(self))
+      register_handler(Relation, RelationHandler.new)
+      register_handler(Array, ArrayHandler.new(self))
+      register_handler(Set, ArrayHandler.new(self))
     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
+    def build_from_hash(attributes, &block)
+      attributes = convert_dot_notation_to_hash(attributes)
+      expand_from_hash(attributes, &block)
     end
 
     def self.references(attributes)
-      attributes.map do |key, value|
+      attributes.each_with_object([]) do |(key, value), result|
         if value.is_a?(Hash)
-          key
-        else
-          key = key.to_s
-          key.split('.').first if key.include?('.')
+          result << Arel.sql(key)
+        elsif key.include?(".")
+          result << Arel.sql(key.split(".").first)
         end
-      end.compact
+      end
     end
 
     # Define how a class is converted to Arel nodes when passed to +where+.
@@ -109,47 +49,121 @@ 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)
-      handler_for(value).call(attribute, value)
+    def [](attr_name, value, operator = nil)
+      build(table.arel_table[attr_name], value, operator)
     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)
+    def build(attribute, value, operator = nil)
+      value = value.id if value.respond_to?(:id)
+      if operator ||= table.type(attribute.name).force_equality?(value) && :eq
+        bind = build_bind_attribute(attribute.name, value)
+        attribute.public_send(operator, bind)
       else
-        value
+        handler_for(value).call(attribute, value)
       end
     end
 
-    def self.can_be_bound?(value) # :nodoc:
-      !value.nil? &&
-        !value.is_a?(Hash) &&
-        handler_for(value) == BASIC_OBJECT_HANDLER
+    def build_bind_attribute(column_name, value)
+      attr = Relation::QueryAttribute.new(column_name, value, table.type(column_name))
+      Arel::Nodes::BindParam.new(attr)
+    end
+
+    def resolve_arel_attribute(table_name, column_name, &block)
+      table.associated_table(table_name, &block).arel_table[column_name]
     end
+
+    protected
+      def expand_from_hash(attributes, &block)
+        return ["1=0"] if attributes.empty?
+
+        attributes.flat_map do |key, value|
+          if value.is_a?(Hash) && !table.has_column?(key)
+            table.associated_table(key, &block)
+              .predicate_builder.expand_from_hash(value.stringify_keys)
+          elsif table.associated_with?(key)
+            # 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)
+            associated_table = table.associated_table(key)
+            if associated_table.polymorphic_association?
+              value = [value] unless value.is_a?(Array)
+              klass = PolymorphicArrayValue
+            elsif associated_table.through_association?
+              next associated_table.predicate_builder.expand_from_hash(
+                associated_table.primary_key => value
+              )
+            end
+
+            klass ||= AssociationQueryValue
+            queries = klass.new(associated_table, value).queries.map! do |query|
+              # If the query produced is identical to attributes don't go any deeper.
+              # Prevents stack level too deep errors when association and foreign_key are identical.
+              query == attributes ? self[key, value] : expand_from_hash(query)
+            end
+
+            grouping_queries(queries)
+          elsif table.aggregated_with?(key)
+            mapping = table.reflect_on_aggregation(key).mapping
+            values = value.nil? ? [nil] : Array.wrap(value)
+            if mapping.length == 1 || values.empty?
+              column_name, aggr_attr = mapping.first
+              values = values.map do |object|
+                object.respond_to?(aggr_attr) ? object.public_send(aggr_attr) : object
+              end
+              self[column_name, values]
+            else
+              queries = values.map do |object|
+                mapping.map do |field_attr, aggregate_attr|
+                  self[field_attr, object.try!(aggregate_attr)]
+                end
+              end
+
+              grouping_queries(queries)
+            end
+          else
+            self[key, value]
+          end
+        end
+      end
+
+    private
+      attr_reader :table
+
+      def grouping_queries(queries)
+        if queries.one?
+          queries.first
+        else
+          queries.map! { |query| query.reduce(&:and) }
+          queries = queries.reduce { |result, query| Arel::Nodes::Or.new(result, query) }
+          Arel::Nodes::Grouping.new(queries)
+        end
+      end
+
+      def convert_dot_notation_to_hash(attributes)
+        dot_notation = attributes.select do |k, v|
+          k.include?(".") && !v.is_a?(Hash)
+        end
+
+        dot_notation.each_key do |key|
+          table_name, column_name = key.split(".")
+          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
   end
 end

data/lib/active_record/relation/query_attribute.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "active_model/attribute"
+
+module ActiveRecord
+  class Relation
+    class QueryAttribute < ActiveModel::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
+
+      def nil?
+        unless value_before_type_cast.is_a?(StatementCache::Substitute)
+          value_before_type_cast.nil? ||
+            type.respond_to?(:subtype, true) && value_for_database.nil?
+        end
+      rescue ::RangeError
+      end
+
+      def infinite?
+        infinity?(value_before_type_cast) || infinity?(value_for_database)
+      rescue ::RangeError
+      end
+
+      def unboundable?
+        if defined?(@_unboundable)
+          @_unboundable
+        else
+          value_for_database unless value_before_type_cast.is_a?(StatementCache::Substitute)
+          @_unboundable = nil
+        end
+      rescue ::RangeError
+        @_unboundable = type.cast(value_before_type_cast) <=> 0
+      end
+
+      private
+        def infinity?(value)
+          value.respond_to?(:infinite?) && value.infinite?
+        end
+    end
+  end
+end