activerecord 6.0.3.5 → 6.0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81509c096d5c718a2f031bb02276ffa200df9f23f6b95ca4ee001ff4b0ed3f0b
-  data.tar.gz: 171cbbd2a3dea6f8156b6662b47787ff29f0d538d24675321cd48875f7968faa
+  metadata.gz: 7fec0126e47879cb6a18aa720a6cb098befe4ecc7d5cdb59595e08f99269ece7
+  data.tar.gz: 21a1a4c770befd02bd8e00aa0a04c9558ab7bf4a7926f760320e8f3dc44285d6
 SHA512:
-  metadata.gz: b2c8ab3ddce74dcccaa27d4260db49ac55667e9a440c2187a0133ff211ec1305159ee3b74b71009ab59c5908d1d5d50b6be59191dd282d1e2dbf1198465556cc
-  data.tar.gz: f2d64203c46ec1cc691a0b46c3e3e84c602267596bd807f212ef43e285248a0e5051e30a2ae0c34fcd0528fa4856e0d509b3ac65f89b1600b8304aa7a7cb2ca8
+  metadata.gz: faceae264fa37dccdc1ee3f39af6d2c660f8e88eac66510c0783c92c665662b378a37d538fba7ffb466f96a1ab70c7b298659390e9235c7f16acee31e414b11b
+  data.tar.gz: 9de5297a408e922be2ac95cf90781be92aacd80da88a06907be70796a28a890b55dd4d2a5a71bc2110c71c83cc98e564d234091531a4e8678ba662783b7c5891

data/CHANGELOG.md

@@ -1,3 +1,126 @@
+## Rails 6.0.4.1 (August 19, 2021) ##
+
+*   No changes.
+
+
+## Rails 6.0.4 (June 15, 2021) ##
+
+*   Only warn about negative enums if a positive form that would cause conflicts exists.
+
+    Fixes #39065.
+
+    *Alex Ghiculescu*
+
+*   Allow the inverse of a `has_one` association that was previously autosaved to be loaded.
+
+    Fixes #34255.
+
+    *Steven Weber*
+
+*   Reset statement cache for association if `table_name` is changed.
+
+    Fixes #36453.
+
+    *Ryuta Kamizono*
+
+*   Type cast extra select for eager loading.
+
+    *Ryuta Kamizono*
+
+*   Prevent collection associations from being autosaved multiple times.
+
+    Fixes #39173.
+
+    *Eugene Kenny*
+
+*   Resolve issue with insert_all unique_by option when used with expression index.
+
+    When the `:unique_by` option of `ActiveRecord::Persistence.insert_all` and
+    `ActiveRecord::Persistence.upsert_all` was used with the name of an expression index, an error
+    was raised. Adding a guard around the formatting behavior for the `:unique_by` corrects this.
+
+    Usage:
+
+    ```ruby
+    create_table :books, id: :integer, force: true do |t|
+      t.column :name, :string
+      t.index "lower(name)", unique: true
+    end
+
+    Book.insert_all [{ name: "MyTest" }], unique_by: :index_books_on_lower_name
+    ```
+
+    Fixes #39516.
+
+    *Austen Madden*
+
+*   Fix preloading for polymorphic association with custom scope.
+
+    *Ryuta Kamizono*
+
+*   Allow relations with different SQL comments in the `or` method.
+
+    *Takumi Shotoku*
+
+*   Resolve conflict between counter cache and optimistic locking.
+
+    Bump an Active Record instance's lock version after updating its counter
+    cache. This avoids raising an unnecessary `ActiveRecord::StaleObjectError`
+    upon subsequent transactions by maintaining parity with the corresponding
+    database record's `lock_version` column.
+
+    Fixes #16449.
+
+    *Aaron Lipman*
+
+*   Fix through association with source/through scope which has joins.
+
+    *Ryuta Kamizono*
+
+*   Fix through association to respect source scope for includes/preload.
+
+    *Ryuta Kamizono*
+
+*   Fix eager load with Arel joins to maintain the original joins order.
+
+    *Ryuta Kamizono*
+
+*   Fix group by count with eager loading + order + limit/offset.
+
+    *Ryuta Kamizono*
+
+*   Fix left joins order when merging multiple left joins from different associations.
+
+    *Ryuta Kamizono*
+
+*   Fix index creation to preserve index comment in bulk change table on MySQL.
+
+    *Ryuta Kamizono*
+
+*   Change `remove_foreign_key` to not check `:validate` option if database
+    doesn't support the feature.
+
+    *Ryuta Kamizono*
+
+*   Fix the result of aggregations to maintain duplicated "group by" fields.
+
+    *Ryuta Kamizono*
+
+*   Do not return duplicated records when using preload.
+
+    *Bogdan Gusiev*
+
+
+## Rails 6.0.3.7 (May 05, 2021) ##
+
+*   No changes.
+
+
+## Rails 6.0.3.6 (March 26, 2021) ##
+
+*   No changes.
+
+
 ## Rails 6.0.3.5 (February 10, 2021) ##
 
 *   Fix possible DoS vector in PostgreSQL money type

