activerecord 7.0.8.7 → 7.1.0.beta1

data/lib/active_record/relation/delegation.rb

@@ -5,6 +5,23 @@ require "active_support/core_ext/module/delegation"
 
 module ActiveRecord
   module Delegation # :nodoc:
+    class << self
+      def delegated_classes
+        [
+          ActiveRecord::Relation,
+          ActiveRecord::Associations::CollectionProxy,
+          ActiveRecord::AssociationRelation,
+          ActiveRecord::DisableJoinsAssociationRelation,
+        ]
+      end
+
+      def uncacheable_methods
+        @uncacheable_methods ||= (
+          delegated_classes.flat_map(&:public_instance_methods) - ActiveRecord::Relation.public_instance_methods
+        ).to_set.freeze
+      end
+    end
+
     module DelegateCache # :nodoc:
       def relation_delegate_class(klass)
         @relation_delegate_cache[klass]
@@ -12,12 +29,7 @@ module ActiveRecord
 
       def initialize_relation_delegate_cache
         @relation_delegate_cache = cache = {}
-        [
-          ActiveRecord::Relation,
-          ActiveRecord::Associations::CollectionProxy,
-          ActiveRecord::AssociationRelation,
-          ActiveRecord::DisableJoinsAssociationRelation
-        ].each do |klass|
+        Delegation.delegated_classes.each do |klass|
           delegate = Class.new(klass) {
             include ClassSpecificRelation
           }
@@ -85,7 +97,7 @@ module ActiveRecord
     # may vary depending on the klass of a relation, so we create a subclass of Relation
     # for each different klass, and the delegations are compiled into that subclass only.
 
-    delegate :to_xml, :encode_with, :length, :each, :join,
+    delegate :to_xml, :encode_with, :length, :each, :join, :intersect?,
              :[], :&, :|, :+, :-, :sample, :reverse, :rotate, :compact, :in_groups, :in_groups_of,
              :to_sentence, :to_fs, :to_formatted_s, :as_json,
              :shuffle, :split, :slice, :index, :rindex, to: :records
@@ -104,7 +116,9 @@ module ActiveRecord
       private
         def method_missing(method, *args, &block)
           if @klass.respond_to?(method)
-            @klass.generate_relation_method(method)
+            unless Delegation.uncacheable_methods.include?(method)
+              @klass.generate_relation_method(method)
+            end
             scoping { @klass.public_send(method, *args, &block) }
           else
             super

data/lib/active_record/relation/finder_methods.rb

@@ -6,7 +6,9 @@ module ActiveRecord
   module FinderMethods
     ONE_AS_ONE = "1 AS one"
 
-    # Find by id - This can either be a specific id (1), a list of ids (1, 5, 6), or an array of ids ([5, 6, 10]).
+    # Find by id - This can either be a specific id (ID), a list of ids (ID, ID, ID), or an array of ids ([ID, ID, ID]).
+    # `ID` refers to an "identifier". For models with a single-column primary key, `ID` will be a single value,
+    # and for models with a composite primary key, it will be an array of values.
     # If one or more records cannot be found for the requested ids, then ActiveRecord::RecordNotFound will be raised.
     # If the primary key is an integer, find by id coerces its arguments by using +to_i+.
     #
@@ -18,6 +20,27 @@ module ActiveRecord
     #   Person.find([1])        # returns an array for the object with ID = 1
     #   Person.where("administrator = 1").order("created_on DESC").find(1)
     #
+    # ==== Find a record for a composite primary key model
+    #   TravelRoute.primary_key = [:origin, :destination]
+    #
+    #   TravelRoute.find(["Ottawa", "London"])
+    #   => #<TravelRoute origin: "Ottawa", destination: "London">
+    #
+    #   TravelRoute.find([["Paris", "Montreal"]])
+    #   => [#<TravelRoute origin: "Paris", destination: "Montreal">]
+    #
+    #   TravelRoute.find(["New York", "Las Vegas"], ["New York", "Portland"])
+    #   => [
+    #        #<TravelRoute origin: "New York", destination: "Las Vegas">,
+    #        #<TravelRoute origin: "New York", destination: "Portland">
+    #      ]
+    #
+    #   TravelRoute.find([["Berlin", "London"], ["Barcelona", "Lisbon"]])
+    #   => [
+    #        #<TravelRoute origin: "Berlin", destination: "London">,
+    #        #<TravelRoute origin: "Barcelona", destination: "Lisbon">
+    #      ]
+    #
     # NOTE: The returned records are in the same order as the ids you provide.
     # If you want the results to be sorted by database, you can use ActiveRecord::QueryMethods#where
     # method and provide an explicit ActiveRecord::QueryMethods#order option.
@@ -324,6 +347,8 @@ module ActiveRecord
     #   Person.exists?
     #   Person.where(name: 'Spartacus', rating: 4).exists?
     def exists?(conditions = :none)
+      return false if @none
+
       if Base === conditions
         raise ArgumentError, <<-MSG.squish
           You are passing an instance of ActiveRecord::Base to `exists?`.
@@ -350,10 +375,20 @@ module ActiveRecord
     # compared to the records in memory. If the relation is unloaded, an
     # efficient existence query is performed, as in #exists?.
     def include?(record)
+      # The existing implementation relies on receiving an Active Record instance as the input parameter named record.
+      # Any non-Active Record object passed to this implementation is guaranteed to return `false`.
+      return false unless record.is_a?(klass)
+
       if loaded? || offset_value || limit_value || having_clause.any?
         records.include?(record)
       else
