activerecord 4.2.9 → 6.1.4.1

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

@@ -1,13 +1,16 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module ConnectionAdapters
     class TransactionState
-      attr_reader :parent
-
-      VALID_STATES = Set.new([:committed, :rolledback, nil])
-
       def initialize(state = nil)
         @state = state
-        @parent = nil
+        @children = nil
+      end
+
+      def add_child(state)
+        @children ||= []
+        @children << state
       end
 
       def finalized?
@@ -15,87 +18,148 @@ module ActiveRecord
       end
 
       def committed?
-        @state == :committed
+        @state == :committed || @state == :fully_committed
+      end
+
+      def fully_committed?
+        @state == :fully_committed
       end
 
       def rolledback?
-        @state == :rolledback
+        @state == :rolledback || @state == :fully_rolledback
+      end
+
+      def fully_rolledback?
+        @state == :fully_rolledback
+      end
+
+      def invalidated?
+        @state == :invalidated
+      end
+
+      def fully_completed?
+        completed?
       end
 
       def completed?
         committed? || rolledback?
       end
 
-      def set_state(state)
-        if !VALID_STATES.include?(state)
-          raise ArgumentError, "Invalid transaction state: #{state}"
-        end
-        @state = state
+      def rollback!
+        @children&.each { |c| c.rollback! }
+        @state = :rolledback
+      end
+
+      def full_rollback!
+        @children&.each { |c| c.rollback! }
+        @state = :fully_rolledback
+      end
+
+      def invalidate!
+        @children&.each { |c| c.invalidate! }
+        @state = :invalidated
+      end
+
+      def commit!
+        @state = :committed
+      end
+
+      def full_commit!
+        @state = :fully_committed
+      end
+
+      def nullify!
+        @state = nil
       end
     end
 
     class NullTransaction #:nodoc:
       def initialize; end
+      def state; end
       def closed?; true; end
       def open?; false; end
       def joinable?; false; end
-      def add_record(record); end
+      def add_record(record, _ = true); end
     end
 
     class Transaction #:nodoc:
+      attr_reader :connection, :state, :savepoint_name, :isolation_level
+      attr_accessor :written
 
-      attr_reader :connection, :state, :records, :savepoint_name
-      attr_writer :joinable
-
-      def initialize(connection, options)
+      def initialize(connection, isolation: nil, joinable: true, run_commit_callbacks: false)
         @connection = connection
         @state = TransactionState.new
-        @records = []
-        @joinable = options.fetch(:joinable, true)
+        @records = nil
+        @isolation_level = isolation
+        @materialized = false
+        @joinable = joinable
+        @run_commit_callbacks = run_commit_callbacks
+        @lazy_enrollment_records = nil
       end
 
-      def add_record(record)
-        records << record
+      def add_record(record, ensure_finalize = true)
+        @records ||= []
+        if ensure_finalize
+          @records << record
+        else
+          @lazy_enrollment_records ||= ObjectSpace::WeakMap.new
+          @lazy_enrollment_records[record] = record
+        end
       end
 
-      def rollback
-        @state.set_state(:rolledback)
+      def records
+        if @lazy_enrollment_records
+          @records.concat @lazy_enrollment_records.values
+          @lazy_enrollment_records = nil
+        end
+        @records
+      end
+
+      def materialize!
+        @materialized = true
+      end
+
+      def materialized?
+        @materialized
       end
 
       def rollback_records
-        ite = records.uniq
+        return unless records
+        ite = records.uniq(&:__id__)
+        already_run_callbacks = {}
         while record = ite.shift
-          begin
-            record.rolledback! full_rollback?
-          rescue => e
-            raise if ActiveRecord::Base.raise_in_transactional_callbacks
-            record.logger.error(e) if record.respond_to?(:logger) && record.logger
-          end
+          trigger_callbacks = record.trigger_transactional_callbacks?
+          should_run_callbacks = !already_run_callbacks[record] && trigger_callbacks
+          already_run_callbacks[record] ||= trigger_callbacks
+          record.rolledback!(force_restore_state: full_rollback?, should_run_callbacks: should_run_callbacks)
         end
       ensure
-        ite.each do |i|
-          i.rolledback!(full_rollback?, false)
+        ite&.each do |i|
+          i.rolledback!(force_restore_state: full_rollback?, should_run_callbacks: false)
         end
       end
 
-      def commit
-        @state.set_state(:committed)
+      def before_commit_records
+        records.uniq.each(&:before_committed!) if records && @run_commit_callbacks
       end
 
       def commit_records
-        ite = records.uniq
+        return unless records
+        ite = records.uniq(&:__id__)
+        already_run_callbacks = {}
         while record = ite.shift
-          begin
-            record.committed!
-          rescue => e
-            raise if ActiveRecord::Base.raise_in_transactional_callbacks
-            record.logger.error(e) if record.respond_to?(:logger) && record.logger
+          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
+            record.committed!(should_run_callbacks: should_run_callbacks)
+          else
+            # if not running callbacks, only adds the record to the parent transaction
+            connection.add_transaction_record(record)
           end
         end
       ensure
-        ite.each do |i|
-          i.committed!(false)
-        end
+        ite&.each { |i| i.committed!(should_run_callbacks: false) }
       end
 
       def full_rollback?; true; end
@@ -105,52 +169,55 @@ module ActiveRecord
     end
 
     class SavepointTransaction < Transaction
+      def initialize(connection, savepoint_name, parent_transaction, **options)
+        super(connection, **options)
 
