activerecord 5.2.3 → 6.1.0

data/MIT-LICENSE

@@ -1,4 +1,6 @@
-Copyright (c) 2004-2018 David Heinemeier Hansson
+Copyright (c) 2004-2020 David Heinemeier Hansson
+
+Arel originally copyright (c) 2007-2016 Nick Kallen, Bryan Helmkamp, Emilio Tagua, Aaron Patterson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -13,6 +13,8 @@ columns. Although these mappings can be defined explicitly, it's recommended
 to follow naming conventions, especially when getting started with the
 library.
 
+You can read more about Active Record in the {Active Record Basics}[https://edgeguides.rubyonrails.org/active_record_basics.html] guide.
+
 A short rundown of some of the major features:
 
 * Automated mapping between classes and tables, attributes and columns.
@@ -130,7 +132,7 @@ This would also define the following accessors: <tt>Product#name</tt> and
   SQLite3[link:classes/ActiveRecord/ConnectionAdapters/SQLite3Adapter.html].
 
 
-* Logging support for Log4r[https://github.com/colbygk/log4r] and Logger[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc].
+* Logging support for Log4r[https://github.com/colbygk/log4r] and Logger[https://ruby-doc.org/stdlib/libdoc/logger/rdoc/].
 
     ActiveRecord::Base.logger = ActiveSupport::Logger.new(STDOUT)
     ActiveRecord::Base.logger = Log4r::Logger.new('Application Log')
@@ -138,7 +140,7 @@ This would also define the following accessors: <tt>Product#name</tt> and
 
 * Database agnostic schema management with Migrations.
 
-    class AddSystemSettings < ActiveRecord::Migration[5.0]
+    class AddSystemSettings < ActiveRecord::Migration[6.0]
       def up
         create_table :system_settings do |t|
           t.string  :name
@@ -192,7 +194,7 @@ The latest version of Active Record can be installed with RubyGems:
 
 Source code can be downloaded as part of the Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/5-2-stable/activerecord
+* https://github.com/rails/rails/tree/master/activerecord
 
 
 == License
@@ -206,7 +208,7 @@ Active Record is released under the MIT license:
 
 API documentation is at:
 
-* http://api.rubyonrails.org
+* https://api.rubyonrails.org
 
 Bug reports for the Ruby on Rails project can be filed here:
 
@@ -214,4 +216,4 @@ Bug reports for the Ruby on Rails project can be filed here:
 
 Feature requests should be discussed on the rails-core mailing list here:
 
-* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
+* https://discuss.rubyonrails.org/c/rubyonrails-core

data/examples/performance.rb

@@ -176,7 +176,7 @@ Benchmark.ips(TIME) do |x|
   end
 
   x.report "Model.log" do
-    Exhibit.connection.send(:log, "hello", "world") {}
+    Exhibit.connection.send(:log, "hello", "world") { }
   end
 
   x.report "AR.execute(query)" do

data/lib/active_record/aggregations.rb

@@ -3,8 +3,6 @@
 module ActiveRecord
   # See ActiveRecord::Aggregations::ClassMethods for documentation
   module Aggregations
-    extend ActiveSupport::Concern
-
     def initialize_dup(*) # :nodoc:
       @aggregation_cache = {}
       super
@@ -16,7 +14,6 @@ module ActiveRecord
     end
 
     private
-
       def clear_aggregation_cache
         @aggregation_cache.clear if persisted?
       end
@@ -144,7 +141,7 @@ module ActiveRecord
       # converted to an instance of value class if necessary.
       #
       # For example, the +NetworkResource+ model has +network_address+ and +cidr_range+ attributes that should be
-      # aggregated using the +NetAddr::CIDR+ value class (http://www.rubydoc.info/gems/netaddr/1.5.0/NetAddr/CIDR).
+      # aggregated using the +NetAddr::CIDR+ value class (https://www.rubydoc.info/gems/netaddr/1.5.0/NetAddr/CIDR).
       # The constructor for the value class is called +create+ and it expects a CIDR address string as a parameter.
       # New values can be assigned to the value object using either another +NetAddr::CIDR+ object, a string
       # or an array. The <tt>:constructor</tt> and <tt>:converter</tt> options can be used to meet
@@ -225,6 +222,10 @@ module ActiveRecord
         def composed_of(part_id, options = {})
           options.assert_valid_keys(:class_name, :mapping, :allow_nil, :constructor, :converter)
 
+          unless self < Aggregations
+            include Aggregations
+          end
+
           name        = part_id.id2name
           class_name  = options[:class_name]  || name.camelize
           mapping     = options[:mapping]     || [ name, name ]

data/lib/active_record/association_relation.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveRecord
-  class AssociationRelation < Relation
-    def initialize(klass, association)
+  class AssociationRelation < Relation # :nodoc:
+    def initialize(klass, association, **)
       super(klass)
       @association = association
     end
@@ -15,20 +15,30 @@ module ActiveRecord
       other == records
     end
 
-    def build(*args, &block)
-      scoping { @association.build(*args, &block) }
-    end
-    alias new build
-
-    def create(*args, &block)
-      scoping { @association.create(*args, &block) }
-    end
+    %w(insert insert_all insert! insert_all! upsert upsert_all).each do |method|
+      class_eval <<~RUBY
+        def #{method}(attributes, **kwargs)
+          if @association.reflection.through_reflection?
+            raise ArgumentError, "Bulk insert or upsert is currently not supported for has_many through association"
+          end
 
-    def create!(*args, &block)
-      scoping { @association.create!(*args, &block) }
+          scoping { klass.#{method}(attributes, **kwargs) }
+        end
+      RUBY
     end
 
     private
+      def _new(attributes, &block)
+        @association.build(attributes, &block)
+      end
+
+      def _create(attributes, &block)
+        @association.create(attributes, &block)
+      end
+
+      def _create!(attributes, &block)
+        @association.create!(attributes, &block)
+      end
 
       def exec_queries
         super do |record|

data/lib/active_record/associations/alias_tracker.rb

@@ -6,9 +6,14 @@ module ActiveRecord
   module Associations
     # Keeps track of table aliases for ActiveRecord::Associations::JoinDependency
     class AliasTracker # :nodoc:
-      def self.create(connection, initial_table, joins)
+      def self.create(connection, initial_table, joins, aliases = nil)
         if joins.empty?
-          aliases = Hash.new(0)
+          aliases ||= Hash.new(0)
+        elsif aliases
+          default_proc = aliases.default_proc || proc { 0 }
+          aliases.default_proc = proc { |h, k|
+            h[k] = initial_count_for(connection, k, joins) + default_proc.call(h, k)
+          }
         else
           aliases = Hash.new { |h, k|
             h[k] = initial_count_for(connection, k, joins)
@@ -32,8 +37,6 @@ module ActiveRecord
             ).size
           elsif join.is_a?(Arel::Nodes::Join)
             join.left.name == name ? 1 : 0
-          elsif join.is_a?(Hash)
-            join[name]
           else
             raise ArgumentError, "joins list should be initialized by list of Arel::Nodes::Join"
           end
@@ -48,31 +51,31 @@ module ActiveRecord
         @connection = connection
       end
 
-      def aliased_table_for(table_name, aliased_name, type_caster)
-        if aliases[table_name].zero?
+      def aliased_table_for(arel_table, table_name = nil)
+        table_name ||= arel_table.name
+
+        if aliases[table_name] == 0
           # If it's zero, we can have our table_name
           aliases[table_name] = 1
-          Arel::Table.new(table_name, type_caster: type_caster)
+          arel_table = arel_table.alias(table_name) if arel_table.name != table_name
         else
           # Otherwise, we need to use an alias
-          aliased_name = @connection.table_alias_for(aliased_name)
+          aliased_name = @connection.table_alias_for(yield)
 
           # Update the count
-          aliases[aliased_name] += 1
+          count = aliases[aliased_name] += 1
 
-          table_alias = if aliases[aliased_name] > 1
-            "#{truncate(aliased_name)}_#{aliases[aliased_name]}"
-          else
-            aliased_name
-          end
-          Arel::Table.new(table_name, type_caster: type_caster).alias(table_alias)
+          aliased_name = "#{truncate(aliased_name)}_#{count}" if count > 1
+
+          arel_table = arel_table.alias(aliased_name)
         end
+
+        arel_table
       end
 
       attr_reader :aliases
 
       private
-
         def truncate(name)
           name.slice(0, @connection.table_alias_length - 2)
         end

data/lib/active_record/associations/association.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/array/wrap"
-
 module ActiveRecord
   module Associations
     # = Active Record Associations
@@ -17,6 +15,23 @@ module ActiveRecord
     #     CollectionAssociation
     #       HasManyAssociation + ForeignAssociation
     #         HasManyThroughAssociation + ThroughAssociation
+    #
+    # Associations in Active Record are middlemen between the object that
+    # holds the association, known as the <tt>owner</tt>, and the associated
+    # result set, known as the <tt>target</tt>. Association metadata is available in
+    # <tt>reflection</tt>, which is an instance of <tt>ActiveRecord::Reflection::AssociationReflection</tt>.
+    #
+    # For example, given
+    #
+    #   class Blog < ActiveRecord::Base
+    #     has_many :posts
+    #   end
+    #
+    #   blog = Blog.first
+    #
+    # The association of <tt>blog.posts</tt> has the object +blog+ as its
+    # <tt>owner</tt>, the collection of its posts as <tt>target</tt>, and
+    # the <tt>reflection</tt> object represents a <tt>:has_many</tt> macro.
     class Association #:nodoc:
       attr_reader :owner, :target, :reflection
 
@@ -39,8 +54,14 @@ module ActiveRecord
         @inversed = false
       end
 
+      def reset_negative_cache # :nodoc:
+        reset if loaded? && target.nil?
+      end
+
       # Reloads the \target and returns +self+ on success.
-      def reload
+      # The QueryCache is cleared if +force+ is true.
+      def reload(force = false)
+        klass.connection.clear_query_cache if force && klass
         reset
         reset_scope
         load_target
@@ -76,18 +97,10 @@ module ActiveRecord
       end
 
       def scope
-        target_scope.merge!(association_scope)
-      end
-
-      # The scope for this association.
-      #
-      # Note that the association_scope is merged into the target_scope only when the
-      # scope method is called. This is because at that point the call may be surrounded
-      # by scope.scoping { ... } or with_scope { ... } etc, which affects the scope which
-      # actually gets built.
-      def association_scope
-        if klass
-          @association_scope ||= AssociationScope.scope(self)
+        if (scope = klass.current_scope) && scope.try(:proxy_association) == self
+          scope.spawn
+        else
+          target_scope.merge!(association_scope)
         end
       end
 
@@ -121,7 +134,15 @@ module ActiveRecord
         self.target = record
         @inversed = !!record
       end
-      alias :inversed_from_queries :inversed_from
+
+      def inversed_from_queries(record)
+        if inversable?(record)
+          self.target = record
+          @inversed = true
+        else
+          @inversed = false
+        end
+      end
 
       # Returns the class of the target. belongs_to polymorphic overrides this to look at the
       # polymorphic_type field on the owner.
@@ -129,12 +150,6 @@ module ActiveRecord
         reflection.klass
       end
 
-      # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
-      # through association's scope)
-      def target_scope
-        AssociationRelation.create(klass, self).merge!(klass.all)
-      end
-
       def extensions
         extensions = klass.default_extensions | reflection.extensions
 
@@ -186,40 +201,60 @@ module ActiveRecord
         set_inverse_instance(record)
       end
 
-      def create(attributes = {}, &block)
+      def create(attributes = nil, &block)
         _create_record(attributes, &block)
       end
 
-      def create!(attributes = {}, &block)
+      def create!(attributes = nil, &block)
         _create_record(attributes, true, &block)
       end
 
       private
-        def scope_for_create
-          scope.scope_for_create
-        end
+        def find_target
+          if owner.strict_loading? && owner.validation_context.nil?
+            Base.strict_loading_violation!(owner: owner.class, association: klass)
+          end
 
-        def find_target?
-          !loaded? && (!owner.new_record? || foreign_key_present?) && klass
-        end
+          if reflection.strict_loading? && owner.validation_context.nil?
+            Base.strict_loading_violation!(owner: owner.class, association: reflection.name)
+          end
+
+          scope = self.scope
+          return scope.to_a if skip_statement_cache?(scope)
 
-        def creation_attributes
-          attributes = {}
+          sc = reflection.association_scope_cache(klass, owner) do |params|
+            as = AssociationScope.create { params.bind }
+            target_scope.merge!(as.scope(self))
+          end
 
-          if (reflection.has_one? || reflection.collection?) && !options[:through]
-            attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
+          binds = AssociationScope.get_bind_values(owner, reflection.chain)
+          sc.execute(binds, klass.connection) { |record| set_inverse_instance(record) }
+        end
 
-            if reflection.type
-              attributes[reflection.type] = owner.class.polymorphic_name
-            end
+        # The scope for this association.
+        #
+        # Note that the association_scope is merged into the target_scope only when the
+        # scope method is called. This is because at that point the call may be surrounded
+        # by scope.scoping { ... } or unscoped { ... } etc, which affects the scope which
+        # actually gets built.
+        def association_scope
+          if klass
+            @association_scope ||= AssociationScope.scope(self)
           end
+        end
 
-          attributes
+        # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
+        # through association's scope)
+        def target_scope
+          AssociationRelation.create(klass, self).merge!(klass.scope_for_association)
         end
 
-        # Sets the owner attributes on the given record
-        def set_owner_attributes(record)
-          creation_attributes.each { |key, value| record[key] = value }
+        def scope_for_create
+          scope.scope_for_create
+        end
+
+        def find_target?
+          !loaded? && (!owner.new_record? || foreign_key_present?) && klass
         end
 
         # Returns true if there is a foreign key present on the owner which
@@ -269,7 +304,7 @@ module ActiveRecord
 
         # Returns true if record contains the foreign_key
         def foreign_key_for?(record)
-          record.has_attribute?(reflection.foreign_key)
+          record._has_attribute?(reflection.foreign_key)
         end
 
         # This should be implemented to return the values of the relevant key(s) on the owner,
@@ -294,6 +329,24 @@ module ActiveRecord
             klass.scope_attributes? ||
             reflection.source_reflection.active_record.default_scopes.any?
         end
+
+        def enqueue_destroy_association(options)
+          owner.class.destroy_association_async_job&.perform_later(**options)
+        end
+
+        def inversable?(record)
+          record &&
+            ((!record.persisted? || !owner.persisted?) || matches_foreign_key?(record))
+        end
+
+        def matches_foreign_key?(record)
+          if foreign_key_for?(record)
+            record.read_attribute(reflection.foreign_key) == owner.id ||
+              (foreign_key_for?(owner) && owner.read_attribute(reflection.foreign_key) == record.id)
+          else
+            owner.read_attribute(reflection.foreign_key) == record.id
+          end
+        end
     end
   end
 end

data/lib/active_record/associations/association_scope.rb

@@ -26,7 +26,9 @@ module ActiveRecord
         chain = get_chain(reflection, association, scope.alias_tracker)
 
         scope.extending! reflection.extensions
-        add_constraints(scope, owner, chain)
+        scope = add_constraints(scope, owner, chain)
+        scope.limit!(1) unless reflection.collection?
+        scope
       end
 
       def self.get_bind_values(owner, chain)
@@ -46,25 +48,20 @@ module ActiveRecord
         binds
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-
+      private
         attr_reader :value_transformation
 
-      private
         def join(table, constraint)
-          table.create_join(table, table.create_on(constraint))
+          Arel::Nodes::LeadingJoin.new(table, Arel::Nodes::On.new(constraint))
         end
 
         def last_chain_scope(scope, reflection, owner)
-          join_keys = reflection.join_keys
-          key = join_keys.key
-          foreign_key = join_keys.foreign_key
+          primary_key = reflection.join_primary_key
+          foreign_key = reflection.join_foreign_key
 
           table = reflection.aliased_table
           value = transform_value(owner[foreign_key])
-          scope = apply_scope(scope, table, key, value)
+          scope = apply_scope(scope, table, primary_key, value)
 
           if reflection.type
             polymorphic_type = transform_value(owner.class.polymorphic_name)
@@ -79,13 +76,12 @@ module ActiveRecord
         end
 
         def next_chain_scope(scope, reflection, next_reflection)
-          join_keys = reflection.join_keys
-          key = join_keys.key
-          foreign_key = join_keys.foreign_key
+          primary_key = reflection.join_primary_key
+          foreign_key = reflection.join_foreign_key
 
           table = reflection.aliased_table
           foreign_table = next_reflection.aliased_table
-          constraint = table[key].eq(foreign_table[foreign_key])
+          constraint = table[primary_key].eq(foreign_table[foreign_key])
 
           if reflection.type
             value = transform_value(next_reflection.klass.polymorphic_name)
@@ -110,11 +106,9 @@ module ActiveRecord
           name = reflection.name
           chain = [Reflection::RuntimeReflection.new(reflection, association)]
           reflection.chain.drop(1).each do |refl|
-            aliased_table = tracker.aliased_table_for(
-              refl.table_name,
-              refl.alias_candidate(name),
-              refl.klass.type_caster
-            )
+            aliased_table = tracker.aliased_table_for(refl.klass.arel_table) do
+              refl.alias_candidate(name)
+            end
             chain << ReflectionProxy.new(refl, aliased_table)
           end
           chain
@@ -136,10 +130,16 @@ module ActiveRecord
 
               if scope_chain_item == chain_head.scope
                 scope.merge! item.except(:where, :includes, :unscope, :order)
+              elsif !item.references_values.empty?
+                join_dependency = item.construct_join_dependency(
+                  item.eager_load_values | item.includes_values, Arel::Nodes::OuterJoin
+                )
+                scope.joins!(*item.joins_values, join_dependency)
+                scope.left_outer_joins!(*item.left_outer_joins_values)
               end
 
               reflection.all_includes do
-                scope.includes! item.includes_values
+                scope.includes_values |= item.includes_values
               end
 
               scope.unscope!(*item.unscope_values)

data/lib/active_record/associations/belongs_to_association.rb

@@ -11,26 +11,23 @@ module ActiveRecord
         when :destroy
           target.destroy
           raise ActiveRecord::Rollback unless target.destroyed?
+        when :destroy_async
+          id = owner.public_send(reflection.foreign_key.to_sym)
+          primary_key_column = reflection.active_record_primary_key.to_sym
+
+          enqueue_destroy_association(
+            owner_model_name: owner.class.to_s,
+            owner_id: owner.id,
+            association_class: reflection.klass.to_s,
+            association_ids: [id],
+            association_primary_key_column: primary_key_column,
+            ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)
+          )
         else
-          target.send(options[:dependent])
+          target.public_send(options[:dependent])
         end
       end
 
-      def replace(record)
-        if record
-          raise_on_type_mismatch!(record)
-          update_counters_on_replace(record)
-          set_inverse_instance(record)
-          @updated = true
-        else
-          decrement_counters
-        end
-
-        replace_keys(record)
-
-        self.target = record
-      end
-
       def inversed_from(record)
         replace_keys(record)
         super
@@ -49,30 +46,60 @@ module ActiveRecord
         @updated
       end
 
-      def decrement_counters # :nodoc:
+      def decrement_counters
         update_counters(-1)
       end
 
-      def increment_counters # :nodoc:
+      def increment_counters
         update_counters(1)
       end
 
+      def decrement_counters_before_last_save
+        if reflection.polymorphic?
+          model_was = owner.attribute_before_last_save(reflection.foreign_type)&.constantize
+        else
+          model_was = klass
+        end
+
+        foreign_key_was = owner.attribute_before_last_save(reflection.foreign_key)
+
+        if foreign_key_was && model_was < ActiveRecord::Base
+          update_counters_via_scope(model_was, foreign_key_was, -1)
+        end
+      end
+
       def target_changed?
         owner.saved_change_to_attribute?(reflection.foreign_key)
       end
 
       private
+        def replace(record)
+          if record
+            raise_on_type_mismatch!(record)
+            set_inverse_instance(record)
+            @updated = true
+          end
+
+          replace_keys(record)
+
+          self.target = record
+        end
 
         def update_counters(by)
           if require_counter_update? && foreign_key_present?
             if target && !stale_target?
               target.increment!(reflection.counter_cache_column, by, touch: reflection.options[:touch])
             else
-              klass.update_counters(target_id, reflection.counter_cache_column => by, touch: reflection.options[:touch])
+              update_counters_via_scope(klass, owner._read_attribute(reflection.foreign_key), by)
             end
           end
         end
 
+        def update_counters_via_scope(klass, foreign_key, by)
+          scope = klass.unscoped.where!(primary_key(klass) => foreign_key)
+          scope.update_counters(reflection.counter_cache_column => by, touch: reflection.options[:touch])
+        end
+
         def find_target?
           !loaded? && foreign_key_present? && klass
         end
@@ -81,44 +108,21 @@ module ActiveRecord
           reflection.counter_cache_column && owner.persisted?
         end
 
-        def update_counters_on_replace(record)
-          if require_counter_update? && different_target?(record)
-            owner.instance_variable_set :@_after_replace_counter_called, true
-            record.increment!(reflection.counter_cache_column, touch: reflection.options[:touch])
-            decrement_counters
-          end
-        end
-
-        # Checks whether record is different to the current target, without loading it
-        def different_target?(record)
-          record._read_attribute(primary_key(record)) != owner._read_attribute(reflection.foreign_key)
-        end
-
         def replace_keys(record)
-          owner[reflection.foreign_key] = record ? record._read_attribute(primary_key(record)) : nil
+          owner[reflection.foreign_key] = record ? record._read_attribute(primary_key(record.class)) : nil
         end
 
-        def primary_key(record)
-          reflection.association_primary_key(record.class)
+        def primary_key(klass)
+          reflection.association_primary_key(klass)
         end
 
         def foreign_key_present?
           owner._read_attribute(reflection.foreign_key)
         end
 
-        # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
-        # has_one associations.
         def invertible_for?(record)
           inverse = inverse_reflection_for(record)
-          inverse && inverse.has_one?
-        end
-
-        def target_id
-          if options[:primary_key]
-            owner.send(reflection.name).try(:id)
-          else
-            owner._read_attribute(reflection.foreign_key)
-          end
+          inverse && (inverse.has_one? || ActiveRecord::Base.has_many_inversing)
         end
 
         def stale_state