activerecord 7.2.3 → 8.0.0.beta1

data/README.rdoc

@@ -139,7 +139,7 @@ A short rundown of some of the major features:
 
 * Database agnostic schema management with Migrations.
 
-    class AddSystemSettings < ActiveRecord::Migration[7.2]
+    class AddSystemSettings < ActiveRecord::Migration[8.0]
       def up
         create_table :system_settings do |t|
           t.string  :name
@@ -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 rubyonrails-core forum here:
+Feature requests should be discussed on the rails-core mailing list here:
 
 * https://discuss.rubyonrails.org/c/rubyonrails-core

data/lib/active_record/associations/alias_tracker.rb

@@ -26,18 +26,16 @@ module ActiveRecord
       end
 
       def self.initial_count_for(connection, name, table_joins)
-        quoted_name_escaped = nil
-        name_escaped = nil
+        quoted_name = nil
 
         counts = table_joins.map do |join|
           if join.is_a?(Arel::Nodes::StringJoin)
-            # 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)
+            # quoted_name should be case ignored as some database adapters (Oracle) return quoted name in uppercase
+            quoted_name ||= connection.quote_table_name(name)
 
             # Table names + table aliases
             join.left.scan(
-              /JOIN(?:\s+\w+)?\s+(?:\S+\s+)?(?:#{quoted_name_escaped}|#{name_escaped})\sON/i
+              /JOIN(?:\s+\w+)?\s+(?:\S+\s+)?(?:#{quoted_name}|#{name})\sON/i
             ).size
           elsif join.is_a?(Arel::Nodes::Join)
             join.left.name == name ? 1 : 0

data/lib/active_record/associations/association.rb

@@ -34,7 +34,7 @@ module ActiveRecord
     # the <tt>reflection</tt> object represents a <tt>:has_many</tt> macro.
     class Association # :nodoc:
       attr_accessor :owner
-      attr_reader :target, :reflection, :disable_joins
+      attr_reader :reflection, :disable_joins
 
       delegate :options, to: :reflection
 
@@ -50,6 +50,13 @@ module ActiveRecord
         @skip_strict_loading = nil
       end
 
+      def target
+        if @target.is_a?(Promise)
+          @target = @target.value
+        end
+        @target
+      end
+
       # Resets the \loaded flag to +false+ and sets the \target to +nil+.
       def reset
         @loaded = false
@@ -172,7 +179,7 @@ module ActiveRecord
       # ActiveRecord::RecordNotFound is rescued within the method, and it is
       # not reraised. The proxy is \reset and +nil+ is the return value.
       def load_target
-        @target = find_target if (@stale_state && stale_target?) || find_target?
+        @target = find_target(async: false) if (@stale_state && stale_target?) || find_target?
 
         loaded! unless loaded?
         target
@@ -180,6 +187,13 @@ module ActiveRecord
         reset
       end
 
+      def async_load_target # :nodoc:
+        @target = find_target(async: true) if (@stale_state && stale_target?) || find_target?
+
+        loaded! unless loaded?
+        nil
+      end
+
       # We can't dump @reflection and @through_reflection since it contains the scope proc
       def marshal_dump
         ivars = (instance_variables - [:@reflection, :@through_reflection]).map { |name| [name, instance_variable_get(name)] }
@@ -223,13 +237,19 @@ module ActiveRecord
           klass
         end
 
-        def find_target
+        def find_target(async: false)
           if violates_strict_loading?
             Base.strict_loading_violation!(owner: owner.class, reflection: reflection)
           end
 
           scope = self.scope
-          return scope.to_a if skip_statement_cache?(scope)
+          if skip_statement_cache?(scope)
+            if async
+              return scope.load_async.then(&:to_a)
+            else
+              return scope.to_a
+            end
+          end
 
           sc = reflection.association_scope_cache(klass, owner) do |params|
             as = AssociationScope.create { params.bind }
@@ -238,7 +258,7 @@ module ActiveRecord
 
           binds = AssociationScope.get_bind_values(owner, reflection.chain)
           klass.with_connection do |c|
-            sc.execute(binds, c) do |record|
+            sc.execute(binds, c, async: async) do |record|
               set_inverse_instance(record)
               if owner.strict_loading_n_plus_one_only? && reflection.macro == :has_many
                 record.strict_loading!

data/lib/active_record/associations/belongs_to_association.rb

@@ -19,16 +19,10 @@ 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: association_class.to_s,
+            association_class: reflection.klass.to_s,
             association_ids: [id],
             association_primary_key_column: primary_key_column,
             ensuring_owner_was_method: options.fetch(:ensuring_owner_was, nil)
@@ -135,9 +129,7 @@ module ActiveRecord
             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
@@ -164,15 +156,7 @@ module ActiveRecord
         end
 
         def stale_state
-          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
+          owner._read_attribute(reflection.foreign_key) { |n| owner.send(:missing_attribute, n, caller) }
         end
     end
   end

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

@@ -30,10 +30,10 @@ module ActiveRecord::Associations::Builder # :nodoc:
       end
 
       reflection = create_reflection(model, name, scope, options, &block)
-      define_accessors model, reflection
-      define_callbacks model, reflection
-      define_validations model, reflection
-      define_change_tracking_methods model, reflection
+      define_accessors(model, reflection)
+      define_callbacks(model, reflection)
+      define_validations(model, reflection)
+      define_change_tracking_methods(model, reflection)
       reflection
     end
 
@@ -71,6 +71,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     def self.define_extensions(model, name)
+      # noop
     end
 
     def self.define_callbacks(model, reflection)
@@ -81,7 +82,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
       end
 
       Association.extensions.each do |extension|
-        extension.build model, reflection
+        extension.build(model, reflection)
       end
     end
 
@@ -131,7 +132,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
         err_message = "A valid destroy_association_async_job is required to use `dependent: :destroy_async` on associations"
         raise ActiveRecord::ConfigurationError, err_message
       end
-      unless valid_dependent_options.include? dependent
+      unless valid_dependent_options.include?(dependent)
         raise ArgumentError, "The :dependent option must be one of #{valid_dependent_options}, but is :#{dependent}"
       end
     end

data/lib/active_record/associations/collection_association.rb

@@ -94,7 +94,7 @@ module ActiveRecord
       def find(*args)
         if options[:inverse_of] && loaded?
           args_flatten = args.flatten
-          model = scope.klass
+          model = scope.model
 
           if args_flatten.blank?
             error_message = "Couldn't find #{model.name} without an ID"
@@ -259,10 +259,10 @@ module ActiveRecord
         klass = reflection.klass
         return false unless record.is_a?(klass)
 
-        if loaded?
-          target.include?(record)
-        elsif record.new_record?
+        if record.new_record?
           include_in_memory?(record)
+        elsif loaded?
+          target.include?(record)
         else
           record_id = klass.composite_primary_key? ? klass.primary_key.zip(record.id).to_h : record.id
           scope.exists?(record_id)

data/lib/active_record/associations/disable_joins_association_scope.rb

@@ -47,7 +47,7 @@ module ActiveRecord
           end
 
           if scope.order_values.empty? && ordered
-            split_scope = DisableJoinsAssociationRelation.create(scope.klass, key, join_ids)
+            split_scope = DisableJoinsAssociationRelation.create(scope.model, key, join_ids)
             split_scope.where_clause += scope.where_clause
             split_scope
           else

data/lib/active_record/associations/has_many_through_association.rb

@@ -93,13 +93,7 @@ module ActiveRecord
           @through_scope = scope
           record = super
 
-          inverse =
-            if source_reflection.polymorphic?
-              source_reflection.polymorphic_inverse_of(record.class)
-            else
-              source_reflection.inverse_of
-            end
-
+          inverse = source_reflection.inverse_of
           if inverse
             if inverse.collection?
               record.send(inverse.name) << build_through_record(record)
@@ -146,7 +140,7 @@ module ActiveRecord
 
           case method
           when :destroy
-            if scope.klass.primary_key
+            if scope.model.primary_key
               count = scope.destroy_all.count(&:destroyed?)
             else
               scope.each(&:_run_destroy_callbacks)
@@ -222,7 +216,8 @@ module ActiveRecord
           end
         end
 
-        def find_target
+        def find_target(async: false)
+          raise NotImplementedError, "No async loading for HasManyThroughAssociation yet" if async
           return [] unless target_reflection_has_associated_record?
           return scope.to_a if disable_joins
           super

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

@@ -38,39 +38,41 @@ module ActiveRecord
             chain << [reflection, table]
           end
 
-          # The chain starts with the target table, but we want to end with it here (makes
-          # more sense in this context), so we reverse
-          chain.reverse_each do |reflection, table|
-            klass = reflection.klass
+          base_klass.with_connection do |connection|
+            # The chain starts with the target table, but we want to end with it here (makes
+            # more sense in this context), so we reverse
+            chain.reverse_each do |reflection, table|
+              klass = reflection.klass
 
-            scope = reflection.join_scope(table, foreign_table, foreign_klass)
+              scope = reflection.join_scope(table, foreign_table, foreign_klass)
 
-            unless scope.references_values.empty?
-              associations = scope.eager_load_values | scope.includes_values
+              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)
+                unless associations.empty?
+                  scope.joins! scope.construct_join_dependency(associations, Arel::Nodes::OuterJoin)
+                end
               end
-            end
 
-            arel = scope.arel(alias_tracker.aliases)
-            nodes = arel.constraints.first
+              arel = scope.arel(alias_tracker.aliases)
+              nodes = arel.constraints.first
 
-            if nodes.is_a?(Arel::Nodes::And)
-              others = nodes.children.extract! do |node|
-                !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
+              if nodes.is_a?(Arel::Nodes::And)
+                others = nodes.children.extract! do |node|
+                  !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
+                end
               end
-            end
 
-            joins << join_type.new(table, Arel::Nodes::On.new(nodes))
+              joins << join_type.new(table, Arel::Nodes::On.new(nodes))
 
-            if others && !others.empty?
-              joins.concat arel.join_sources
-              append_constraints(joins.last, others)
-            end
+              if others && !others.empty?
+                joins.concat arel.join_sources
+                append_constraints(connection, joins.last, others)
+              end
 
-            # The current table in this iteration becomes the foreign table in the next
-            foreign_table, foreign_klass = table, klass
+              # The current table in this iteration becomes the foreign table in the next
+              foreign_table, foreign_klass = table, klass
+            end
           end
 
           joins
@@ -89,10 +91,10 @@ module ActiveRecord
         end
 
         private
-          def append_constraints(join, constraints)
+          def append_constraints(connection, join, constraints)
             if join.is_a?(Arel::Nodes::StringJoin)
               join_string = Arel::Nodes::And.new(constraints.unshift join.left)
-              join.left = join_string
+              join.left = Arel.sql(connection.visitor.compile(join_string))
             else
               right = join.right
               right.expr = Arel::Nodes::And.new(constraints.unshift right.expr)

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

@@ -17,12 +17,12 @@ module ActiveRecord
           def eql?(other)
             association_key_name == other.association_key_name &&
               scope.table_name == other.scope.table_name &&
-              scope.connection_specification_name == other.scope.connection_specification_name &&
+              scope.model.connection_specification_name == other.scope.model.connection_specification_name &&
               scope.values_for_queries == other.scope.values_for_queries
           end
 
           def hash
-            [association_key_name, scope.table_name, scope.connection_specification_name, scope.values_for_queries].hash
+            [association_key_name, scope.model.table_name, scope.model.connection_specification_name, scope.values_for_queries].hash
           end
 
           def records_for(loaders)

data/lib/active_record/associations/singular_association.rb

@@ -18,6 +18,7 @@ module ActiveRecord
       def reset
         super
         @target = nil
+        @future_target = nil
       end
 
       # Implements the writer method, e.g. foo.bar= for Foo.belongs_to :bar
@@ -43,11 +44,15 @@ module ActiveRecord
           super.except!(*Array(klass.primary_key))
         end
 
-        def find_target
+        def find_target(async: false)
           if disable_joins
-            scope.first
+            if async
+              scope.load_async.then(&:first)
+            else
+              scope.first
+            end
           else
-            super.first
+            super.then(&:first)
           end
         end
 

data/lib/active_record/associations.rb

@@ -379,21 +379,43 @@ module ActiveRecord
       #              after_add: :congratulate_client,
       #              after_remove: :log_after_remove
       #
-      #     def congratulate_client(record)
+      #     def congratulate_client(client)
       #       # ...
       #     end
       #
-      #     def log_after_remove(record)
+      #     def log_after_remove(client)
       #       # ...
       #     end
       #   end
       #
+      # Callbacks can be defined in three ways:
+      #
+      # 1. A symbol that references a method defined on the class with the
+      #    associated collection. For example, <tt>after_add: :congratulate_client</tt>
+      #    invokes <tt>Firm#congratulate_client(client)</tt>.
+      # 2. A callable with a signature that accepts both the record with the
+      #    associated collection and the record being added or removed. For
+      #    example, <tt>after_add: ->(firm, client) { ... }</tt>.
+      # 3. An object that responds to the callback name. For example, passing
+      #    <tt>after_add: CallbackObject.new</tt> invokes <tt>CallbackObject#after_add(firm,
+      #    client)</tt>.
+      #
       # It's possible to stack callbacks by passing them as an array. Example:
       #
+      #   class CallbackObject
+      #     def after_add(firm, client)
+      #       firm.log << "after_adding #{client.id}"
+      #     end
+      #   end
+      #
       #   class Firm < ActiveRecord::Base
       #     has_many :clients,
       #              dependent: :destroy,
-      #              after_add: [:congratulate_client, -> (firm, record) { firm.log << "after_adding#{record.id}" }],
+      #              after_add: [
+      #                :congratulate_client,
+      #                -> (firm, client) { firm.log << "after_adding #{client.id}" },
+      #                CallbackObject.new
+      #              ],
       #              after_remove: :log_after_remove
       #   end
       #
@@ -537,7 +559,7 @@ module ActiveRecord
       #   @group.avatars << Avatar.new   # this would work if User belonged_to Avatar rather than the other way around
       #   @group.avatars.delete(@group.avatars.last)  # so would this
       #
-      # === Setting Inverses
+      # == Setting Inverses
       #
       # If you are using a #belongs_to on the join model, it is a good idea to set the
       # <tt>:inverse_of</tt> option on the #belongs_to, which will mean that the following example
@@ -1199,11 +1221,8 @@ module ActiveRecord
         #   If you are going to modify the association (rather than just read from it), then it is
         #   a good idea to set the <tt>:inverse_of</tt> option on the source association on the
         #   join model. This allows associated records to be built which will automatically create
-        #   the appropriate join model records when they are saved. See
-        #   {Association Join Models}[rdoc-ref:Associations::ClassMethods@Association+Join+Models]
-        #   and {Setting Inverses}[rdoc-ref:Associations::ClassMethods@Setting+Inverses] for
-        #   more detail.
-        #
+        #   the appropriate join model records when they are saved. (See the 'Association Join Models'
+        #   and 'Setting Inverses' sections above.)
         # [+:disable_joins+]
         #   Specifies whether joins should be skipped for an association. If set to true, two or more queries
         #   will be generated. Note that in some cases, if order or limit is applied, it will be done in-memory
@@ -1232,8 +1251,7 @@ module ActiveRecord
         # [+:inverse_of+]
         #   Specifies the name of the #belongs_to association on the associated object
         #   that is the inverse of this #has_many association.
-        #   See {Bi-directional associations}[rdoc-ref:Associations::ClassMethods@Bi-directional+associations]
-        #   for more detail.
+        #   See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
         # [+:extend+]
         #   Specifies a module or array of modules that will be extended into the association object returned.
         #   Useful for defining methods on associations, especially when they should be shared between multiple
@@ -1255,6 +1273,14 @@ module ActiveRecord
         #   persisted new records placed at the end.
         #   When set to +:nested_attributes_order+, the index is based on the record order received by
         #   nested attributes setter, when accepts_nested_attributes_for is used.
+        # [:before_add]
+        #   Defines an {association callback}[rdoc-ref:Associations::ClassMethods@Association+callbacks] that gets triggered <b>before an object is added</b> to the association collection.
+        # [:after_add]
+        #   Defines an {association callback}[rdoc-ref:Associations::ClassMethods@Association+callbacks] that gets triggered <b>after an object is added</b> to the association collection.
+        # [:before_remove]
+        #   Defines an {association callback}[rdoc-ref:Associations::ClassMethods@Association+callbacks] that gets triggered <b>before an object is removed</b> from the association collection.
+        # [:after_remove]
+        #   Defines an {association callback}[rdoc-ref:Associations::ClassMethods@Association+callbacks] that gets triggered <b>after an object is removed</b> from the association collection.
         #
         # Option examples:
         #   has_many :comments, -> { order("posted_on") }
@@ -1274,12 +1300,10 @@ module ActiveRecord
           Reflection.add_reflection self, name, reflection
         end
 
-        # Specifies a one-to-one association with another class. This method
-        # should only be used if the other class contains the foreign key. If
-        # the current class contains the foreign key, then you should use
-        # #belongs_to instead. See {Is it a belongs_to or has_one
-        # association?}[rdoc-ref:Associations::ClassMethods@Is+it+a+-23belongs_to+or+-23has_one+association-3F]
-        # for more detail on when to use #has_one and when to use #belongs_to.
+        # Specifies a one-to-one association with another class. This method should only be used
+        # if the other class contains the foreign key. If the current class contains the foreign key,
+        # then you should use #belongs_to instead. See also ActiveRecord::Associations::ClassMethods's overview
+        # on when to use #has_one and when to use #belongs_to.
         #
         # The following methods for retrieval and query of a single associated object will be added:
         #
@@ -1394,10 +1418,8 @@ module ActiveRecord
         #   If you are going to modify the association (rather than just read from it), then it is
         #   a good idea to set the <tt>:inverse_of</tt> option on the source association on the
         #   join model. This allows associated records to be built which will automatically create
-        #   the appropriate join model records when they are saved. See
-        #   {Association Join Models}[rdoc-ref:Associations::ClassMethods@Association+Join+Models]
-        #   and {Setting Inverses}[rdoc-ref:Associations::ClassMethods@Setting+Inverses] for
-        #   more detail.
+        #   the appropriate join model records when they are saved. (See the 'Association Join Models'
+        #   and 'Setting Inverses' sections above.)
         # [+:disable_joins+]
         #   Specifies whether joins should be skipped for an association. If set to true, two or more queries
         #   will be generated. Note that in some cases, if order or limit is applied, it will be done in-memory
@@ -1435,8 +1457,7 @@ module ActiveRecord
         # [+:inverse_of+]
         #   Specifies the name of the #belongs_to association on the associated object
         #   that is the inverse of this #has_one association.
-        #   See {Bi-directional associations}[rdoc-ref:Associations::ClassMethods@Bi-directional+associations]
-        #   for more detail.
+        #   See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
         # [+:required+]
         #   When set to +true+, the association will also have its presence validated.
         #   This will validate the association itself, not the id. You can use
@@ -1470,12 +1491,10 @@ module ActiveRecord
           Reflection.add_reflection self, name, reflection
         end
 
-        # Specifies a one-to-one association with another class. This method
-        # should only be used if this class contains the foreign key. If the
-        # other class contains the foreign key, then you should use #has_one
-        # instead. See {Is it a belongs_to or has_one
-        # association?}[rdoc-ref:Associations::ClassMethods@Is+it+a+-23belongs_to+or+-23has_one+association-3F]
-        # for more detail on when to use #has_one and when to use #belongs_to.
+        # Specifies a one-to-one association with another class. This method should only be used
+        # if this class contains the foreign key. If the other class contains the foreign key,
+        # then you should use #has_one instead. See also ActiveRecord::Associations::ClassMethods's overview
+        # on when to use #has_one and when to use #belongs_to.
         #
         # Methods will be added for retrieval and query for a single associated object, for which
         # this object holds an id:
@@ -1617,8 +1636,7 @@ module ActiveRecord
         # [+:inverse_of+]
         #   Specifies the name of the #has_one or #has_many association on the associated
         #   object that is the inverse of this #belongs_to association.
-        #   See {Bi-directional associations}[rdoc-ref:Associations::ClassMethods@Bi-directional+associations]
-        #   for more detail.
+        #   See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
         # [+:optional+]
         #   When set to +true+, the association will not have its presence validated.
         # [+:required+]
@@ -1678,7 +1696,7 @@ module ActiveRecord
         # The join table should not have a primary key or a model associated with it. You must manually generate the
         # join table with a migration such as this:
         #
-        #   class CreateDevelopersProjectsJoinTable < ActiveRecord::Migration[7.2]
+        #   class CreateDevelopersProjectsJoinTable < ActiveRecord::Migration[8.0]
         #     def change
         #       create_join_table :developers, :projects
         #     end

data/lib/active_record/asynchronous_queries_tracker.rb

@@ -1,29 +1,30 @@
 # frozen_string_literal: true
 
+require "concurrent/atomic/atomic_boolean"
+require "concurrent/atomic/read_write_lock"
+
 module ActiveRecord
   class AsynchronousQueriesTracker # :nodoc:
-    module NullSession # :nodoc:
-      class << self
-        def active?
-          true
-        end
-
-        def finalize
-        end
-      end
-    end
-
     class Session # :nodoc:
       def initialize
-        @active = true
+        @active = Concurrent::AtomicBoolean.new(true)
+        @lock = Concurrent::ReadWriteLock.new
       end
 
       def active?
-        @active
+        @active.true?
       end
 
-      def finalize
-        @active = false
+      def synchronize(&block)
+        @lock.with_read_lock(&block)
+      end
+
+      def finalize(wait = false)
+        @active.make_false
+        if wait
+          # Wait until all thread with a read lock are done
+          @lock.with_write_lock { }
+        end
       end
     end
 
@@ -33,7 +34,7 @@ module ActiveRecord
       end
 
       def run
-        ActiveRecord::Base.asynchronous_queries_tracker.start_session
+        ActiveRecord::Base.asynchronous_queries_tracker.tap(&:start_session)
       end
 
       def complete(asynchronous_queries_tracker)
@@ -41,20 +42,23 @@ module ActiveRecord
       end
     end
 
-    attr_reader :current_session
-
     def initialize
-      @current_session = NullSession
+      @stack = []
+    end
+
+    def current_session
+      @stack.last or raise ActiveRecordError, "Can't perform asynchronous queries without a query session"
     end
 
     def start_session
-      @current_session = Session.new
-      self
+      session = Session.new
+      @stack << session
     end
 
-    def finalize_session
-      @current_session.finalize
-      @current_session = NullSession
+    def finalize_session(wait = false)
+      session = @stack.pop
+      session&.finalize(wait)
+      self
     end
   end
 end

data/lib/active_record/attribute_methods/serialization.rb

@@ -130,7 +130,7 @@ module ActiveRecord
         # silently cast unsupported types to +String+:
         #
         #   >> JSON.parse(JSON.dump(Struct.new(:foo)))
-        #   # => "#<Class:0x000000013090b4c0>"
+        #   => "#<Class:0x000000013090b4c0>"
         #
         # ==== Examples
         #