Class: ActiveRecord::ConnectionAdapters::TransactionManager

# File 'activerecord/lib/active_record/connection_adapters/abstract/transaction.rb', line 573

def restorable?
  @stack.none?(&:dirty?)
end

# File 'activerecord/lib/active_record/connection_adapters/abstract/transaction.rb', line 506

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
        )
      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}",
          current_transaction,
          isolation: isolation,
          joinable: joinable,
          run_commit_callbacks: run_commit_callbacks
        )
      end

    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
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract/transaction.rb', line 593

def commit_transaction
  @connection.lock.synchronize do
    transaction = @stack.last

    begin
      transaction.before_commit_records
    ensure
      @stack.pop
    end

    dirty_current_transaction if transaction.dirty?

    transaction.commit
    transaction.commit_records
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract/transaction.rb', line 661

def current_transaction
  @stack.last || NULL_TRANSACTION
end

# File 'activerecord/lib/active_record/connection_adapters/abstract/transaction.rb', line 561

def dirty_current_transaction
  current_transaction.dirty!
end

# File 'activerecord/lib/active_record/connection_adapters/abstract/transaction.rb', line 548

def disable_lazy_transactions!
  materialize_transactions
  @lazy_transactions_enabled = false
end

# File 'activerecord/lib/active_record/connection_adapters/abstract/transaction.rb', line 553

def enable_lazy_transactions!
  @lazy_transactions_enabled = true
end

# File 'activerecord/lib/active_record/connection_adapters/abstract/transaction.rb', line 577

def materialize_transactions
  return if @materializing_transactions

  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
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract/transaction.rb', line 657

def open_transactions
  @stack.size
end

# File 'activerecord/lib/active_record/connection_adapters/abstract/transaction.rb', line 565

def restore_transactions
  return false unless restorable?

  @stack.each(&:restore!)

  true
end

# File 'activerecord/lib/active_record/connection_adapters/abstract/transaction.rb', line 610

def rollback_transaction(transaction = nil)
  @connection.lock.synchronize do
    transaction ||= @stack.last
    begin
      transaction.rollback
    ensure
      @stack.pop if @stack.last == transaction
    end
    transaction.rollback_records
  end
end

# File 'activerecord/lib/active_record/connection_adapters/abstract/transaction.rb', line 622

def within_new_transaction(isolation: nil, joinable: true)
  @connection.lock.synchronize do
    transaction = begin_transaction(isolation: isolation, joinable: joinable)
    begin
      yield transaction.user_transaction
    rescue Exception => error
      rollback_transaction
      after_failure_actions(transaction, error)

      raise
    ensure
      unless error
        if Thread.current.status == "aborting"
          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