activerecord 7.0.8 → 7.1.0

data/lib/active_record/connection_adapters/abstract/transaction.rb

@@ -2,6 +2,7 @@
 
 module ActiveRecord
   module ConnectionAdapters
+    # = Active Record Connection Adapters Transaction State
     class TransactionState
       def initialize(state = nil)
         @state = state
@@ -73,6 +74,35 @@ module ActiveRecord
       end
     end
 
+    class TransactionInstrumenter
+      def initialize(payload = {})
+        @handle = nil
+        @started = false
+        @payload = nil
+        @base_payload = payload
+      end
+
+      class InstrumentationNotStartedError < ActiveRecordError; end
+      class InstrumentationAlreadyStartedError < ActiveRecordError; end
+
+      def start
+        raise InstrumentationAlreadyStartedError.new("Called start on an already started transaction") if @started
+        @started = true
+
+        @payload = @base_payload.dup
+        @handle = ActiveSupport::Notifications.instrumenter.build_handle("transaction.active_record", @payload)
+        @handle.start
+      end
+
+      def finish(outcome)
+        raise InstrumentationNotStartedError.new("Called finish on a transaction that hasn't started") unless @started
+        @started = false
+
+        @payload[:outcome] = outcome
+        @handle.finish
+      end
+    end
+
     class NullTransaction # :nodoc:
       def initialize; end
       def state; end
@@ -80,12 +110,19 @@ module ActiveRecord
       def open?; false; end
       def joinable?; false; end
       def add_record(record, _ = true); end
+      def restartable?; false; end
+      def dirty?; false; end
+      def dirty!; end
+      def invalidated?; false; end
+      def invalidate!; end
     end
 
     class Transaction # :nodoc:
       attr_reader :connection, :state, :savepoint_name, :isolation_level
       attr_accessor :written
 
+      delegate :invalidate!, :invalidated?, to: :@state
+
       def initialize(connection, isolation: nil, joinable: true, run_commit_callbacks: false)
         @connection = connection
         @state = TransactionState.new
@@ -95,6 +132,16 @@ module ActiveRecord
         @joinable = joinable
         @run_commit_callbacks = run_commit_callbacks
         @lazy_enrollment_records = nil
+        @dirty = false
+        @instrumenter = TransactionInstrumenter.new(connection: connection)
+      end
+
+      def dirty!
+        @dirty = true
+      end
+
+      def dirty?
+        @dirty
       end
 
       def add_record(record, ensure_finalize = true)
@@ -115,22 +162,41 @@ module ActiveRecord
         @records
       end
 
+      # Can this transaction's current state be recreated by
+      # rollback+begin ?
+      def restartable?
+        joinable? && !dirty?
+      end
+
+      def incomplete!
+        @instrumenter.finish(:incomplete) if materialized?
+      end
+
       def materialize!
         @materialized = true
+        @instrumenter.start
       end
 
       def materialized?
         @materialized
       end
 
+      def restore!
+        if materialized?
+          incomplete!
+          @materialized = false
+          materialize!
+        end
+      end
+
       def rollback_records
         return unless records
-        ite = records.uniq(&:__id__)
-        already_run_callbacks = {}
-        while record = ite.shift
-          trigger_callbacks = record.trigger_transactional_callbacks?
-          should_run_callbacks = !already_run_callbacks[record] && trigger_callbacks
-          already_run_callbacks[record] ||= trigger_callbacks
+
+        ite = unique_records
+
+        instances_to_run_callbacks_on = prepare_instances_to_run_callbacks_on(ite)
+
+        run_action_on_records(ite, instances_to_run_callbacks_on) do |record, should_run_callbacks|
           record.rolledback!(force_restore_state: full_rollback?, should_run_callbacks: should_run_callbacks)
         end
       ensure
@@ -140,20 +206,38 @@ module ActiveRecord
       end
 
       def before_commit_records
-        records.uniq.each(&:before_committed!) if records && @run_commit_callbacks
+        return unless records
+
+        if @run_commit_callbacks
+          if ActiveRecord.before_committed_on_all_records
+            ite = unique_records
+
+            instances_to_run_callbacks_on = records.each_with_object({}) do |record, candidates|
+              candidates[record] = record
+            end
+
+            run_action_on_records(ite, instances_to_run_callbacks_on) do |record, should_run_callbacks|
+              record.before_committed! if should_run_callbacks
+            end
+          else
+            records.uniq.each(&:before_committed!)
+          end
+        end
       end
 
       def commit_records
         return unless records
-        ite = records.uniq(&:__id__)
-        already_run_callbacks = {}
-        while record = ite.shift
-          if @run_commit_callbacks
-            trigger_callbacks = record.trigger_transactional_callbacks?
-            should_run_callbacks = !already_run_callbacks[record] && trigger_callbacks
-            already_run_callbacks[record] ||= trigger_callbacks
+
+        ite = unique_records
+
+        if @run_commit_callbacks
+          instances_to_run_callbacks_on = prepare_instances_to_run_callbacks_on(ite)
+
+          run_action_on_records(ite, instances_to_run_callbacks_on) do |record, should_run_callbacks|
             record.committed!(should_run_callbacks: should_run_callbacks)
