activerecord 6.1.0 → 6.1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 418812373f3ff5fd16133fe0928b94b80b78b8a366abfc23a205fcb2ccc5a3e3
-  data.tar.gz: 70db1902a8fc82b1c46f8a7731ffb358357bc8cac29564a57881a732dbd2a65a
+  metadata.gz: a6a73442f7b3996c8742fbdaddb78012145e7321e67873b9b3326bd7deb3d0ee
+  data.tar.gz: c1ddaf64625c98f4467998f98978232f9c17c245ba0650b7cee93c9d53e88be3
 SHA512:
-  metadata.gz: 31ae64f629cb62f63bc37c74a888d557f9f0b102d401f2f9cf62c7d31655d99e5161ae9bc7f8be874c7a9cf27ec879dde3c04075df5cb2b5868891c0db144a50
-  data.tar.gz: cfc9585f3a6f53187707a9d96503269e3d4b1c5f1fe8c5f4db3bdefe8ce636042b6cf1fe9fb233491d1e8197f52293a7018a2f9925f1e34644ad1e30b134d59f
+  metadata.gz: 4b90ced681f18f7685128f85d8be8c68cca244991999d4d05ec76b54513a34a3fab490798e9dd95e853a87550151e03b873007f57380b0baf39ea1bf93539351
+  data.tar.gz: 6e7e52edeb4a03f2088ee50a3823fe1dd07eacdfb4fd7ff4dde7ee2984e92385f0f3d8d91f7598a76082986720e5967ca99c395ce20f9fd7c4a9531642ae8701

data/CHANGELOG.md

@@ -1,3 +1,188 @@
+## 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 +223,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 +355,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*
 

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.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/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 (owner.strict_loading? || reflection.strict_loading?) && owner.validation_context.nil?
+            Base.strict_loading_violation!(owner: owner.class, reflection: reflection)
           end
 
           scope = self.scope
@@ -331,7 +327,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

@@ -80,7 +80,7 @@ module ActiveRecord
             @updated = true
           end
 
-          replace_keys(record)
+          replace_keys(record, force: true)
 
           self.target = record
         end
@@ -108,8 +108,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