-      def initialize(connection, savepoint_name, options)
-        super(connection, options)
-        if options[:isolation]
+        parent_transaction.state.add_child(@state)
+
+        if isolation_level
           raise ActiveRecord::TransactionIsolationError, "cannot set transaction isolation in a nested transaction"
         end
-        connection.create_savepoint(@savepoint_name = savepoint_name)
+
+        @savepoint_name = savepoint_name
       end
 
-      def rollback
-        connection.rollback_to_savepoint(savepoint_name)
+      def materialize!
+        connection.create_savepoint(savepoint_name)
         super
-        rollback_records
+      end
+
+      def rollback
+        connection.rollback_to_savepoint(savepoint_name) if materialized?
+        @state.rollback!
       end
 
       def commit
-        connection.release_savepoint(savepoint_name)
-        super
-        parent = connection.transaction_manager.current_transaction
-        records.each { |r| parent.add_record(r) }
+        connection.release_savepoint(savepoint_name) if materialized?
+        @state.commit!
       end
 
       def full_rollback?; false; end
     end
 
     class RealTransaction < Transaction
-
-      def initialize(connection, options)
-        super
-        if options[:isolation]
-          connection.begin_isolated_db_transaction(options[:isolation])
+      def materialize!
+        if isolation_level
+          connection.begin_isolated_db_transaction(isolation_level)
         else
           connection.begin_db_transaction
         end
+
+        super
       end
 
       def rollback
-        connection.rollback_db_transaction
-        super
-        rollback_records
+        connection.rollback_db_transaction if materialized?
+        @state.full_rollback!
       end
 
       def commit
-        connection.commit_db_transaction
-        super
-        commit_records
+        connection.commit_db_transaction if materialized?
+        @state.full_commit!
       end
     end
 
@@ -158,43 +225,135 @@ module ActiveRecord
       def initialize(connection)
         @stack = []
         @connection = connection
+        @has_unmaterialized_transactions = false
+        @materializing_transactions = false
+        @lazy_transactions_enabled = true
       end
 
-      def begin_transaction(options = {})
-        transaction =
-          if @stack.empty?
-            RealTransaction.new(@connection, options)
+      def begin_transaction(isolation: nil, joinable: true, _lazy: true)
+        @connection.lock.synchronize do
+          run_commit_callbacks = !current_transaction.joinable?
+          transaction =
+            if @stack.empty?
+              RealTransaction.new(
+                @connection,
+                isolation: isolation,
+                joinable: joinable,
+                run_commit_callbacks: run_commit_callbacks
+              )
+            else
+              SavepointTransaction.new(
+                @connection,
+                "active_record_#{@stack.size}",
+                @stack.last,
+                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
-            SavepointTransaction.new(@connection, "active_record_#{@stack.size}", options)
+            transaction.materialize!
+          end
+          @stack.push(transaction)
+          transaction
+        end
+      end
+
+      def disable_lazy_transactions!
+        materialize_transactions
+        @lazy_transactions_enabled = false
+      end
+
+      def enable_lazy_transactions!
+        @lazy_transactions_enabled = true
+      end
+
+      def lazy_transactions_enabled?
+        @lazy_transactions_enabled
+      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
           end
-        @stack.push(transaction)
-        transaction
+          @has_unmaterialized_transactions = false
+        end
       end
 
       def commit_transaction
-        @stack.pop.commit
+        @connection.lock.synchronize do
+          transaction = @stack.last
+
+          begin
+            transaction.before_commit_records
+          ensure
+            @stack.pop
+          end
+
+          transaction.commit
+          transaction.commit_records
+        end
       end
 
-      def rollback_transaction
-        @stack.pop.rollback
+      def rollback_transaction(transaction = nil)
+        @connection.lock.synchronize do
+          transaction ||= @stack.pop
+          transaction.rollback unless transaction.state.invalidated?
+          transaction.rollback_records
+        end
       end
 
-      def within_new_transaction(options = {})
-        transaction = begin_transaction options
-        yield
-      rescue Exception => error
-        rollback_transaction if transaction
-        raise
-      ensure
-        unless error
-          if Thread.current.status == 'aborting'
-            rollback_transaction if transaction
-          else
-            begin
-              commit_transaction
-            rescue Exception
-              transaction.rollback unless transaction.state.completed?
-              raise
+      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
+            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?
+            else
+              if Thread.current.status == "aborting"
+                rollback_transaction
+              else
+                if !completed && transaction.written
+                  ActiveSupport::Deprecation.warn(<<~EOW)
+                    Using `return`, `break` or `throw` to exit a transaction block is
+                    deprecated without replacement. If the `throw` came from
+                    `Timeout.timeout(duration)`, pass an exception class as a second
+                    argument so it doesn't use `throw` to abort its block. This results
+                    in the transaction being committed, but in the next release of Rails
+                    it will rollback.
+                  EOW
+                end
+                begin
+                  commit_transaction
+                rescue Exception
+                  rollback_transaction(transaction) unless transaction.state.completed?
+                  raise
+                end
+              end
             end
           end
         end
@@ -210,6 +369,13 @@ module ActiveRecord
 
       private
         NULL_TRANSACTION = NullTransaction.new
+
+        # Deallocate invalidated prepared statements outside of the transaction
+        def after_failure_actions(transaction, error)
+          return unless transaction.is_a?(RealTransaction)
+          return unless error.is_a?(ActiveRecord::PreparedStatementCacheExpired)
+          @connection.clear_cache!
+        end
     end
   end
 end