activerecord 6.1.0 → 6.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 418812373f3ff5fd16133fe0928b94b80b78b8a366abfc23a205fcb2ccc5a3e3
-  data.tar.gz: 70db1902a8fc82b1c46f8a7731ffb358357bc8cac29564a57881a732dbd2a65a
+  metadata.gz: 8533ac44f34eb20fbdc7d86aeef22c966a16ebe23e157db652a5bc1d6551429a
+  data.tar.gz: 2fe7a2768e779b4b5cd02f9da33231392199313c9acd4a2600a7b10f253ac7bd
 SHA512:
-  metadata.gz: 31ae64f629cb62f63bc37c74a888d557f9f0b102d401f2f9cf62c7d31655d99e5161ae9bc7f8be874c7a9cf27ec879dde3c04075df5cb2b5868891c0db144a50
-  data.tar.gz: cfc9585f3a6f53187707a9d96503269e3d4b1c5f1fe8c5f4db3bdefe8ce636042b6cf1fe9fb233491d1e8197f52293a7018a2f9925f1e34644ad1e30b134d59f
+  metadata.gz: e65080023ad359f9782e8c9f40437e0fb961b285cbe9e9ecb8efb8155defd814470a774ef086b5b9911de1c60cb7aa04e4f0006cdaa361344dfb41627f2a3fd3
+  data.tar.gz: 3c7e9ac5eea68d2e2ed2d4c6bc6a49f59b026682da56a695426454e20b6f4d25bb1d1dec4ecf651fbf42bce7231cf97a2cbf45751632471ffb7ffe3a6382a460

data/CHANGELOG.md

