activerecord 6.0.0 → 6.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed17e948626d108075b2951ac71abbac3075ef55b055abe64e2b352e91755fd9
-  data.tar.gz: 2c031642e021041f9fdf278888b580fd446879008a23f12d33c8b33aafbddc59
+  metadata.gz: d8ac16c2194f2d74297c1fdbfd64c286003ce2aea666afd85bfa07ecac816877
+  data.tar.gz: a15e33a862b0985aea1d3b506ce53dd38678c3f47a121dddcd5c90388665788e
 SHA512:
-  metadata.gz: 6b208a5cbee77c2a057649b762a92ec4ca5be3b8fbd1b2123caf485579abbc602bcb2aee455a503b74f33efa9ce364ab644dc8958b9e1edd94fee3397bf17cc8
-  data.tar.gz: 751ecf72279d478887665f6a3efc5ad366b70284fb3f4ef6d2f3b072faf7c325be660116a7d3ac9427ac44dcf6f8c345e145921692d0465e24a70f1c2ca3b1bd
+  metadata.gz: be693dc74628ffedf85fe5dd569b2bec88e1ccd1b3ed61a347ce63f612747c8e50485d41d46a70fd803f8fbc454572592e59bea246152c0902057ef5c384a235
+  data.tar.gz: 33294c99f5631c31762075cfb88da12fb106794f4a68d28d227fb177d92fe1afd832148331b9ba273f338fa749d1a3679cffaafef464549f79292e2de8b08e08

data/CHANGELOG.md