data/README.rdoc

@@ -194,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/master/activerecord
+* https://github.com/rails/rails/tree/main/activerecord
 
 
 == License

data/lib/active_record/associations/association.rb

@@ -204,14 +204,13 @@ module ActiveRecord
           scope = self.scope
           return scope.to_a if skip_statement_cache?(scope)
 
-          conn = klass.connection
-          sc = reflection.association_scope_cache(conn, owner) do |params|
+          sc = reflection.association_scope_cache(klass, owner) do |params|
             as = AssociationScope.create { params.bind }
             target_scope.merge!(as.scope(self))
           end
 
           binds = AssociationScope.get_bind_values(owner, reflection.chain)
-          sc.execute(binds, conn) { |record| set_inverse_instance(record) } || []
+          sc.execute(binds, klass.connection) { |record| set_inverse_instance(record) } || []
         end
 
         # The scope for this association.

data/lib/active_record/associations/association_scope.rb

@@ -52,7 +52,7 @@ module ActiveRecord
         attr_reader :value_transformation
 
         def join(table, constraint)
-          table.create_join(table, table.create_on(constraint))
+          table.create_join(table, table.create_on(constraint), Arel::Nodes::LeadingJoin)
         end
 
         def last_chain_scope(scope, reflection, owner)
@@ -134,6 +134,12 @@ 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

data/lib/active_record/associations/collection_association.rb

@@ -332,6 +332,13 @@ module ActiveRecord
           persisted + memory
         end
 
+        def build_record(attributes)
+          previous = klass.current_scope(true) if block_given?
+          super
+        ensure
+          klass.current_scope = previous if previous
+        end
+
         def _create_record(attributes, raise = false, &block)
           unless owner.persisted?
             raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"

data/lib/active_record/associations/collection_proxy.rb

@@ -51,6 +51,7 @@ module ActiveRecord
       def loaded?
         @association.loaded?
       end
+      alias :loaded :loaded?
 
       ##
       # :method: select

data/lib/active_record/associations/join_dependency.rb

@@ -106,8 +106,16 @@ module ActiveRecord
         model_cache = Hash.new { |h, klass| h[klass] = {} }
         parents = model_cache[join_root]
 
-        column_aliases = aliases.column_aliases join_root
-        column_aliases += explicit_selections(column_aliases, result_set)
+        column_aliases = aliases.column_aliases(join_root)
+        column_names = explicit_selections(column_aliases, result_set)
+
+        if column_names.empty?
+          column_types = {}
+        else
+          column_types = result_set.column_types
+          column_types = column_types.slice(*column_names) unless column_types.empty?
+          column_aliases += column_names.map! { |name| Aliases::Column.new(name, name) }
+        end
 
         message_bus = ActiveSupport::Notifications.instrumenter
 
@@ -119,7 +127,7 @@ module ActiveRecord
         message_bus.instrument("instantiation.active_record", payload) do
           result_set.each { |row_hash|
             parent_key = primary_key ? row_hash[primary_key] : row_hash
-            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, &block)
+            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, column_types, &block)
             construct(parent, join_root, row_hash, seen, model_cache)
           }
         end
@@ -139,9 +147,9 @@ module ActiveRecord
 
         def explicit_selections(root_column_aliases, result_set)
           root_names = root_column_aliases.map(&:name).to_set
