activerecord 7.1.6 → 7.2.3

data/README.rdoc

@@ -34,7 +34,7 @@ A short rundown of some of the major features:
   This would also define the following accessors: <tt>Product#name</tt> and
   <tt>Product#name=(new_name)</tt>.
 
-  {Learn more}[link:classes/ActiveRecord/Base.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Base.html]
 
 * Associations between objects defined by simple class methods.
 
@@ -44,7 +44,7 @@ A short rundown of some of the major features:
      belongs_to :conglomerate
    end
 
-  {Learn more}[link:classes/ActiveRecord/Associations/ClassMethods.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html]
 
 
 * Aggregations of value objects.
@@ -56,7 +56,7 @@ A short rundown of some of the major features:
                  mapping: [%w(address_street street), %w(address_city city)]
    end
 
-  {Learn more}[link:classes/ActiveRecord/Aggregations/ClassMethods.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Aggregations/ClassMethods.html]
 
 
 * Validation rules that can differ for new or existing objects.
@@ -68,7 +68,7 @@ A short rundown of some of the major features:
       validates :password, :email_address, confirmation: true, on: :create
     end
 
-  {Learn more}[link:classes/ActiveRecord/Validations.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Validations.html]
 
 
 * Callbacks available for the entire life cycle (instantiation, saving, destroying, validating, etc.).
@@ -78,7 +78,7 @@ A short rundown of some of the major features:
      # the `invalidate_payment_plan` method gets called just before Person#destroy
    end
 
-  {Learn more}[link:classes/ActiveRecord/Callbacks.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html]
 
 
 * Inheritance hierarchies.
@@ -88,7 +88,7 @@ A short rundown of some of the major features:
    class Client < Company; end
    class PriorityClient < Client; end
 
-  {Learn more}[link:classes/ActiveRecord/Base.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Base.html]
 
 
 * Transactions.
@@ -99,7 +99,7 @@ A short rundown of some of the major features:
       mary.deposit(100)
     end
 
-  {Learn more}[link:classes/ActiveRecord/Transactions/ClassMethods.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Transactions/ClassMethods.html]
 
 
 * Reflections on columns, associations, and aggregations.
@@ -108,7 +108,7 @@ A short rundown of some of the major features:
     reflection.klass # => Client (class)
     Firm.columns # Returns an array of column descriptors for the firms table
 
-  {Learn more}[link:classes/ActiveRecord/Reflection/ClassMethods.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Reflection/ClassMethods.html]
 
 
 * Database abstraction through simple adapters.
@@ -125,13 +125,13 @@ A short rundown of some of the major features:
       database: 'activerecord'
     )
 