@@ -1,3 +1,187 @@
+## Rails 6.0.3 (May 06, 2020) ##
+
+*   Recommend applications don't use the `database` kwarg in `connected_to`
+
+    The database kwarg in `connected_to` was meant to be used for one-off scripts but is often used in requests. This is really dangerous because it re-establishes a connection every time. It's deprecated in 6.1 and will be removed in 6.2 without replacement. This change soft deprecates it in 6.0 by removing documentation.
+
+    *Eileen M. Uchitelle*
+
+*   Fix support for PostgreSQL 11+ partitioned indexes.
+
+    *Sebastián Palma*
+
+*   Add support for beginless ranges, introduced in Ruby 2.7.
+
+    *Josh Goodall*
+
+*   Fix insert_all with enum values
+
+    Fixes #38716.
+
+    *Joel Blum*
+
+*   Regexp-escape table name for MS SQL
+
+    Add `Regexp.escape` to one method in ActiveRecord, so that table names with regular expression characters in them work as expected. Since MS SQL Server uses "[" and "]" to quote table and column names, and those characters are regular expression characters, methods like `pluck` and `select` fail in certain cases when used with the MS SQL Server adapter.
+
+    *Larry Reid*
+
+*   Store advisory locks on their own named connection.
+
+    Previously advisory locks were taken out against a connection when a migration started. This works fine in single database applications but doesn't work well when migrations need to open new connections which results in the lock getting dropped.
+
+    In order to fix this we are storing the advisory lock on a new connection with the connection specification name `AdisoryLockBase`. The caveat is that we need to maintain at least 2 connections to a database while migrations are running in order to do this.
+
+    *Eileen M. Uchitelle*, *John Crepezzi*
+
+*   Ensure `:reading` connections always raise if a write is attempted.
+
+    Now Rails will raise an `ActiveRecord::ReadOnlyError` if any connection on the reading handler attempts to make a write. If your reading role needs to write you should name the role something other than `:reading`.
+
+    *Eileen M. Uchitelle*
+
+*   Enforce fresh ETag header after a collection's contents change by adding
+    ActiveRecord::Relation#cache_key_with_version. This method will be used by
+    ActionController::ConditionalGet to ensure that when collection cache versioning
+    is enabled, requests using ConditionalGet don't return the same ETag header
+    after a collection is modified. Fixes #38078.
+
+    *Aaron Lipman*
+
+*   A database URL can now contain a querystring value that contains an equal sign. This is needed to support passing PostgresSQL `options`.
+
+     *Joshua Flanagan*
+
+*   Retain explicit selections on the base model after applying `includes` and `joins`.
+
+    Resolves #34889.
+
+    *Patrick Rebsch*
+
+
+## Rails 6.0.2.2 (March 19, 2020) ##
+
+*   No changes.
+
+
+## Rails 6.0.2.1 (December 18, 2019) ##
+
+*   No changes.
+
+
+## Rails 6.0.2 (December 13, 2019) ##
+
+*   Share the same connection pool for primary and replica databases in the
+    transactional tests for the same database.
+
+    *Edouard Chin*
+
+*   Fix the preloader when one record is fetched using `after_initialize`
+    but not the entire collection.
+
+    *Bradley Price*
+
+*   Fix collection callbacks not terminating when `:abort` is thrown.
+
+    *Edouard Chin*, *Ryuta Kamizono*
+
+*   Correctly deprecate `where.not` working as NOR for relations.
+
+    12a9664 deprecated where.not working as NOR, however
+    doing a relation query like `where.not(relation: { ... })`
+    wouldn't be properly deprecated and `where.not` would work as
+    NAND instead.
+
+    *Edouard Chin*
+
+*   Fix `db:migrate` task with multiple databases to restore the connection
+    to the previous database.
+
+    The migrate task iterates and establish a connection over each db
+    resulting in the last one to be used by subsequent rake tasks.
+    We should reestablish a connection to the connection that was
+    established before the migrate tasks was run
+
+    *Edouard Chin*
+
+*   Fix multi-threaded issue for `AcceptanceValidator`.
+
+    *Ryuta Kamizono*
+
+
+## Rails 6.0.1 (November 5, 2019) ##
+
+*    Common Table Expressions are allowed on read-only connections.
+
+     *Chris Morris*
+
+*    New record instantiation respects `unscope`.
+
+     *Ryuta Kamizono*
+
+*    Fixed a case where `find_in_batches` could halt too early.
+
+     *Takayuki Nakata*
+
+*    Autosaved associations always perform validations when a custom validation
+     context is used.
+
+     *Tekin Suleyman*
+
+*    `sql.active_record` notifications now include the `:connection` in
+     their payloads.
+
+     *Eugene Kenny*
+
+*    A rollback encountered in an `after_commit` callback does not reset
+     previously-committed record state.
+
+     *Ryuta Kamizono*
+
+*    Fixed that join order was lost when eager-loading.
+
+     *Ryuta Kamizono*
+
+*   `DESCRIBE` queries are allowed on read-only connections.
+
+    *Dylan Thacker-Smith*
+
+*   Fixed that records that had been `inspect`ed could not be marshaled.
+
+    *Eugene Kenny*
+
+*   The connection pool reaper thread is respawned in forked processes. This
+    fixes that idle connections in forked processes wouldn't be reaped.
+
+    *John Hawthorn*
+
+*   The memoized result of `ActiveRecord::Relation#take` is properly cleared
+    when `ActiveRecord::Relation#reset` or `ActiveRecord::Relation#reload`
+    is called.
+
+    *Anmol Arora*
+
+*   Fixed the performance regression for `primary_keys` introduced MySQL 8.0.
+
+    *Hiroyuki Ishii*
+
+*   `insert`, `insert_all`, `upsert`, and `upsert_all` now clear the query cache.
+
+    *Eugene Kenny*
+
+*   Call `while_preventing_writes` directly from `connected_to`.
+
+    In some cases application authors want to use the database switching middleware and make explicit calls with `connected_to`. It's possible for an app to turn off writes and not turn them back on by the time we call `connected_to(role: :writing)`.
+
+    This change allows apps to fix this by assuming if a role is writing we want to allow writes, except in the case it's explicitly turned off.
+
+    *Eileen M. Uchitelle*
+
+*   Improve detection of ActiveRecord::StatementTimeout with mysql2 adapter in the edge case when the query is terminated during filesort.
+
+    *Kir Shatrov*
+
+
 ## Rails 6.0.0 (August 16, 2019) ##
 
 *   Preserve user supplied joins order as much as possible.
@@ -478,7 +662,7 @@
 
     *Rafael Mendonça França*
 
-*   Deprecate `config.activerecord.sqlite3.represent_boolean_as_integer`.
+*   Deprecate `config.active_record.sqlite3.represent_boolean_as_integer`.
 
     *Rafael Mendonça França*
 

data/README.rdoc

@@ -216,4 +216,4 @@ Bug reports for the Ruby on Rails project can be filed here:
 
 Feature requests should be discussed on the rails-core mailing list here:
 
-* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
+* https://discuss.rubyonrails.org/c/rubyonrails-core