-        record.is_a?(klass) && exists?(record.id)
+        id = if record.class.composite_primary_key?
+          record.class.primary_key.zip(record.id).to_h
+        else
+          record.id
+        end
+
+        exists?(id)
       end
     end
 
@@ -442,10 +477,17 @@ module ActiveRecord
       def find_with_ids(*ids)
         raise UnknownPrimaryKey.new(@klass) if primary_key.nil?
 
-        expects_array = ids.first.kind_of?(Array)
+        expects_array = if klass.composite_primary_key?
+          ids.first.first.is_a?(Array)
+        else
+          ids.first.is_a?(Array)
+        end
+
         return [] if expects_array && ids.first.empty?
 
-        ids = ids.flatten.compact.uniq
+        ids = ids.first if expects_array
+
+        ids = ids.compact.uniq
 
         model_name = @klass.name
 
@@ -469,7 +511,12 @@ module ActiveRecord
           MSG
         end
 
-        relation = where(primary_key => id)
+        relation = if klass.composite_primary_key?
+          where(primary_key.zip(id).to_h)
+        else
+          where(primary_key => id)
+        end
+
         record = relation.take
 
         raise_record_not_found_exception!(id, 0, 1) unless record
@@ -480,7 +527,14 @@ module ActiveRecord
       def find_some(ids)
         return find_some_ordered(ids) unless order_values.present?
 
-        result = where(primary_key => ids).to_a
+        relation = if klass.composite_primary_key?
+          ids.map { |values_set| where(primary_key.zip(values_set).to_h) }.inject(&:or)
+        else
+          where(primary_key => ids)
+        end
+
+        relation = relation.select(table[primary_key]) unless select_values.empty?
+        result = relation.to_a
 
         expected_size =
           if limit_value && ids.size > limit_value
@@ -504,7 +558,14 @@ module ActiveRecord
       def find_some_ordered(ids)
         ids = ids.slice(offset_value || 0, limit_value || ids.size) || []
 
-        result = except(:limit, :offset).where(primary_key => ids).records
+        relation = except(:limit, :offset)
+        relation = if klass.composite_primary_key?
+          ids.map { |values_set| relation.where(primary_key.zip(values_set).to_h) }.inject(&:or)
+        else
+          relation.where(primary_key => ids)
+        end
+        relation = relation.select(table[primary_key]) unless select_values.empty?
+        result = relation.records
 
         if result.size == ids.size
           result.in_order_of(:id, ids.map { |id| @klass.type_for_attribute(primary_key).cast(id) })
@@ -559,10 +620,10 @@ module ActiveRecord
         else
           relation = ordered_relation
 
-          if equal?(relation) || has_limit_or_offset?
+          if relation.order_values.empty? || relation.has_limit_or_offset?
             relation.records[-index]
           else
-            relation.last(index)[-index]
+            relation.reverse_order.offset(index - 1).first
           end
         end
       end
@@ -572,15 +633,24 @@ module ActiveRecord
       end
 
       def ordered_relation
-        if order_values.empty? && (implicit_order_column || primary_key)
-          if implicit_order_column && primary_key && implicit_order_column != primary_key
-            order(table[implicit_order_column].asc, table[primary_key].asc)
-          else
-            order(table[implicit_order_column || primary_key].asc)
-          end
+        if order_values.empty? && (implicit_order_column || !query_constraints_list.nil? || primary_key)
+          order(_order_columns.map { |column| table[column].asc })
         else
           self
         end
       end
+
+      def _order_columns
+        oc = []
+
+        oc << implicit_order_column if implicit_order_column
+        oc << query_constraints_list if query_constraints_list
+
+        if primary_key && query_constraints_list.nil?
+          oc << primary_key
+        end
+
+        oc.flatten.uniq.compact
+      end
   end
 end

data/lib/active_record/relation/merger.rb

@@ -69,6 +69,8 @@ module ActiveRecord
           end
         end
 
+        relation.none! if other.null_relation?
+
         merge_select_values
         merge_multi_values
         merge_single_values

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

@@ -9,7 +9,14 @@ module ActiveRecord
       end
 
       def queries
-        [ associated_table.join_foreign_key => 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
@@ -25,7 +32,7 @@ module ActiveRecord
           when Array
             value.map { |v| convert_to_id(v) }
           else
-            convert_to_id(value)
+            [convert_to_id(value)]
           end
         end
 
@@ -50,6 +57,8 @@ module ActiveRecord
         end
 
         def convert_to_id(value)
+          return primary_key.map { |pk| value.public_send(pk) } if primary_key.is_a?(Array)
+
           if value.respond_to?(primary_key)
             value.public_send(primary_key)
           else

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.table[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

@@ -29,8 +29,8 @@ module ActiveRecord
       attributes.each_with_object([]) do |(key, value), result|
         if value.is_a?(Hash)
           result << Arel.sql(key)
-        elsif key.include?(".")
-          result << Arel.sql(key.split(".").first)
+        elsif (idx = key.rindex("."))
+          result << Arel.sql(key[0, idx])
         end
       end
     end
@@ -77,7 +77,13 @@ module ActiveRecord
         return ["1=0"] if attributes.empty?
 
         attributes.flat_map do |key, value|
-          if value.is_a?(Hash) && !table.has_column?(key)
+          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)
@@ -142,19 +148,25 @@ module ActiveRecord
       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)

data/lib/active_record/relation/query_attribute.rb

@@ -24,7 +24,8 @@ module ActiveRecord
       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)