activerecord 6.0.3.6 → 6.0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10483d65f664af6e16b8846c4e732c1684ccce361c7f5de71174d4c58667d7f0
-  data.tar.gz: b8e115b38be1bb8a9cfd2b405d5be96c21c7a1b402e63280ad1cef7d495e0cd9
+  metadata.gz: 88afaa50cc998c6a17ae5d4685b6b347c05a04360ac54f8130a9a08f4933136b
+  data.tar.gz: bfd6b05fcaf68e62f9e99d2d0be51ce298805ab3f34151449b0fd1fa6d93e87c
 SHA512:
-  metadata.gz: 870e5ab273716a3b06ab68e5b18bf107cb8dfbba027df6c4c021628b7a5384c38b44d60a97df83da109aca4df075394ae88e8f8f76a61a63182fa2055b51a012
-  data.tar.gz: 1371263b37deb82f2f8af79399c9bfa955bfc819930779136de843caf0266cb3da913b2b8709c0fbf841478ef663fe9a7d8e1f6025909c7d630ab9e7b337fb00
+  metadata.gz: 6ad949a111141d5dd29f74d7667002ca24797b00ab3b299be58b7360fc662d9350333b462f3a5bd65e1e63ebfc61542ba748bb9c68fb417e75e257a3f52c81f0
+  data.tar.gz: 2ed993c948432001d6917b7c89b182e360bdd47db27aadcdd6a979720ebe9a9c33c26a3aaa18b449720859ad6606a038f1114a089e4bcd6793f68e8cb24f288b

data/CHANGELOG.md

@@ -1,3 +1,126 @@
+## Rails 6.0.4.2 (December 14, 2021) ##
+
+*   No changes.
+
+
+## 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.

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/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/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/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/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/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
 

data/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -1035,6 +1035,12 @@ module ActiveRecord
       # In some cases you may want to prevent writes to the database
       # even if you are on a database that can write. `while_preventing_writes`
       # will prevent writes to the database for the duration of the block.
+      #
+      # This method does not provide the same protection as a readonly
+      # user and is meant to be a safeguard against accidental writes.
+      #
+      # See `READ_QUERY` for the queries that are blocked by this
+      # method.
       def while_preventing_writes(enabled = true)
         original, self.prevent_writes = self.prevent_writes, enabled
         yield

data/lib/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -63,6 +63,10 @@ module ActiveRecord
           end
         CODE
       end
+
+      def aliased_types(name, fallback)
+        "timestamp" == name ? :datetime : fallback
+      end
     end
 
     AddColumnDefinition = Struct.new(:column) # :nodoc:
@@ -105,8 +109,9 @@ module ActiveRecord
         !ActiveRecord::SchemaDumper.fk_ignore_pattern.match?(name) if name
       end
 
-      def defined_for?(to_table: nil, **options)
+      def defined_for?(to_table: nil, validate: nil, **options)
         (to_table.nil? || to_table.to_s == self.to_table) &&
+          (validate.nil? || validate == options.fetch(:validate, validate)) &&
           options.all? { |k, v| self.options[k].to_s == v.to_s }
       end
 

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -103,7 +103,11 @@ module ActiveRecord
         end
       end
 
+      DEFAULT_READ_QUERY = [:begin, :commit, :explain, :release, :rollback, :savepoint, :select, :with] # :nodoc:
+      private_constant :DEFAULT_READ_QUERY
+
       def self.build_read_query_regexp(*parts) # :nodoc:
+        parts += DEFAULT_READ_QUERY
         parts = parts.map { |part| /#{part}/i }
         /\A(?:[\(\s]|#{COMMENT_REGEX})*#{Regexp.union(*parts)}/
       end
@@ -168,6 +172,8 @@ module ActiveRecord
                                 spec_name = conn.pool.spec.name
                                 name = "#{spec_name}::SchemaMigration"
 
+                                return ActiveRecord::SchemaMigration if spec_name == "primary"
+
                                 Class.new(ActiveRecord::SchemaMigration) do
                                   define_singleton_method(:name) { name }
                                   define_singleton_method(:to_s) { name }

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -675,9 +675,10 @@ module ActiveRecord
         end
 
         def add_index_for_alter(table_name, column_name, options = {})
-          index_name, index_type, index_columns, _, index_algorithm, index_using = add_index_options(table_name, column_name, **options)
+          index_name, index_type, index_columns, _, index_algorithm, index_using, comment = add_index_options(table_name, column_name, **options)
           index_algorithm[0, 0] = ", " if index_algorithm.present?
-          "ADD #{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})#{index_algorithm}"
+          sql = +"ADD #{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})#{index_algorithm}"
+          add_sql_comment!(sql, comment)
         end
 
         def remove_index_for_alter(table_name, options = {})
@@ -686,7 +687,11 @@ module ActiveRecord
         end
 
         def supports_rename_index?
-          mariadb? ? false : database_version >= "5.7.6"
+          if mariadb?
+            database_version >= "10.5.2"
+          else
+            database_version >= "5.7.6"
+          end
         end
 
         def configure_connection
@@ -739,7 +744,7 @@ module ActiveRecord
           end.compact.join(", ")
 
           # ...and send them all in one query
-          execute "SET #{encoding} #{sql_mode_assignment} #{variable_assignments}"
+          execute("SET #{encoding} #{sql_mode_assignment} #{variable_assignments}", "SCHEMA")
         end
 
         def column_definitions(table_name) # :nodoc:

data/lib/active_record/connection_adapters/mysql/database_statements.rb

@@ -20,7 +20,7 @@ module ActiveRecord
         end
 
         READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
-          :begin, :commit, :explain, :select, :set, :show, :release, :savepoint, :rollback, :describe, :desc, :with
+          :desc, :describe, :set, :show, :use
         ) # :nodoc:
         private_constant :READ_QUERY
 

data/lib/active_record/connection_adapters/mysql/schema_statements.rb

@@ -203,10 +203,14 @@ module ActiveRecord
           def data_source_sql(name = nil, type: nil)
             scope = quoted_scope(name, type: type)
 
-            sql = +"SELECT table_name FROM information_schema.tables"
-            sql << " WHERE table_schema = #{scope[:schema]}"
-            sql << " AND table_name = #{scope[:name]}" if scope[:name]
-            sql << " AND table_type = #{scope[:type]}" if scope[:type]
+            sql = +"SELECT table_name FROM (SELECT * FROM information_schema.tables "
+            sql << " WHERE table_schema = #{scope[:schema]}) _subquery"
+            if scope[:type] || scope[:name]
+              conditions = []
+              conditions << "_subquery.table_type = #{scope[:type]}" if scope[:type]
+              conditions << "_subquery.table_name = #{scope[:name]}" if scope[:name]
+              sql << " WHERE #{conditions.join(" AND ")}"
+            end
             sql
           end
 

data/lib/active_record/connection_adapters/postgresql/database_statements.rb

@@ -68,7 +68,7 @@ module ActiveRecord
         end
 
         READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
-          :begin, :commit, :explain, :select, :set, :show, :release, :savepoint, :rollback, :with
+          :close, :declare, :fetch, :move, :set, :show
         ) # :nodoc:
         private_constant :READ_QUERY
 

data/lib/active_record/connection_adapters/postgresql/oid/date_time.rb

@@ -16,6 +16,14 @@ module ActiveRecord
               super
             end
           end
+
+          def type_cast_for_schema(value)
+            case value
+            when ::Float::INFINITY then "::Float::INFINITY"
+            when -::Float::INFINITY then "-::Float::INFINITY"
+            else super
+            end
+          end
         end
       end
     end