@@ -1,3 +1,291 @@
+## Rails 6.1.4 (June 24, 2021) ##
+
+*   Do not try to rollback transactions that failed due to a `ActiveRecord::TransactionRollbackError`.
+
+    *Jamie McCarthy*
+
+*   Raise an error if `pool_config` is `nil` in `set_pool_config`.
+
+    *Eileen M. Uchitelle*
+
+*   Fix compatibility with `psych >= 4`.
+
+    Starting in Psych 4.0.0 `YAML.load` behaves like `YAML.safe_load`. To preserve compatibility
+    Active Record's schema cache loader and `YAMLColumn` now uses `YAML.unsafe_load` if available.
+
+    *Jean Boussier*
+
+*   Support using replicas when using `rails dbconsole`.
+
+    *Christopher Thornton*
+
+*   Restore connection pools after transactional tests.
+
+    *Eugene Kenny*
+
+*   Change `upsert_all` to fails cleanly for MySQL when `:unique_by` is used.
+
+    *Bastian Bartmann*
+
+*   Fix user-defined `self.default_scope` to respect table alias.
+
+    *Ryuta Kamizono*
+
+*   Clear `@cache_keys` cache after `update_all`, `delete_all`, `destroy_all`.
+
+    *Ryuta Kamizono*
+
+*   Changed Arel predications `contains` and `overlaps` to use
+    `quoted_node` so that PostgreSQL arrays are quoted properly.
+
+    *Bradley Priest*
+
+*   Fix `merge` when the `where` clauses have string contents.
+
+    *Ryuta Kamizono*
+
+*   Fix rollback of parent destruction with nested `dependent: :destroy`.
+
+    *Jacopo Beschi*
+
+*   Fix binds logging for `"WHERE ... IN ..."` statements.
+
+    *Ricardo Díaz*
+
+*   Handle `false` in relation strict loading checks.
+
+    Previously when a model had strict loading set to true and then had a
+    relation set `strict_loading` to false the false wasn't considered when
+    deciding whether to raise/warn about strict loading.
+
+    ```
+    class Dog < ActiveRecord::Base
+      self.strict_loading_by_default = true
+
+      has_many :treats, strict_loading: false
+    end
+    ```
+
+    In the example, `dog.treats` would still raise even though
+    `strict_loading` was set to false. This is a bug effecting more than
+    Active Storage which is why I made this PR superceeding #41461. We need
+    to fix this for all applications since the behavior is a little
+    surprising. I took the test from ##41461 and the code suggestion from #41453
+    with some additions.
+
+    *Eileen M. Uchitelle*, *Radamés Roriz*
+
+*   Fix numericality validator without precision.
+
+    *Ryuta Kamizono*
+
+*   Fix aggregate attribute on Enum types.
+
+    *Ryuta Kamizono*
+
+*   Fix `CREATE INDEX` statement generation for PostgreSQL.
+
+    *eltongo*
+
+*   Fix where clause on enum attribute when providing array of strings.
+
+    *Ryuta Kamizono*
+
+*   Fix `unprepared_statement` to work it when nesting.
+
+    *Ryuta Kamizono*
+
+
+## Rails 6.1.3.2 (May 05, 2021) ##
+
+*   No changes.
+
+
+## Rails 6.1.3.1 (March 26, 2021) ##
+
+*   No changes.
+
+
+## Rails 6.1.3 (February 17, 2021) ##
+
+*   Fix the MySQL adapter to always set the right collation and charset
+    to the connection session.
+
+    *Rafael Mendonça França*
+
+*   Fix MySQL adapter handling of time objects when prepared statements
+    are enabled.
+
+    *Rafael Mendonça França*
+
+*   Fix scoping in enum fields using conditions that would generate
+    an `IN` clause.
+
+    *Ryuta Kamizono*
+
+*   Skip optimised #exist? query when #include? is called on a relation
+    with a having clause
+
+    Relations that have aliased select values AND a having clause that
+    references an aliased select value would generate an error when
+    #include? was called, due to an optimisation that would generate
+    call #exists? on the relation instead, which effectively alters
+    the select values of the query (and thus removes the aliased select
+    values), but leaves the having clause intact. Because the having
+    clause is then referencing an aliased column that is no longer
+    present in the simplified query, an ActiveRecord::InvalidStatement
+    error was raised.
+
+    An sample query affected by this problem:
+
+    ```ruby
+    Author.select('COUNT(*) as total_posts', 'authors.*')
+          .joins(:posts)
+          .group(:id)
+          .having('total_posts > 2')
+          .include?(Author.first)
+    ```
+
+    This change adds an addition check to the condition that skips the
+    simplified #exists? query, which simply checks for the presence of
+    a having clause.
+
+    Fixes #41417
+
+    *Michael Smart*
+
+*   Increment postgres prepared statement counter before making a prepared statement, so if the statement is aborted
+    without Rails knowledge (e.g., if app gets kill -9d during long-running query or due to Rack::Timeout), app won't end
+    up in perpetual crash state for being inconsistent with Postgres.
+
+    *wbharding*, *Martin Tepper*
+
+
+## Rails 6.1.2.1 (February 10, 2021) ##
+
+*   Fix possible DoS vector in PostgreSQL money type
+
+    Carefully crafted input can cause a DoS via the regular expressions used
+    for validating the money format in the PostgreSQL adapter.  This patch
+    fixes the regexp.
+
+    Thanks to @dee-see from Hackerone for this patch!
+
+    [CVE-2021-22880]
+
+    *Aaron Patterson*
+
+
+## Rails 6.1.2 (February 09, 2021) ##
+
+*   Fix timestamp type for sqlite3.
+
+    *Eileen M. Uchitelle*
+
+*   Make destroy async transactional.
+
+    An active record rollback could occur while enqueuing a job. In this
+    case the job would enqueue even though the database deletion
+    rolledback putting things in a funky state.
+
+    Now the jobs are only enqueued until after the db transaction has been committed.
+
+    *Cory Gwin*
+
+*   Fix malformed packet error in MySQL statement for connection configuration.
+
+    *robinroestenburg*
+
+*   Connection specification now passes the "url" key as a configuration for the
+    adapter if the "url" protocol is "jdbc", "http", or "https". Previously only
+    urls with the "jdbc" prefix were passed to the Active Record Adapter, others
+    are assumed to be adapter specification urls.
+
+    Fixes #41137.
+
+    *Jonathan Bracy*
+
+*   Fix granular connection swapping when there are multiple abstract classes.
+
+    *Eileen M. Uchitelle*
+
+*   Fix `find_by` with custom primary key for belongs_to association.
+
+    *Ryuta Kamizono*
+
+*   Add support for `rails console --sandbox` for multiple database applications.
+
+    *alpaca-tc*
+
+*   Fix `where` on polymorphic association with empty array.
+
+    *Ryuta Kamizono*
+
+*   Fix preventing writes for `ApplicationRecord`.
+
+    *Eileen M. Uchitelle*
+
+
+## Rails 6.1.1 (January 07, 2021) ##
+
+*   Fix fixtures loading when strict loading is enabled for the association.
+
+    *Alex Ghiculescu*
+
+*   Fix `where` with custom primary key for belongs_to association.
+
+    *Ryuta Kamizono*
+
+*   Fix `where` with aliased associations.
+
+    *Ryuta Kamizono*
+
+*   Fix `composed_of` with symbol mapping.
+
+    *Ryuta Kamizono*
+
+*   Don't skip money's type cast for pluck and calculations.
+
+    *Ryuta Kamizono*
+
+*   Fix `where` on polymorphic association with non Active Record object.
+
+    *Ryuta Kamizono*
+
+*   Make sure `db:prepare` works even the schema file doesn't exist.
+
+    *Rafael Mendonça França*
+
+*   Fix complicated `has_many :through` with nested where condition.
+
+    *Ryuta Kamizono*
+
+*   Handle STI models for `has_many dependent: :destroy_async`.
+
+    *Muhammad Usman*
+
+*   Restore possibility of passing `false` to :polymorphic option of `belongs_to`.
+
+    Previously, passing `false` would trigger the option validation logic
+    to throw an error saying :polymorphic would not be a valid option.
+
+    *glaszig*
+
+*   Allow adding nonnamed expression indexes to be revertible.
+
+    Fixes #40732.
+
+    Previously, the following code would raise an error, when executed while rolling back,
+    and the index name should be specified explicitly. Now, the index name is inferred
+    automatically.
+
+    ```ruby
+    add_index(:items, "to_tsvector('english', description)")
+    ```
+
+    *fatkodima*
+
+
 ## Rails 6.1.0 (December 09, 2020) ##
 
 *   Only warn about negative enums if a positive form that would cause conflicts exists.