-          else
+          end
+        else
+          while record = ite.shift
             # if not running callbacks, only adds the record to the parent transaction
             connection.add_transaction_record(record)
           end
@@ -166,8 +250,76 @@ module ActiveRecord
       def joinable?; @joinable; end
       def closed?; false; end
       def open?; !closed?; end
+
+      private
+        def unique_records
+          records.uniq(&:__id__)
+        end
+
+        def run_action_on_records(records, instances_to_run_callbacks_on)
+          while record = records.shift
+            should_run_callbacks = record.__id__ == instances_to_run_callbacks_on[record].__id__
+
+            yield record, should_run_callbacks
+          end
+        end
+
+        def prepare_instances_to_run_callbacks_on(records)
+          records.each_with_object({}) do |record, candidates|
+            next unless record.trigger_transactional_callbacks?
+
+            earlier_saved_candidate = candidates[record]
+
+            next if earlier_saved_candidate && record.class.run_commit_callbacks_on_first_saved_instances_in_transaction
+
+            # If the candidate instance destroyed itself in the database, then
+            # instances which were added to the transaction afterwards, and which
+            # think they updated themselves, are wrong. They should not replace
+            # our candidate as an instance to run callbacks on
+            next if earlier_saved_candidate&.destroyed? && !record.destroyed?
+
+            # If the candidate instance was created inside of this transaction,
+            # then instances which were subsequently loaded from the database
+            # and updated need that state transferred to them so that
+            # the after_create_commit callbacks are run
+            record._new_record_before_last_commit = true if earlier_saved_candidate&._new_record_before_last_commit
+
+            # The last instance to save itself is likeliest to have internal
+            # state that matches what's committed to the database
+            candidates[record] = record
+          end
+        end
+    end
+
+    # = Active Record Restart Parent \Transaction
+    class RestartParentTransaction < Transaction
+      def initialize(connection, parent_transaction, **options)
+        super(connection, **options)
+
+        @parent = parent_transaction
+
+        if isolation_level
+          raise ActiveRecord::TransactionIsolationError, "cannot set transaction isolation in a nested transaction"
+        end
+
+        @parent.state.add_child(@state)
+      end
+
+      delegate :materialize!, :materialized?, :restart, to: :@parent
+
+      def rollback
+        @state.rollback!
+        @parent.restart
+      end
+
+      def commit
+        @state.commit!
+      end
+
+      def full_rollback?; false; end
     end
 
+    # = Active Record Savepoint \Transaction
     class SavepointTransaction < Transaction
       def initialize(connection, savepoint_name, parent_transaction, **options)
         super(connection, **options)
@@ -186,19 +338,33 @@ module ActiveRecord
         super
       end
 
+      def restart
+        return unless materialized?
+
+        @instrumenter.finish(:restart)
+        @instrumenter.start
+
+        connection.rollback_to_savepoint(savepoint_name)
+      end
+
       def rollback
-        connection.rollback_to_savepoint(savepoint_name) if materialized?
+        unless @state.invalidated?
+          connection.rollback_to_savepoint(savepoint_name) if materialized?
+        end
         @state.rollback!
+        @instrumenter.finish(:rollback) if materialized?
       end
 
       def commit
         connection.release_savepoint(savepoint_name) if materialized?
         @state.commit!
+        @instrumenter.finish(:commit) if materialized?
       end
 
       def full_rollback?; false; end
     end
 
+    # = Active Record Real \Transaction
     class RealTransaction < Transaction
       def materialize!
         if isolation_level
@@ -210,14 +376,30 @@ module ActiveRecord
         super
       end
 
+      def restart
+        return unless materialized?
+
+        @instrumenter.finish(:restart)
+
+        if connection.supports_restart_db_transaction?
+          @instrumenter.start
+          connection.restart_db_transaction
+        else
+          connection.rollback_db_transaction
+          materialize!
+        end
+      end
+
       def rollback
         connection.rollback_db_transaction if materialized?
         @state.full_rollback!
+        @instrumenter.finish(:rollback) if materialized?
       end
 
       def commit
         connection.commit_db_transaction if materialized?
         @state.full_commit!
+        @instrumenter.finish(:commit) if materialized?
       end
     end
 
@@ -241,21 +423,31 @@ module ActiveRecord
                 joinable: joinable,
                 run_commit_callbacks: run_commit_callbacks
               )
+            elsif current_transaction.restartable?
+              RestartParentTransaction.new(
+                @connection,
+                current_transaction,
+                isolation: isolation,
+                joinable: joinable,
+                run_commit_callbacks: run_commit_callbacks
+              )
             else
               SavepointTransaction.new(
                 @connection,
                 "active_record_#{@stack.size}",
-                @stack.last,
+                current_transaction,
                 isolation: isolation,
                 joinable: joinable,
                 run_commit_callbacks: run_commit_callbacks
               )
             end
 