data/lib/active_record.rb

@@ -35,6 +35,7 @@ require "active_model/attribute_set"
 module ActiveRecord
   extend ActiveSupport::Autoload
 
+  autoload :AdvisoryLockBase
   autoload :Base
   autoload :Callbacks
   autoload :Core

data/lib/active_record/advisory_lock_base.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  # This class is used to create a connection that we can use for advisory
+  # locks. This will take out a "global" lock that can't be accidentally
+  # removed if a new connection is established during a migration.
+  class AdvisoryLockBase < ActiveRecord::Base # :nodoc:
+    self.abstract_class = true
+
+    self.connection_specification_name = "AdvisoryLockBase"
+
+    class << self
+      def _internal?
+        true
+      end
+    end
+  end
+end

data/lib/active_record/aggregations.rb

@@ -14,7 +14,6 @@ module ActiveRecord
     end
 
     private
-
       def clear_aggregation_cache
         @aggregation_cache.clear if persisted?
       end

data/lib/active_record/association_relation.rb

@@ -2,7 +2,7 @@
 
 module ActiveRecord
   class AssociationRelation < Relation
-    def initialize(klass, association)
+    def initialize(klass, association, **)
       super(klass)
       @association = association
     end
@@ -15,21 +15,23 @@ module ActiveRecord
       other == records
     end
 
-    def build(*args, &block)
-      scoping { @association.build(*args, &block) }
+    def build(attributes = nil, &block)
+      block = _deprecated_scope_block("new", &block)
+      scoping { @association.build(attributes, &block) }
     end
     alias new build
 
-    def create(*args, &block)
-      scoping { @association.create(*args, &block) }
+    def create(attributes = nil, &block)
+      block = _deprecated_scope_block("create", &block)
+      scoping { @association.create(attributes, &block) }
     end
 
-    def create!(*args, &block)
-      scoping { @association.create!(*args, &block) }
+    def create!(attributes = nil, &block)
+      block = _deprecated_scope_block("create!", &block)
+      scoping { @association.create!(attributes, &block) }
     end
 
     private
-
       def exec_queries
         super do |record|
           @association.set_inverse_instance_from_queries(record)

data/lib/active_record/associations.rb

@@ -92,7 +92,7 @@ module ActiveRecord
         through_reflection      = reflection.through_reflection
         source_reflection_names = reflection.source_reflection_names
         source_associations     = reflection.through_reflection.klass._reflections.keys
-        super("Could not find the source association(s) #{source_reflection_names.collect(&:inspect).to_sentence(two_words_connector: ' or ', last_word_connector: ', or ', locale: :en)} in model #{through_reflection.klass}. Try 'has_many #{reflection.name.inspect}, :through => #{through_reflection.name.inspect}, :source => <name>'. Is it one of #{source_associations.to_sentence(two_words_connector: ' or ', last_word_connector: ', or ', locale: :en)}?")
+        super("Could not find the source association(s) #{source_reflection_names.collect(&:inspect).to_sentence(two_words_connector: ' or ', last_word_connector: ', or ')} in model #{through_reflection.klass}. Try 'has_many #{reflection.name.inspect}, :through => #{through_reflection.name.inspect}, :source => <name>'. Is it one of #{source_associations.to_sentence(two_words_connector: ' or ', last_word_connector: ', or ')}?")
       else
         super("Could not find the source association(s).")
       end
@@ -1857,7 +1857,7 @@ module ActiveRecord
             hm_options[k] = options[k] if options.key? k
           end
 
-          has_many name, scope, hm_options, &extension
+          has_many name, scope, **hm_options, &extension
           _reflections[name.to_s].parent_reflection = habtm_reflection
         end
       end

data/lib/active_record/associations/alias_tracker.rb

@@ -72,7 +72,6 @@ module ActiveRecord
       attr_reader :aliases
 
       private
-
         def truncate(name)
           name.slice(0, @connection.table_alias_length - 2)
         end

data/lib/active_record/associations/association.rb

@@ -95,7 +95,11 @@ module ActiveRecord
       end
 
       def scope
-        target_scope.merge!(association_scope)
+        if (scope = klass.current_scope) && scope.try(:proxy_association) == self
+          scope.spawn
+        else
+          target_scope.merge!(association_scope)
+        end
       end
 
       def reset_scope

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

