activerecord 6.0.0 → 7.2.3

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

@@ -9,7 +9,14 @@ module ActiveRecord
       end
 
       def queries
-        [associated_table.association_join_foreign_key.to_s => ids]
+        if associated_table.join_foreign_key.is_a?(Array)
+          id_list = ids
+          id_list = id_list.pluck(primary_key) if id_list.is_a?(Relation)
+
+          id_list.map { |ids_set| associated_table.join_foreign_key.zip(ids_set).to_h }
+        else
+          [ associated_table.join_foreign_key => ids ]
+        end
       end
 
       private
@@ -18,22 +25,50 @@ module ActiveRecord
         def ids
           case value
           when Relation
-            value.select_values.empty? ? value.select(primary_key) : value
+            relation = value
+            relation = relation.select(primary_key) if select_clause?
+            relation = relation.where(primary_type => polymorphic_name) if polymorphic_clause?
+            relation
           when Array
             value.map { |v| convert_to_id(v) }
           else
-            convert_to_id(value)
+            [convert_to_id(value)]
           end
         end
 
         def primary_key
-          associated_table.association_join_primary_key
+          associated_table.join_primary_key
+        end
+
+        def primary_type
+          associated_table.join_primary_type
+        end
+
+        def polymorphic_name
+          associated_table.polymorphic_name_association
+        end
+
+        def select_clause?
+          value.select_values.empty?
+        end
+
+        def polymorphic_clause?
+          primary_type && !value.where_values_hash.has_key?(primary_type)
         end
 
         def convert_to_id(value)
-          case value
-          when Base
-            value._read_attribute(primary_key)
+          if primary_key.is_a?(Array)
+            primary_key.map do |attribute|
+              next nil if value.nil?
+
+              if attribute == "id"
+                value.id_value
+              else
+                value.public_send(attribute)
+              end
+            end
+          elsif value.respond_to?(primary_key)
+            value.public_send(primary_key)
           else
             value
           end

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

@@ -9,11 +9,13 @@ module ActiveRecord
       end
 
       def queries
+        return [ associated_table.join_foreign_key => values ] if values.empty?
+
         type_to_ids_mapping.map do |type, ids|
-          {
-            associated_table.association_foreign_type.to_s => type,
-            associated_table.association_foreign_key.to_s => ids
-          }
+          query = {}
+          query[associated_table.join_foreign_type] = type if type
+          query[associated_table.join_foreign_key] = ids
+          query
         end
       end
 
@@ -23,29 +25,34 @@ module ActiveRecord
         def type_to_ids_mapping
           default_hash = Hash.new { |hsh, key| hsh[key] = [] }
           values.each_with_object(default_hash) do |value, hash|
-            hash[klass(value).polymorphic_name] << convert_to_id(value)
+            hash[klass(value)&.polymorphic_name] << convert_to_id(value)
           end
         end
 
         def primary_key(value)
-          associated_table.association_join_primary_key(klass(value))
+          associated_table.join_primary_key(klass(value))
         end
 
         def klass(value)
-          case value
-          when Base
+          if value.is_a?(Base)
             value.class
-          when Relation
+          elsif value.is_a?(Relation)
             value.klass
           end
         end
 
         def convert_to_id(value)
-          case value
-          when Base
-            value._read_attribute(primary_key(value))
-          when Relation
+          if value.is_a?(Base)
+            primary_key = primary_key(value)
+            if primary_key.is_a?(Array)
+              primary_key.map { |column| value._read_attribute(column) }
+            else
+              value._read_attribute(primary_key)
+            end
+          elsif value.is_a?(Relation)
             value.select(primary_key(value))
+          else
+            value
           end
         end
     end

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

@@ -9,7 +9,11 @@ module ActiveRecord
         end
 
         if value.select_values.empty?
-          value = value.select(value.arel_attribute(value.klass.primary_key))
+          if value.klass.composite_primary_key?
+            raise ArgumentError, "Cannot map composite primary key #{value.klass.primary_key} to #{attribute.name}"
+          else
+            value = value.select(value.table[value.klass.primary_key])
+          end
         end
 
         attribute.in(value.arel)

data/lib/active_record/relation/predicate_builder.rb

@@ -2,34 +2,37 @@
 
 module ActiveRecord
   class PredicateBuilder # :nodoc:
-    delegate :resolve_column_aliases, to: :table
+    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"
 
     def initialize(table)
       @table = table
       @handlers = []
 
       register_handler(BasicObject, BasicObjectHandler.new(self))
-      register_handler(Base, BaseHandler.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 build_from_hash(attributes)
+    def build_from_hash(attributes, &block)
       attributes = convert_dot_notation_to_hash(attributes)
-      expand_from_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, retryable: true)
+        elsif (idx = key.rindex("."))
+          result << Arel.sql(key[0, idx], retryable: true)
         end
-      end.compact
+      end
     end
 
     # Define how a class is converted to Arel nodes when passed to +where+.
@@ -47,27 +50,42 @@ module ActiveRecord
       @handlers.unshift([klass, handler])
     end
 
-    def build(attribute, value)
-      if table.type(attribute.name).force_equality?(value)
+    def [](attr_name, value, operator = nil)
+      build(table.arel_table[attr_name], value, operator)
+    end
+
+    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.eq(bind)
+        attribute.public_send(operator, bind)
       else
         handler_for(value).call(attribute, value)
       end
     end
 
     def build_bind_attribute(column_name, value)