-          result_set.columns
-            .reject { |n| root_names.include?(n) || n =~ /\At\d+_r\d+\z/ }
-            .map { |n| Aliases::Column.new(n, n) }
+          result_set.columns.each_with_object([]) do |name, result|
+            result << name unless /\At\d+_r\d+\z/.match?(name) || root_names.include?(name)
+          end
         end
 
         def aliases

data/lib/active_record/associations/join_dependency/join_association.rb

@@ -33,6 +33,13 @@ module ActiveRecord
 
             join_scope = reflection.join_scope(table, foreign_table, foreign_klass)
 
+            unless join_scope.references_values.empty?
+              join_dependency = join_scope.construct_join_dependency(
+                join_scope.eager_load_values | join_scope.includes_values, Arel::Nodes::OuterJoin
+              )
+              join_scope.joins!(join_dependency)
+            end
+
             arel = join_scope.arel(alias_tracker.aliases)
             nodes = arel.constraints.first
 

data/lib/active_record/associations/join_dependency/join_part.rb

@@ -62,8 +62,8 @@ module ActiveRecord
           hash
         end
 
-        def instantiate(row, aliases, &block)
-          base_klass.instantiate(extract_record(row, aliases), &block)
+        def instantiate(row, aliases, column_types = {}, &block)
+          base_klass.instantiate(extract_record(row, aliases), column_types, &block)
         end
       end
     end

data/lib/active_record/associations/preloader.rb

@@ -94,6 +94,10 @@ module ActiveRecord
         end
       end
 
+      def initialize(associate_by_default: true)
+        @associate_by_default = associate_by_default
+      end
+
       private
         # Loads all the given data into +records+ for the +association+.
         def preloaders_on(association, records, scope, polymorphic_parent = false)
@@ -142,7 +146,7 @@ module ActiveRecord
 
         def preloaders_for_reflection(reflection, records, scope)
           records.group_by { |record| record.association(reflection.name).klass }.map do |rhs_klass, rs|
-            preloader_for(reflection, rs).new(rhs_klass, rs, reflection, scope).run
+            preloader_for(reflection, rs).new(rhs_klass, rs, reflection, scope, @associate_by_default).run
           end
         end
 
@@ -157,7 +161,7 @@ module ActiveRecord
         end
 
         class AlreadyLoaded # :nodoc:
-          def initialize(klass, owners, reflection, preload_scope)
+          def initialize(klass, owners, reflection, preload_scope, associate_by_default = true)
             @owners = owners
             @reflection = reflection
           end

data/lib/active_record/associations/preloader/association.rb

@@ -4,46 +4,62 @@ module ActiveRecord
   module Associations
     class Preloader
       class Association #:nodoc:
-        def initialize(klass, owners, reflection, preload_scope)
+        def initialize(klass, owners, reflection, preload_scope, associate_by_default = true)
           @klass         = klass
-          @owners        = owners
+          @owners        = owners.uniq(&:__id__)
           @reflection    = reflection
           @preload_scope = preload_scope
+          @associate     = associate_by_default || !preload_scope || preload_scope.empty_scope?
           @model         = owners.first && owners.first.class
         end
 
         def run
-          if !preload_scope || preload_scope.empty_scope?
-            owners.each do |owner|
-              associate_records_to_owner(owner, records_by_owner[owner] || [])
-            end
-          else
-            # Custom preload scope is used and
-            # the association can not be marked as loaded
-            # Loading into a Hash instead
-            records_by_owner
-          end
+          records = records_by_owner
+
+          owners.each do |owner|
+            associate_records_to_owner(owner, records[owner] || [])
+          end if @associate
+
           self
         end
 
         def records_by_owner
-          # owners can be duplicated when a relation has a collection association join
-          # #compare_by_identity makes such owners different hash keys
-          @records_by_owner ||= preloaded_records.each_with_object({}.compare_by_identity) do |record, result|
-            owners_by_key[convert_key(record[association_key_name])].each do |owner|
-              (result[owner] ||= []) << record
-            end
-          end
+          load_records unless defined?(@records_by_owner)
+
+          @records_by_owner
         end
 
         def preloaded_records
-          return @preloaded_records if defined?(@preloaded_records)
-          @preloaded_records = owner_keys.empty? ? [] : records_for(owner_keys)
+          load_records unless defined?(@preloaded_records)
+
+          @preloaded_records
         end
 
         private
           attr_reader :owners, :reflection, :preload_scope, :model, :klass
 