@@ -46,7 +46,6 @@ module ActiveRecord::Associations::Builder # :nodoc:
         end
 
         private
-
           def self.suppress_composite_primary_key(pk)
             pk unless pk.is_a?(Array)
           end
@@ -73,7 +72,6 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     private
-
       def middle_options(join_model)
         middle_options = {}
         middle_options[:class_name] = "#{lhs_model.name}::#{join_model.name}"

data/lib/active_record/associations/collection_association.rb

@@ -378,7 +378,9 @@ module ActiveRecord
         end
 
         def remove_records(existing_records, records, method)
-          records.each { |record| callback(:before_remove, record) }
+          catch(:abort) do
+            records.each { |record| callback(:before_remove, record) }
+          end || return
 
           delete_records(existing_records, method) if existing_records.any?
           @target -= records
@@ -434,7 +436,9 @@ module ActiveRecord
         end
 
         def replace_on_target(record, index, skip_callbacks)
-          callback(:before_add, record) unless skip_callbacks
+          catch(:abort) do
+            callback(:before_add, record)
+          end || return unless skip_callbacks
 
           set_inverse_instance(record)
 

data/lib/active_record/associations/collection_proxy.rb

@@ -27,7 +27,7 @@ module ActiveRecord
     # is computed directly through SQL and does not trigger by itself the
     # instantiation of the actual post records.
     class CollectionProxy < Relation
-      def initialize(klass, association) #:nodoc:
+      def initialize(klass, association, **) #:nodoc:
         @association = association
         super klass
 
@@ -1101,7 +1101,6 @@ module ActiveRecord
       delegate(*delegate_methods, to: :scope)
 
       private
-
         def find_nth_with_limit(index, limit)
           load_target if find_from_target?
           super

data/lib/active_record/associations/has_many_association.rb

@@ -37,7 +37,6 @@ module ActiveRecord
       end
 
       private
-
         # Returns the number of records in this collection.
         #
         # If the association has a counter cache it gets that value. Otherwise

data/lib/active_record/associations/join_dependency.rb

@@ -70,6 +70,10 @@ module ActiveRecord
         @join_type = join_type
       end
 
+      def base_klass
+        join_root.base_klass
+      end
+
       def reflections
         join_root.drop(1).map!(&:reflection)
       end
@@ -101,7 +105,9 @@ 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)
 
         message_bus = ActiveSupport::Notifications.instrumenter
 
@@ -131,6 +137,13 @@ module ActiveRecord
       private
         attr_reader :alias_tracker
 
+        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) }
+        end
+
         def aliases
           @aliases ||= Aliases.new join_root.each_with_index.map { |join_part, i|
             columns = join_part.column_names.each_with_index.map { |column_name, j|

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

@@ -37,7 +37,7 @@ module ActiveRecord
             nodes = arel.constraints.first
 
             others = nodes.children.extract! do |node|
-              Arel.fetch_attribute(node) { |attr| attr.relation.name != table.name }
+              !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
             end
 
             joins << table.create_join(table, table.create_on(nodes), join_type)

data/lib/active_record/associations/preloader.rb

@@ -95,7 +95,6 @@ module ActiveRecord
       end
 
       private
-
         # Loads all the given data into +records+ for the +association+.
         def preloaders_on(association, records, scope, polymorphic_parent = false)
           case association
@@ -112,7 +111,7 @@ module ActiveRecord
           association.flat_map { |parent, child|
             grouped_records(parent, records, polymorphic_parent).flat_map do |reflection, reflection_records|
               loaders = preloaders_for_reflection(reflection, reflection_records, scope)
-              recs = loaders.flat_map(&:preloaded_records)
+              recs = loaders.flat_map(&:preloaded_records).uniq
               child_polymorphic_parent = reflection && reflection.options[:polymorphic]
               loaders.concat Array.wrap(child).flat_map { |assoc|
                 preloaders_on assoc, recs, scope, child_polymorphic_parent
@@ -185,7 +184,7 @@ module ActiveRecord
         # and attach it to a relation. The class returned implements a `run` method
         # that accepts a preloader.
         def preloader_for(reflection, owners)
-          if owners.first.association(reflection.name).loaded?
+          if owners.all? { |o| o.association(reflection.name).loaded? }
             return AlreadyLoaded
           end
           reflection.check_preloadable!