activerecord 6.1.0 → 6.1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 418812373f3ff5fd16133fe0928b94b80b78b8a366abfc23a205fcb2ccc5a3e3
-  data.tar.gz: 70db1902a8fc82b1c46f8a7731ffb358357bc8cac29564a57881a732dbd2a65a
+  metadata.gz: 2093e13defc611f0ec1e62d7efd445bcd1c5b182d8aab24f3dd3625047ce2f9f
+  data.tar.gz: 8d3e9a6daab9d0026cc1826d1caf2f24fee239d05b63cbb0eac866b1daded767
 SHA512:
-  metadata.gz: 31ae64f629cb62f63bc37c74a888d557f9f0b102d401f2f9cf62c7d31655d99e5161ae9bc7f8be874c7a9cf27ec879dde3c04075df5cb2b5868891c0db144a50
-  data.tar.gz: cfc9585f3a6f53187707a9d96503269e3d4b1c5f1fe8c5f4db3bdefe8ce636042b6cf1fe9fb233491d1e8197f52293a7018a2f9925f1e34644ad1e30b134d59f
+  metadata.gz: 3e6be64f1492b2441290abac0af6cde31950acef133ccdd98202b2ab719dc48b0f969eda318b4712c508cde2f29b3a6c381c27c6e7467b4ee25ec97209717d7a
+  data.tar.gz: 924c8bcbbaa608deb02263437e76947737b041b39a86818585e3d087530f0d1e3fdc537fc10d1177fe6cf2413deaf47f655342435312a5d473a4789e7a35631f

data/CHANGELOG.md