+          def load_records
+            # owners can be duplicated when a relation has a collection association join
+            # #compare_by_identity makes such owners different hash keys
+            @records_by_owner = {}.compare_by_identity
+            raw_records = owner_keys.empty? ? [] : records_for(owner_keys)
+
+            @preloaded_records = raw_records.select do |record|
+              assignments = []
+
+              owners_by_key[convert_key(record[association_key_name])].each do |owner|
+                entries = (@records_by_owner[owner] ||= [])
+
+                if reflection.collection? || entries.empty?
+                  entries << record
+                  assignments << record
+                end
+              end
+
+              !assignments.empty?
+            end
+          end
+
           # The name of the key on the associated records
           def association_key_name
             reflection.join_primary_key(klass)
@@ -113,7 +129,9 @@ module ActiveRecord
           end
 
           def reflection_scope
-            @reflection_scope ||= reflection.scope ? reflection.scope_for(klass.unscoped) : klass.unscoped
+            @reflection_scope ||= begin
+              reflection.join_scopes(klass.arel_table, klass.predicate_builder, klass).inject(&:merge!) || klass.unscoped
+            end
           end
 
           def build_scope
@@ -123,7 +141,7 @@ module ActiveRecord
               scope.where!(reflection.type => model.polymorphic_name)
             end
 
-            scope.merge!(reflection_scope) if reflection.scope
+            scope.merge!(reflection_scope) unless reflection_scope.empty_scope?
             scope.merge!(preload_scope) if preload_scope
             scope
           end

data/lib/active_record/associations/preloader/through_association.rb

@@ -4,7 +4,7 @@ module ActiveRecord
   module Associations
     class Preloader
       class ThroughAssociation < Association # :nodoc:
-        PRELOADER = ActiveRecord::Associations::Preloader.new
+        PRELOADER = ActiveRecord::Associations::Preloader.new(associate_by_default: false)
 
         def initialize(*)
           super

data/lib/active_record/associations/through_association.rb

@@ -32,7 +32,7 @@ module ActiveRecord
           reflection.chain.drop(1).each do |reflection|
             relation = reflection.klass.scope_for_association
             scope.merge!(
-              relation.except(:select, :create_with, :includes, :preload, :joins, :eager_load)
+              relation.except(:select, :create_with, :includes, :preload, :eager_load, :joins, :left_outer_joins)
             )
           end
           scope

data/lib/active_record/autosave_association.rb

@@ -29,7 +29,7 @@ module ActiveRecord
   # == Callbacks
   #
   # Association with autosave option defines several callbacks on your
-  # model (before_save, after_create, after_update). Please note that
+  # model (around_save, before_save, after_create, after_update). Please note that
   # callbacks are executed in the order they were defined in
   # model. You should avoid modifying the association content, before
   # autosave callbacks are executed. Placing your callbacks after
@@ -180,8 +180,7 @@ module ActiveRecord
           save_method = :"autosave_associated_records_for_#{reflection.name}"
 
           if reflection.collection?
-            before_save :before_save_collection_association
-            after_save :after_save_collection_association
+            around_save :around_save_collection_association
 
             define_non_cyclic_method(save_method) { save_collection_association(reflection) }
             # Doesn't use after_save as that would save associations added in after_create/after_update twice
@@ -358,14 +357,15 @@ module ActiveRecord
         end
       end
 
-      # Is used as a before_save callback to check while saving a collection
+      # Is used as an around_save callback to check while saving a collection
       # association whether or not the parent was a new record before saving.
-      def before_save_collection_association
-        @new_record_before_save ||= new_record?
-      end
+      def around_save_collection_association
+        previously_new_record_before_save = (@new_record_before_save ||= false)
+        @new_record_before_save = !previously_new_record_before_save && new_record?
 
-      def after_save_collection_association
-        @new_record_before_save = false
+        yield
+      ensure
+        @new_record_before_save = previously_new_record_before_save
       end
 
       # Saves any new associated records, or all loaded autosave associations if
@@ -444,7 +444,7 @@ module ActiveRecord
               unless reflection.through_reflection
                 record[reflection.foreign_key] = key
                 if inverse_reflection = reflection.inverse_of
-                  record.association(inverse_reflection.name).loaded!
+                  record.association(inverse_reflection.name).inversed_from(self)
                 end
               end