@@ -38,21 +326,21 @@
 
     Before:
 
-      AnimalsRecord.connected_to(role: :reading) do
-        MealsRecord.connected_to(role: :reading) do
-          Dog.first # read from animals replica
-          Dinner.first # read from meals replica
-          Person.first # read from primary writer
+        AnimalsRecord.connected_to(role: :reading) do
+          MealsRecord.connected_to(role: :reading) do
+            Dog.first # read from animals replica
+            Dinner.first # read from meals replica
+            Person.first # read from primary writer
+          end
         end
-      end
 
     After:
 
-      ActiveRecord::Base.connected_to_many([AnimalsRecord, MealsRecord], role: :reading) do
-        Dog.first # read from animals replica
-        Dinner.first # read from meals replica
-        Person.first # read from primary writer
-      end
+        ActiveRecord::Base.connected_to_many([AnimalsRecord, MealsRecord], role: :reading) do
+          Dog.first # read from animals replica
+          Dinner.first # read from meals replica
+          Person.first # read from primary writer
+        end
 
     *Eileen M. Uchitelle*, *John Crepezzi*
 
@@ -170,13 +458,13 @@
 
      Before:
 
-         User.where.not(name: "Jon", role: "admin")
-         # SELECT * FROM users WHERE name != 'Jon' AND role != 'admin'
+        User.where.not(name: "Jon", role: "admin")
+        # SELECT * FROM users WHERE name != 'Jon' AND role != 'admin'
 
      After:
 