-  {Learn more}[link:classes/ActiveRecord/Base.html] and read about the built-in support for
-  MySQL[link:classes/ActiveRecord/ConnectionAdapters/Mysql2Adapter.html],
-  PostgreSQL[link:classes/ActiveRecord/ConnectionAdapters/PostgreSQLAdapter.html], and
-  SQLite3[link:classes/ActiveRecord/ConnectionAdapters/SQLite3Adapter.html].
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Base.html] and read about the built-in support for
+  MySQL[https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/Mysql2Adapter.html],
+  PostgreSQL[https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/PostgreSQLAdapter.html], and
+  SQLite3[https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SQLite3Adapter.html].
 
 
-* Logging support for Log4r[https://github.com/colbygk/log4r] and Logger[https://ruby-doc.org/stdlib/libdoc/logger/rdoc/].
+* Logging support for Log4r[https://github.com/colbygk/log4r] and Logger[https://docs.ruby-lang.org/en/master/Logger.html].
 
     ActiveRecord::Base.logger = ActiveSupport::Logger.new(STDOUT)
     ActiveRecord::Base.logger = Log4r::Logger.new('Application Log')
@@ -139,7 +139,7 @@ A short rundown of some of the major features:
 
 * Database agnostic schema management with Migrations.
 
-    class AddSystemSettings < ActiveRecord::Migration[7.1]
+    class AddSystemSettings < ActiveRecord::Migration[7.2]
       def up
         create_table :system_settings do |t|
           t.string  :name
@@ -157,7 +157,7 @@ A short rundown of some of the major features:
       end
     end
 
-  {Learn more}[link:classes/ActiveRecord/Migration.html]
+  {Learn more}[https://api.rubyonrails.org/classes/ActiveRecord/Migration.html]
 
 
 == Philosophy
@@ -214,6 +214,6 @@ Bug reports for the Ruby on \Rails project can be filed here:
 
 * https://github.com/rails/rails/issues
 
-Feature requests should be discussed on the rails-core mailing list here:
+Feature requests should be discussed on the rubyonrails-core forum here:
 
 * https://discuss.rubyonrails.org/c/rubyonrails-core

data/examples/performance.rb

@@ -176,10 +176,10 @@ Benchmark.ips(TIME) do |x|
   end
 
   x.report "Model.log" do
-    Exhibit.connection.send(:log, "hello", "world") { }
+    Exhibit.lease_connection.send(:log, "hello", "world") { }
   end
 
   x.report "AR.execute(query)" do
-    ActiveRecord::Base.connection.execute("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}")
+    ActiveRecord::Base.lease_connection.execute("SELECT * FROM exhibits WHERE id = #{(rand * 1000 + 1).to_i}")
   end
 end

data/lib/active_record/association_relation.rb

@@ -22,7 +22,7 @@ module ActiveRecord
             raise ArgumentError, "Bulk insert or upsert is currently not supported for has_many through association"
           end
 
-          scoping { klass.#{method}(attributes, **kwargs) }
+          super
         end
       RUBY
     end

data/lib/active_record/associations/alias_tracker.rb

@@ -6,34 +6,38 @@ module ActiveRecord
   module Associations
     # Keeps track of table aliases for ActiveRecord::Associations::JoinDependency
     class AliasTracker # :nodoc:
-      def self.create(connection, initial_table, joins, aliases = nil)
-        if joins.empty?
-          aliases ||= Hash.new(0)
-        elsif aliases
-          default_proc = aliases.default_proc || proc { 0 }
-          aliases.default_proc = proc { |h, k|
-            h[k] = initial_count_for(connection, k, joins) + default_proc.call(h, k)
-          }
-        else
-          aliases = Hash.new { |h, k|
-            h[k] = initial_count_for(connection, k, joins)
-          }
+      def self.create(pool, initial_table, joins, aliases = nil)
+        pool.with_connection do |connection|
+          if joins.empty?
+            aliases ||= Hash.new(0)
+          elsif aliases
+            default_proc = aliases.default_proc || proc { 0 }
+            aliases.default_proc = proc { |h, k|
+              h[k] = initial_count_for(connection, k, joins) + default_proc.call(h, k)
+            }
+          else
+            aliases = Hash.new { |h, k|
+              h[k] = initial_count_for(connection, k, joins)
+            }
+          end
+          aliases[initial_table] = 1
+          new(connection.table_alias_length, aliases)
         end
-        aliases[initial_table] = 1
-        new(connection, aliases)
       end
 
       def self.initial_count_for(connection, name, table_joins)
-        quoted_name = nil
+        quoted_name_escaped = nil
+        name_escaped = nil
 
         counts = table_joins.map do |join|
           if join.is_a?(Arel::Nodes::StringJoin)
-            # quoted_name should be case ignored as some database adapters (Oracle) return quoted name in uppercase
-            quoted_name ||= connection.quote_table_name(name)
+            # quoted_name_escaped should be case ignored as some database adapters (Oracle) return quoted name in uppercase
+            quoted_name_escaped ||= Regexp.escape(connection.quote_table_name(name))
+            name_escaped ||= Regexp.escape(name)
 
             # Table names + table aliases
             join.left.scan(
-              /JOIN(?:\s+\w+)?\s+(?:\S+\s+)?(?:#{quoted_name}|#{name})\sON/i
+              /JOIN(?:\s+\w+)?\s+(?:\S+\s+)?(?:#{quoted_name_escaped}|#{name_escaped})\sON/i
             ).size
           elsif join.is_a?(Arel::Nodes::Join)
             join.left.name == name ? 1 : 0
@@ -46,9 +50,9 @@ module ActiveRecord
       end
 
       # table_joins is an array of arel joins which might conflict with the aliases we assign here
-      def initialize(connection, aliases)
-        @aliases    = aliases
-        @connection = connection
+      def initialize(table_alias_length, aliases)
+        @aliases = aliases
+        @table_alias_length = table_alias_length
       end
 
       def aliased_table_for(arel_table, table_name = nil)
@@ -60,7 +64,7 @@ module ActiveRecord
           arel_table = arel_table.alias(table_name) if arel_table.name != table_name
         else
           # Otherwise, we need to use an alias
-          aliased_name = @connection.table_alias_for(yield)
+          aliased_name = table_alias_for(yield)
 
           # Update the count
           count = aliases[aliased_name] += 1
@@ -76,8 +80,12 @@ module ActiveRecord
       attr_reader :aliases
 
       private
+        def table_alias_for(table_name)
+          table_name[0...@table_alias_length].tr(".", "_")
+        end
+
         def truncate(name)
-          name.slice(0, @connection.table_alias_length - 2)
+          name.slice(0, @table_alias_length - 2)
         end
     end
   end

data/lib/active_record/associations/association.rb

@@ -53,7 +53,6 @@ module ActiveRecord
       # Resets the \loaded flag to +false+ and sets the \target to +nil+.
       def reset
         @loaded = false
-        @target = nil
         @stale_state = nil
       end
 
@@ -64,7 +63,7 @@ module ActiveRecord
       # Reloads the \target and returns +self+ on success.
       # The QueryCache is cleared if +force+ is true.
       def reload(force = false)
-        klass.connection.clear_query_cache if force && klass
+        klass.connection_pool.clear_query_cache if force && klass
         reset
         reset_scope
         load_target
@@ -211,6 +210,12 @@ module ActiveRecord
         _create_record(attributes, true, &block)
       end
 
+      # Whether the association represent a single record
+      # or a collection of records.
+      def collection?
+        false
+      end
+
       private
         # Reader and writer methods call this so that consistent errors are presented
         # when the association target class does not exist.
@@ -232,12 +237,14 @@ module ActiveRecord
           end
 
           binds = AssociationScope.get_bind_values(owner, reflection.chain)
-          sc.execute(binds, klass.connection) do |record|
-            set_inverse_instance(record)
-            if owner.strict_loading_n_plus_one_only? && reflection.macro == :has_many
-              record.strict_loading!
-            else
-              record.strict_loading!(false, mode: owner.strict_loading_mode)
+          klass.with_connection do |c|
+            sc.execute(binds, c) do |record|
+              set_inverse_instance(record)
+              if owner.strict_loading_n_plus_one_only? && reflection.macro == :has_many
+                record.strict_loading!
+              else
+                record.strict_loading!(false, mode: owner.strict_loading_mode)
+              end
             end
           end
         end

data/lib/active_record/associations/belongs_to_association.rb

@@ -19,10 +19,16 @@ module ActiveRecord
             id = owner.public_send(reflection.foreign_key)
           end
 
+          association_class = if reflection.polymorphic?
+            owner.public_send(reflection.foreign_type)
+          else
+            reflection.klass
+          end
+
           enqueue_destroy_association(
             owner_model_name: owner.class.to_s,
             owner_id: owner.id,
-            association_class: reflection.klass.to_s,
+            association_class: association_class.to_s,
             association_ids: [id],
             association_primary_key_column: primary_key_column,
             ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)
@@ -124,12 +130,22 @@ module ActiveRecord
         end
 
         def replace_keys(record, force: false)
-          target_key_values = record ? Array(primary_key(record.class)).map { |key| record._read_attribute(key) } : []
-          reflection_fk = Array(reflection.foreign_key)
+          reflection_fk = reflection.foreign_key
+          if reflection_fk.is_a?(Array)
+            target_key_values = record ? Array(primary_key(record.class)).map { |key| record._read_attribute(key) } : []
+
+            if force || reflection_fk.map { |fk| owner._read_attribute(fk) } != target_key_values
+              owner_pk = Array(owner.class.primary_key)
+              reflection_fk.each_with_index do |key, index|
+                next if record.nil? && owner_pk.include?(key)
+                owner[key] = target_key_values[index]
+              end
+            end
+          else
+            target_key_value = record ? record._read_attribute(primary_key(record.class)) : nil
 
-          if force || reflection_fk.map { |fk| owner._read_attribute(fk) } != target_key_values
-            reflection_fk.zip(target_key_values).each do |key, value|
-              owner[key] = value
+            if force || owner._read_attribute(reflection_fk) != target_key_value
+              owner[reflection_fk] = target_key_value
             end
           end
         end
@@ -148,8 +164,15 @@ module ActiveRecord
         end
 
         def stale_state
-          result = owner._read_attribute(reflection.foreign_key) { |n| owner.send(:missing_attribute, n, caller) }
-          result && result.to_s
+          foreign_key = reflection.foreign_key
+          if foreign_key.is_a?(Array)
+            attributes = foreign_key.map do |fk|
+              owner._read_attribute(fk) { |n| owner.send(:missing_attribute, n, caller) }
+            end
+            attributes if attributes.any?
+          else
+            owner._read_attribute(foreign_key) { |n| owner.send(:missing_attribute, n, caller) }
+          end
         end
     end
   end

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -41,8 +41,9 @@ module ActiveRecord
         end
 
         def stale_state
-          foreign_key = super
-          foreign_key && [foreign_key.to_s, owner[reflection.foreign_type].to_s]
+          if foreign_key = super
+            [foreign_key, owner[reflection.foreign_type]]
+          end
         end
     end
   end

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

@@ -38,6 +38,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
       klass = reflection.class_name.safe_constantize
       klass._counter_cache_columns |= [cache_column] if klass && klass.respond_to?(:_counter_cache_columns)
+      model.counter_cached_association_names |= [reflection.name]
     end
 
     def self.touch_record(o, changes, foreign_key, name, touch) # :nodoc:

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

@@ -42,8 +42,8 @@ module ActiveRecord::Associations::Builder # :nodoc:
           self.right_reflection = _reflect_on_association(rhs_name)
         end
 
-        def self.retrieve_connection
-          left_model.retrieve_connection
+        def self.connection_pool
+          left_model.connection_pool
         end
       }
 

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

@@ -7,11 +7,10 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     def self.valid_options(options)
-      valid = super + [:counter_cache, :join_table, :index_errors]
-      valid += [:as, :foreign_type] if options[:as]
-      valid += [:through, :source, :source_type] if options[:through]
+      valid = super + [:counter_cache, :join_table, :index_errors, :as, :through]
+      valid += [:foreign_type] if options[:as]
+      valid += [:source, :source_type, :disable_joins] if options[:through]
       valid += [:ensuring_owner_was] if options[:dependent] == :destroy_async
-      valid += [:disable_joins] if options[:disable_joins] && options[:through]
       valid
     end
 

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

@@ -7,11 +7,10 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     def self.valid_options(options)
-      valid = super
-      valid += [:as, :foreign_type] if options[:as]
+      valid = super + [:as, :through]
+      valid += [:foreign_type] if options[:as]
       valid += [:ensuring_owner_was] if options[:dependent] == :destroy_async
-      valid += [:through, :source, :source_type] if options[:through]
-      valid += [:disable_joins] if options[:disable_joins] && options[:through]
+      valid += [:source, :source_type, :disable_joins] if options[:through]
       valid
     end
 

data/lib/active_record/associations/collection_association.rb

@@ -28,6 +28,8 @@ module ActiveRecord
     # If you need to work on all current children, new and existing records,
     # +load_target+ and the +loaded+ flag are your friends.
     class CollectionAssociation < Association # :nodoc:
+      attr_accessor :nested_attributes_target
+
       # Implements the reader method, e.g. foo.items for Foo.has_many :items
       def reader
         ensure_klass_exists!
@@ -228,7 +230,7 @@ module ActiveRecord
       # loaded and you are going to fetch the records anyway it is better to
       # check <tt>collection.length.zero?</tt>.
       def empty?
-        if loaded? || @association_ids || reflection.has_cached_counter?
+        if loaded? || @association_ids || reflection.has_active_cached_counter?
           size.zero?
         else
           target.empty? && !scope.exists?
@@ -254,14 +256,16 @@ module ActiveRecord
       end
 
       def include?(record)
-        if record.is_a?(reflection.klass)
-          if record.new_record?
-            include_in_memory?(record)
-          else
-            loaded? ? target.include?(record) : scope.exists?(record.id)
-          end
+        klass = reflection.klass
+        return false unless record.is_a?(klass)
+
+        if loaded?
+          target.include?(record)
+        elsif record.new_record?
+          include_in_memory?(record)
         else
-          false
+          record_id = klass.composite_primary_key? ? klass.primary_key.zip(record.id).to_h : record.id
+          scope.exists?(record_id)
         end
       end
 
@@ -309,6 +313,10 @@ module ActiveRecord
           target.any? { |record| record.new_record? || record.changed? }
       end
 
+      def collection?
+        true
+      end
+
       private
         def transaction(&block)
           reflection.klass.transaction(&block)

data/lib/active_record/associations/collection_proxy.rb

@@ -928,7 +928,20 @@ module ActiveRecord
         !!@association.include?(record)
       end
 
-      def proxy_association # :nodoc:
+      # Returns the association object for the collection.
+      #
+      #   class Person < ActiveRecord::Base
+      #     has_many :pets
+      #   end
+      #
+      #   person.pets.proxy_association
+      #   # => #<ActiveRecord::Associations::HasManyAssociation owner="#<Person:0x00>">
+      #
+      # Returns the same object as <tt>person.association(:pets)</tt>,
+      # allowing you to make calls like <tt>person.pets.proxy_association.owner</tt>.
+      #
+      # See Associations::ClassMethods@Association+extensions for more.
+      def proxy_association
         @association
       end