-      attr = Relation::QueryAttribute.new(column_name.to_s, value, table.type(column_name))
-      Arel::Nodes::BindParam.new(attr)
+      Relation::QueryAttribute.new(column_name, value, table.type(column_name))
+    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)
+      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)
-            associated_predicate_builder(key).expand_from_hash(value)
+          if key.is_a?(Array)
+            queries = Array(value).map do |ids_set|
+              raise ArgumentError, "Expected corresponding value for #{key} to be an Array" unless ids_set.is_a?(Array)
+              expand_from_hash(key.zip(ids_set).to_h)
+            end
+            grouping_queries(queries)
+          elsif 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)
@@ -76,18 +94,22 @@ module ActiveRecord
             # PriceEstimate.where(estimate_of: treasure)
             associated_table = table.associated_table(key)
             if associated_table.polymorphic_association?
-              case value.is_a?(Array) ? value.first : value
-              when Base, Relation
-                value = [value] unless value.is_a?(Array)
-                klass = PolymorphicArrayValue
-              end
+              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|
-              expand_from_hash(query).reduce(&:and)
+            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
-            queries.reduce(&:or)
+
+            grouping_queries(queries)
           elsif table.aggregated_with?(key)
             mapping = table.reflect_on_aggregation(key).mapping
             values = value.nil? ? [nil] : Array.wrap(value)
@@ -96,17 +118,18 @@ module ActiveRecord
               values = values.map do |object|
                 object.respond_to?(aggr_attr) ? object.public_send(aggr_attr) : object
               end
-              build(table.arel_attribute(column_name), values)
+              self[column_name, values]
             else
               queries = values.map do |object|
                 mapping.map do |field_attr, aggregate_attr|
-                  build(table.arel_attribute(field_attr), object.try!(aggregate_attr))
-                end.reduce(&:and)
+                  self[field_attr, object.try!(aggregate_attr)]
+                end
               end
-              queries.reduce(&:or)
+
+              grouping_queries(queries)
             end
           else
-            build(table.arel_attribute(key), value)
+            self[key, value]
           end
         end
       end
@@ -114,24 +137,36 @@ module ActiveRecord
     private
       attr_reader :table
 
-      def associated_predicate_builder(association_name)
-        self.class.new(table.associated_table(association_name))
+      def grouping_queries(queries)
+        if queries.one?
+          queries.first
+        else
+          queries.map! { |query| query.reduce(&:and) }
+          queries = Arel::Nodes::Or.new(queries)
+          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.each_with_object({}) do |(key, value), converted|
+          if value.is_a?(Hash)
+            if (existing = converted[key])
+              existing.merge!(value)
+            else
+              converted[key] = value.dup
+            end
+          elsif (idx = key.rindex("."))
+            table_name, column_name = key[0, idx], key[idx + 1, key.length]
 
-          attributes[table_name] = attributes[table_name].merge(column_name => value)
+            if (existing = converted[table_name])
+              existing[column_name] = value
+            else
+              converted[table_name] = { column_name => value }
+            end
+          else
+            converted[key] = value
+          end
         end
-
-        attributes
       end
 
       def handler_for(object)
@@ -139,12 +174,3 @@ module ActiveRecord
       end
   end
 end
-
-require "active_record/relation/predicate_builder/array_handler"
-require "active_record/relation/predicate_builder/base_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"

data/lib/active_record/relation/query_attribute.rb

@@ -5,12 +5,27 @@ require "active_model/attribute"
 module ActiveRecord
   class Relation
     class QueryAttribute < ActiveModel::Attribute # :nodoc:
+      def initialize(...)
+        super
+
+        # The query attribute value may be mutated before we actually "compile" the query.
+        # To avoid that if the type uses a serializer we eagerly compute the value for database
+        if value_before_type_cast.is_a?(StatementCache::Substitute)
+          # we don't need to serialize StatementCache::Substitute
+        elsif @type.serialized?
+          value_for_database
+        elsif @type.mutable? # If the type is simply mutable, we deep_dup it.
+          @value_before_type_cast = @value_before_type_cast.deep_dup
+        end
+      end
+
       def type_cast(value)
         value
       end
 
       def value_for_database
-        @value_for_database ||= super
+        @value_for_database = _value_for_database unless defined?(@value_for_database)
+        @value_for_database
       end
 
       def with_cast_value(value)
@@ -20,25 +35,28 @@ module ActiveRecord
       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?
+            (type.respond_to?(:subtype) || type.respond_to?(:normalizer)) && serializable? && value_for_database.nil?
         end
-      rescue ::RangeError
       end
 
       def infinite?
-        infinity?(value_before_type_cast) || infinity?(value_for_database)
-      rescue ::RangeError
+        infinity?(value_before_type_cast) || serializable? && infinity?(value_for_database)
       end
 
       def unboundable?
-        if defined?(@_unboundable)
-          @_unboundable
-        else
-          value_for_database unless value_before_type_cast.is_a?(StatementCache::Substitute)
-          @_unboundable = nil
+        unless defined?(@_unboundable)
+          serializable? { |value| @_unboundable = value <=> 0 } && @_unboundable = nil
         end
-      rescue ::RangeError
-        @_unboundable = type.cast(value_before_type_cast) <=> 0
+        @_unboundable
+      end
+
+      def ==(other)
+        super && value_for_database == other.value_for_database
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, name, value_for_database, type].hash
       end
 
       private