-         User.where.not(name: "Jon", role: "admin")
-         # SELECT * FROM users WHERE NOT (name == 'Jon' AND role == 'admin')
+        User.where.not(name: "Jon", role: "admin")
+        # SELECT * FROM users WHERE NOT (name == 'Jon' AND role == 'admin')
 
     *Rafael Mendonça França*
 
@@ -863,14 +1151,14 @@
     Deprecated behavior:
 
     ```ruby
-    db_config = ActiveRecord::Base.configs_for(env_name: "development", spec_name: "primary")
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "development", spec_name: "primary")
     db_config.spec_name
     ```
 
     New behavior:
 
     ```ruby
-    db_config = ActiveRecord::Base.configs_for(env_name: "development", name: "primary")
+    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "development", name: "primary")
     db_config.name
     ```
 

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/aggregations.rb

@@ -244,8 +244,8 @@ module ActiveRecord
         private
           def reader_method(name, class_name, mapping, allow_nil, constructor)
             define_method(name) do
-              if @aggregation_cache[name].nil? && (!allow_nil || mapping.any? { |key, _| !_read_attribute(key).nil? })
-                attrs = mapping.collect { |key, _| _read_attribute(key) }
+              if @aggregation_cache[name].nil? && (!allow_nil || mapping.any? { |key, _| !read_attribute(key).nil? })
+                attrs = mapping.collect { |key, _| read_attribute(key) }
                 object = constructor.respond_to?(:call) ?
                   constructor.call(*attrs) :
                   class_name.constantize.send(constructor, *attrs)
@@ -271,10 +271,10 @@ module ActiveRecord
               end
 
               if part.nil? && allow_nil
-                mapping.each { |key, _| self[key] = nil }
+                mapping.each { |key, _| write_attribute(key, nil) }
                 @aggregation_cache[name] = nil
               else
-                mapping.each { |key, value| self[key] = part.send(value) }
+                mapping.each { |key, value| write_attribute(key, part.send(value)) }
                 @aggregation_cache[name] = part.freeze
               end
             end

data/lib/active_record/association_relation.rb

@@ -27,6 +27,16 @@ module ActiveRecord
       RUBY
     end
 
+    def build(attributes = nil, &block)
+      if attributes.is_a?(Array)
+        attributes.collect { |attr| build(attr, &block) }
+      else
+        block = current_scope_restoring_block(&block)
+        scoping { _new(attributes, &block) }
+      end
+    end
+    alias new build
+
     private
       def _new(attributes, &block)
         @association.build(attributes, &block)

data/lib/active_record/associations/association.rb

@@ -211,12 +211,8 @@ module ActiveRecord
 
       private
         def find_target
-          if owner.strict_loading? && owner.validation_context.nil?
-            Base.strict_loading_violation!(owner: owner.class, association: klass)
-          end
-
-          if reflection.strict_loading? && owner.validation_context.nil?
-            Base.strict_loading_violation!(owner: owner.class, association: reflection.name)
+          if strict_loading? && owner.validation_context.nil?
+            Base.strict_loading_violation!(owner: owner.class, reflection: reflection)
           end
 
           scope = self.scope
@@ -231,6 +227,12 @@ module ActiveRecord
           sc.execute(binds, klass.connection) { |record| set_inverse_instance(record) }
         end
 
+        def strict_loading?
+          return reflection.strict_loading? if reflection.options.key?(:strict_loading)
+
+          owner.strict_loading?
+        end
+
         # The scope for this association.
         #
         # Note that the association_scope is merged into the target_scope only when the
@@ -331,7 +333,11 @@ module ActiveRecord
         end
 
         def enqueue_destroy_association(options)
-          owner.class.destroy_association_async_job&.perform_later(**options)
+          job_class = owner.class.destroy_association_async_job
+
+          if job_class
+            owner._after_commit_jobs.push([job_class, options])
+          end
         end
 
         def inversable?(record)