@@ -1,3 +1,443 @@
+## Rails 6.1.6.1 (July 12, 2022) ##
+
+*   Change ActiveRecord::Coders::YAMLColumn default to safe_load
+
+    This adds two new configuration options The configuration options are as
+    follows:
+    
+    * `config.active_storage.use_yaml_unsafe_load`
+    
+    When set to true, this configuration option tells Rails to use the old
+    "unsafe" YAML loading strategy, maintaining the existing behavior but leaving
+    the possible escalation vulnerability in place.  Setting this option to true
+    is *not* recommended, but can aid in upgrading.
+    
+    * `config.active_record.yaml_column_permitted_classes`
+    
+    The "safe YAML" loading method does not allow all classes to be deserialized
+    by default.  This option allows you to specify classes deemed "safe" in your
+    application.  For example, if your application uses Symbol and Time in
+    serialized data, you can add Symbol and Time to the allowed list as follows:
+    
+    ```
+    config.active_record.yaml_column_permitted_classes = [Symbol, Date, Time]
+    ```
+
+    [CVE-2022-32224]
+
+
+## Rails 6.1.5.1 (April 26, 2022) ##
+
+*   No changes.
+
+
+## Rails 6.1.5 (March 09, 2022) ##
+
+*   Fix `ActiveRecord::ConnectionAdapters::SchemaCache#deep_deduplicate` for Ruby 2.6.
+
+    Ruby 2.6 and 2.7 have slightly different implementations of the `String#-@` method.
+    In Ruby 2.6, the receiver of the `String#-@` method is modified under certain circumstances.
+    This was later identified as a bug (https://bugs.ruby-lang.org/issues/15926) and only
+    fixed in Ruby 2.7.
+
+    Before the changes in this commit, the
+    `ActiveRecord::ConnectionAdapters::SchemaCache#deep_deduplicate` method, which internally
+    calls the `String#-@` method, could also modify an input string argument in Ruby 2.6 --
+    changing a tainted, unfrozen string into a tainted, frozen string.
+
+    Fixes #43056
+
+    *Eric O'Hanlon*
+
+*   Fix migration compatibility to create SQLite references/belongs_to column as integer when
+    migration version is 6.0.
+
+    `reference`/`belongs_to` in migrations with version 6.0 were creating columns as
+    bigint instead of integer for the SQLite Adapter.
+
+    *Marcelo Lauxen*
+
+*   Fix dbconsole for 3-tier config.
+
+    *Eileen M. Uchitelle*
+
+*   Better handle SQL queries with invalid encoding.
+
+    ```ruby
+    Post.create(name: "broken \xC8 UTF-8")
+    ```
+
+    Would cause all adapters to fail in a non controlled way in the code
+    responsible to detect write queries.
+
+    The query is now properly passed to the database connection, which might or might
+    not be able to handle it, but will either succeed or failed in a more correct way.
+
+    *Jean Boussier*
+
+*   Ignore persisted in-memory records when merging target lists.
+
+    *Kevin Sjöberg*
+
+*   Fix regression bug that caused ignoring additional conditions for preloading
+    `has_many` through relations.
+
+    Fixes #43132
+
+    *Alexander Pauly*
+
+*   Fix `ActiveRecord::InternalMetadata` to not be broken by
+    `config.active_record.record_timestamps = false`
+
+    Since the model always create the timestamp columns, it has to set them, otherwise it breaks
+    various DB management tasks.
+
+    Fixes #42983
+
+    *Jean Boussier*
+
+*   Fix duplicate active record objects on `inverse_of`.
+
+    *Justin Carvalho*
+
+*   Fix duplicate objects stored in has many association after save.
+
+    Fixes #42549.
+
+    *Alex Ghiculescu*
+
+*   Fix performance regression in `CollectionAssocation#build`.
+
+    *Alex Ghiculescu*
+
+*   Fix retrieving default value for text column for MariaDB.
+
+    *fatkodima*
+
+
+## Rails 6.1.4.7 (March 08, 2022) ##
+
+*   No changes.
+
+
+## Rails 6.1.4.6 (February 11, 2022) ##
+
+*   No changes.
+
+
+## Rails 6.1.4.5 (February 11, 2022) ##
+
+*   No changes.
+
+
+## Rails 6.1.4.4 (December 15, 2021) ##
+
+*   No changes.
+
+
+## Rails 6.1.4.3 (December 14, 2021) ##
+
+*   No changes.
+
+
+## Rails 6.1.4.2 (December 14, 2021) ##
+
+*   No changes.
+
+
+## Rails 6.1.4.1 (August 19, 2021) ##
+
+*   No changes.
+
+
+## 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 affecting more than
+    Active Storage which is why I made this PR superseding #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 +478,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 +610,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*
 
@@ -284,7 +724,7 @@
 
         attribute :duration, :interval
 
-    To keep old behavior until 6.2 is released:
+    To keep old behavior until 7.0 is released:
 
         attribute :duration, :string
 
@@ -456,8 +896,8 @@
     *Ryuta Kamizono*
 
 *   Merging conditions on the same column no longer maintain both conditions,
-    and will be consistently replaced by the latter condition in Rails 6.2.
-    To migrate to Rails 6.2's behavior, use `relation.merge(other, rewhere: true)`.
+    and will be consistently replaced by the latter condition in Rails 7.0.
+    To migrate to Rails 7.0's behavior, use `relation.merge(other, rewhere: true)`.
 
     ```ruby
     # Rails 6.1 (IN clause is replaced by merger side equality condition)
@@ -466,10 +906,10 @@
     # Rails 6.1 (both conflict conditions exists, deprecated)
     Author.where(id: david.id..mary.id).merge(Author.where(id: bob)) # => []
 
-    # Rails 6.1 with rewhere to migrate to Rails 6.2's behavior
+    # Rails 6.1 with rewhere to migrate to Rails 7.0's behavior
     Author.where(id: david.id..mary.id).merge(Author.where(id: bob), rewhere: true) # => [bob]
 
-    # Rails 6.2 (same behavior with IN clause, mergee side condition is consistently replaced)
+    # Rails 7.0 (same behavior with IN clause, mergee side condition is consistently replaced)
     Author.where(id: [david.id, mary.id]).merge(Author.where(id: bob)) # => [bob]
     Author.where(id: david.id..mary.id).merge(Author.where(id: bob)) # => [bob]
     ```
@@ -561,7 +1001,7 @@
 
 *   Deprecate aggregations with group by duplicated fields.
 
-    To migrate to Rails 6.2's behavior, use `uniq!(:group)` to deduplicate group fields.
+    To migrate to Rails 7.0's behavior, use `uniq!(:group)` to deduplicate group fields.
 
     ```ruby
     accounts = Account.group(:firm_id)
@@ -585,7 +1025,7 @@
 
 *   Deprecate duplicated query annotations.
 
-    To migrate to Rails 6.2's behavior, use `uniq!(:annotate)` to deduplicate query annotations.
+    To migrate to Rails 7.0's behavior, use `uniq!(:annotate)` to deduplicate query annotations.
 
     ```ruby
     accounts = Account.where(id: [1, 2]).annotate("david and mary")
@@ -863,14 +1303,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
     ```
 
@@ -1006,13 +1446,13 @@
 
 *   Deprecate `#remove_connection` in favor of `#remove_connection_pool` when called on the handler.
 
-    `#remove_connection` is deprecated in order to support returning a `DatabaseConfig` object instead of a `Hash`. Use `#remove_connection_pool`, `#remove_connection` will be removed in 6.2.
+    `#remove_connection` is deprecated in order to support returning a `DatabaseConfig` object instead of a `Hash`. Use `#remove_connection_pool`, `#remove_connection` will be removed in Rails 7.0.
 
     *Eileen M. Uchitelle*, *John Crepezzi*
 
 *   Deprecate `#default_hash` and it's alias `#[]` on database configurations.
 
-    Applications should use `configs_for`. `#default_hash` and `#[]` will be removed in 6.2.
+    Applications should use `configs_for`. `#default_hash` and `#[]` will be removed in Rails 7.0.
 
     *Eileen M. Uchitelle*, *John Crepezzi*
 

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2020 David Heinemeier Hansson
+Copyright (c) 2004-2022 David Heinemeier Hansson
 
 Arel originally copyright (c) 2007-2016 Nick Kallen, Bryan Helmkamp, Emilio Tagua, Aaron Patterson
 

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)