-          if @connection.supports_lazy_transactions? && lazy_transactions_enabled? && _lazy
-            @has_unmaterialized_transactions = true
-          else
-            transaction.materialize!
+          unless transaction.materialized?
+            if @connection.supports_lazy_transactions? && lazy_transactions_enabled? && _lazy
+              @has_unmaterialized_transactions = true
+            else
+              transaction.materialize!
+            end
           end
           @stack.push(transaction)
           transaction
@@ -275,18 +467,35 @@ module ActiveRecord
         @lazy_transactions_enabled
       end
 
+      def dirty_current_transaction
+        current_transaction.dirty!
+      end
+
+      def restore_transactions
+        return false unless restorable?
+
+        @stack.each(&:restore!)
+
+        true
+      end
+
+      def restorable?
+        @stack.none?(&:dirty?)
+      end
+
       def materialize_transactions
         return if @materializing_transactions
-        return unless @has_unmaterialized_transactions
 
-        @connection.lock.synchronize do
-          begin
-            @materializing_transactions = true
-            @stack.each { |t| t.materialize! unless t.materialized? }
-          ensure
-            @materializing_transactions = false
+        if @has_unmaterialized_transactions
+          @connection.lock.synchronize do
+            begin
+              @materializing_transactions = true
+              @stack.each { |t| t.materialize! unless t.materialized? }
+            ensure
+              @materializing_transactions = false
+            end
+            @has_unmaterialized_transactions = false
           end
-          @has_unmaterialized_transactions = false
         end
       end
 
@@ -300,6 +509,8 @@ module ActiveRecord
             @stack.pop
           end
 
+          dirty_current_transaction if transaction.dirty?
+
           transaction.commit
           transaction.commit_records
         end
@@ -307,8 +518,12 @@ module ActiveRecord
 
       def rollback_transaction(transaction = nil)
         @connection.lock.synchronize do
-          transaction ||= @stack.pop
-          transaction.rollback unless transaction.state.invalidated?
+          transaction ||= @stack.last
+          begin
+            transaction.rollback
+          ensure
+            @stack.pop if @stack.last == transaction
+          end
           transaction.rollback_records
         end
       end
@@ -316,39 +531,53 @@ module ActiveRecord
       def within_new_transaction(isolation: nil, joinable: true)
         @connection.lock.synchronize do
           transaction = begin_transaction(isolation: isolation, joinable: joinable)
-          ret = yield
-          completed = true
-          ret
-        rescue Exception => error
-          if transaction
-            transaction.state.invalidate! if error.is_a? ActiveRecord::TransactionRollbackError
+          begin
+            ret = yield
+            completed = true
+            ret
+          rescue Exception => error
             rollback_transaction
             after_failure_actions(transaction, error)
-          end
 
-          raise
-        ensure
-          if transaction
-            if error
-              # @connection still holds an open or invalid transaction, so we must not
-              # put it back in the pool for reuse.
-              @connection.throw_away! unless transaction.state.rolledback?
-            elsif Thread.current.status == "aborting" || (!completed && transaction.written)
-              # The transaction is still open but the block returned earlier.
-              #
-              # The block could return early because of a timeout or because the thread is aborting,
-              # so we are rolling back to make sure the timeout didn't caused the transaction to be
-              # committed incompletely.
-              rollback_transaction
-            else
-              begin
-                commit_transaction
-              rescue Exception
-                rollback_transaction(transaction) unless transaction.state.completed?
-                raise
+            raise
+          ensure
+            unless error
+              # In 7.1 we enforce timeout >= 0.4.0 which no longer use throw, so we can
+              # go back to the original behavior of committing on non-local return.
+              # If users are using throw, we assume it's not an error case.
+              completed = true if ActiveRecord.commit_transaction_on_non_local_return
+
+              if Thread.current.status == "aborting"
+                rollback_transaction
+              elsif !completed && transaction.written
+                ActiveRecord.deprecator.warn(<<~EOW)
+                  A transaction is being rolled back because the transaction block was
+                  exited using `return`, `break` or `throw`.
+                  In Rails 7.2 this transaction will be committed instead.
+                  To opt-in to the new behavior now and suppress this warning
+                  you can set:
+
+                    Rails.application.config.active_record.commit_transaction_on_non_local_return = true
+                EOW
+                rollback_transaction
+              else
+                begin
+                  commit_transaction
+                rescue ActiveRecord::ConnectionFailed
+                  transaction.invalidate! unless transaction.state.completed?
+                  raise
+                rescue Exception
+                  rollback_transaction(transaction) unless transaction.state.completed?
+                  raise
+                end
               end
             end
           end
+        ensure
+          unless transaction&.state&.completed?
+            @connection.throw_away!
+            transaction&.incomplete!
+          end
         end
       end