data/lib/active_record/associations/association_scope.rb

@@ -131,11 +131,13 @@ 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)
+                scope.merge! item.only(:joins, :left_outer_joins)
+
+                associations = item.eager_load_values | item.includes_values
+
+                unless associations.empty?
+                  scope.joins! item.construct_join_dependency(associations, Arel::Nodes::OuterJoin)
+                end
               end
 
               reflection.all_includes do

data/lib/active_record/associations/belongs_to_association.rb

@@ -9,8 +9,7 @@ module ActiveRecord
 
         case options[:dependent]
         when :destroy
-          target.destroy
-          raise ActiveRecord::Rollback unless target.destroyed?
+          raise ActiveRecord::Rollback unless target.destroy
         when :destroy_async
           id = owner.public_send(reflection.foreign_key.to_sym)
           primary_key_column = reflection.active_record_primary_key.to_sym
@@ -80,7 +79,7 @@ module ActiveRecord
             @updated = true
           end
 
-          replace_keys(record)
+          replace_keys(record, force: true)
 
           self.target = record
         end
@@ -108,8 +107,12 @@ module ActiveRecord
           reflection.counter_cache_column && owner.persisted?
         end
 
-        def replace_keys(record)
-          owner[reflection.foreign_key] = record ? record._read_attribute(primary_key(record.class)) : nil
+        def replace_keys(record, force: false)
+          target_key = record ? record._read_attribute(primary_key(record.class)) : nil
+
+          if force || owner[reflection.foreign_key] != target_key
+            owner[reflection.foreign_key] = target_key
+          end
         end
 
         def primary_key(klass)

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -14,9 +14,14 @@ module ActiveRecord
       end
 
       private
-        def replace_keys(record)
+        def replace_keys(record, force: false)
           super
-          owner[reflection.foreign_type] = record ? record.class.polymorphic_name : nil
+
+          target_type = record ? record.class.polymorphic_name : nil
+
+          if force || owner[reflection.foreign_type] != target_type
+            owner[reflection.foreign_type] = target_type
+          end
         end
 
         def inverse_reflection_for(record)

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

@@ -76,6 +76,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
       if dependent = reflection.options[:dependent]
         check_dependent_options(dependent, model)
         add_destroy_callbacks(model, reflection)
+        add_after_commit_jobs_callback(model, dependent)
       end
 
       Association.extensions.each do |extension|
@@ -132,11 +133,31 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
     def self.add_destroy_callbacks(model, reflection)
       name = reflection.name
-      model.before_destroy lambda { |o| o.association(name).handle_dependency }
+      model.before_destroy(->(o) { o.association(name).handle_dependency })
+    end
+
+    def self.add_after_commit_jobs_callback(model, dependent)
+      if dependent == :destroy_async
+        mixin = model.generated_association_methods
+
+        unless mixin.method_defined?(:_after_commit_jobs)
+          model.after_commit(-> do
+            _after_commit_jobs.each do |job_class, job_arguments|
+              job_class.perform_later(**job_arguments)
+            end
+          end)
+
+          mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+            def _after_commit_jobs
+              @_after_commit_jobs ||= []
+            end
+          CODE
+        end
+      end
     end
 
     private_class_method :build_scope, :macro, :valid_options, :validate_options, :define_extensions,
       :define_callbacks, :define_accessors, :define_readers, :define_writers, :define_validations,
-      :valid_dependent_options, :check_dependent_options, :add_destroy_callbacks
+      :valid_dependent_options, :check_dependent_options, :add_destroy_callbacks, :add_after_commit_jobs_callback
   end
 end

data/lib/active_record/associations/builder/belongs_to.rb

@@ -7,8 +7,8 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     def self.valid_options(options)
-      valid = super + [:counter_cache, :optional, :default]
-      valid += [:polymorphic, :foreign_type] if options[:polymorphic]
+      valid = super + [:polymorphic, :counter_cache, :optional, :default]
+      valid += [:foreign_type] if options[:polymorphic]
       valid += [:ensuring_owner_was] if options[:dependent] == :destroy_async
       valid
     end

data/lib/active_record/associations/has_many_association.rb

@@ -42,7 +42,7 @@ module ActiveRecord
             enqueue_destroy_association(
               owner_model_name: owner.class.to_s,
               owner_id: owner.id,
-              association_class: association_class.to_s,
+              association_class: reflection.klass.to_s,
               association_ids: ids,
               association_primary_key_column: primary_key_column,
               ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)

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

@@ -42,16 +42,17 @@ module ActiveRecord
           chain.reverse_each do |reflection, table|
             klass = reflection.klass
 
-            join_scope = reflection.join_scope(table, foreign_table, foreign_klass)
+            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)
+            unless scope.references_values.empty?
+              associations = scope.eager_load_values | scope.includes_values
+
+              unless associations.empty?
+                scope.joins! scope.construct_join_dependency(associations, Arel::Nodes::OuterJoin)
+              end
             end
 
-            arel = join_scope.arel(alias_tracker.aliases)
+            arel = scope.arel(alias_tracker.aliases)
             nodes = arel.constraints.first
 
             if nodes.is_a?(Arel::Nodes::And)

data/lib/active_record/associations/join_dependency.rb

@@ -195,7 +195,7 @@ module ActiveRecord
               next table, true
             end
 
-            table_name = @references[reflection.name.to_sym]
+            table_name = @references[reflection.name.to_sym]&.to_s
 
             table = alias_tracker.aliased_table_for(reflection.klass.arel_table, table_name) do
               name = reflection.alias_candidate(parent.table_name)

data/lib/active_record/associations.rb

@@ -1371,7 +1371,9 @@ module ActiveRecord
         #
         #   * <tt>nil</tt> do nothing (default).
         #   * <tt>:destroy</tt> causes all the associated objects to also be destroyed.
-        #   * <tt>:destroy_async</tt> destroys all the associated objects in a background job.
+        #   * <tt>:destroy_async</tt> destroys all the associated objects in a background job. <b>WARNING:</b> Do not use
+        #     this option if the association is backed by foreign key constraints in your database. The foreign key
+        #     constraint actions will occur inside the same transaction that deletes its owner.
         #   * <tt>:delete_all</tt> causes all the associated objects to be deleted directly from the database (so callbacks will not be executed).
         #   * <tt>:nullify</tt> causes the foreign keys to be set to +NULL+. Polymorphic type will also be nullified
         #     on polymorphic associations. Callbacks are not executed.
@@ -1523,7 +1525,9 @@ module ActiveRecord
         #
         #   * <tt>nil</tt> do nothing (default).
         #   * <tt>:destroy</tt> causes the associated object to also be destroyed
-        #   * <tt>:destroy_async</tt> causes all the associated object to be destroyed in a background job.
+        #   * <tt>:destroy_async</tt> causes the associated object to be destroyed in a background job. <b>WARNING:</b> Do not use
+        #     this option if the association is backed by foreign key constraints in your database. The foreign key
+        #     constraint actions will occur inside the same transaction that deletes its owner.
         #   * <tt>:delete</tt> causes the associated object to be deleted directly from the database (so callbacks will not execute)
         #   * <tt>:nullify</tt> causes the foreign key to be set to +NULL+. Polymorphic type column is also nullified
         #     on polymorphic associations. Callbacks are not executed.

data/lib/active_record/attributes.rb

@@ -173,7 +173,7 @@ module ActiveRecord
       #   class Money < Struct.new(:amount, :currency)
       #   end
       #
-      #   class MoneyType < Type::Value
+      #   class MoneyType < ActiveRecord::Type::Value
       #     def initialize(currency_converter:)
       #       @currency_converter = currency_converter
       #     end