<form method="POST">
    <h3>Editing: ManagesTransactions.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php

namespace Illuminate\Database\Concerns;

use Closure;
use RuntimeException;
use Throwable;

trait ManagesTransactions
{
    /**
     * Execute a Closure within a transaction.
     *
     * @param  \Closure  $callback
     * @param  int  $attempts
     * @return mixed
     *
     * @throws \Throwable
     */
    public function transaction(Closure $callback, $attempts = 1)
    {
        for ($currentAttempt = 1; $currentAttempt &lt;= $attempts; $currentAttempt++) {
            $this-&gt;beginTransaction();

            // We'll simply execute the given callback within a try / catch block and if we
            // catch any exception we can rollback this transaction so that none of this
            // gets actually persisted to a database or stored in a permanent fashion.
            try {
                $callbackResult = $callback($this);
            }

            // If we catch an exception we'll rollback this transaction and try again if we
            // are not out of attempts. If we are out of attempts we will just throw the
            // exception back out and let the developer handle an uncaught exceptions.
            catch (Throwable $e) {
                $this-&gt;handleTransactionException(
                    $e, $currentAttempt, $attempts
                );

                continue;
            }

            try {
                if ($this-&gt;transactions == 1) {
                    $this-&gt;getPdo()-&gt;commit();
                }

                $this-&gt;transactions = max(0, $this-&gt;transactions - 1);

                if ($this-&gt;transactions == 0) {
                    optional($this-&gt;transactionsManager)-&gt;commit($this-&gt;getName());
                }
            } catch (Throwable $e) {
                $this-&gt;handleCommitTransactionException(
                    $e, $currentAttempt, $attempts
                );

                continue;
            }

            $this-&gt;fireConnectionEvent('committed');

            return $callbackResult;
        }
    }

    /**
     * Handle an exception encountered when running a transacted statement.
     *
     * @param  \Throwable  $e
     * @param  int  $currentAttempt
     * @param  int  $maxAttempts
     * @return void
     *
     * @throws \Throwable
     */
    protected function handleTransactionException(Throwable $e, $currentAttempt, $maxAttempts)
    {
        // On a deadlock, MySQL rolls back the entire transaction so we can't just
        // retry the query. We have to throw this exception all the way out and
        // let the developer handle it in another way. We will decrement too.
        if ($this-&gt;causedByConcurrencyError($e) &amp;&amp;
            $this-&gt;transactions &gt; 1) {
            $this-&gt;transactions--;

            optional($this-&gt;transactionsManager)-&gt;rollback(
                $this-&gt;getName(), $this-&gt;transactions
            );

            throw $e;
        }

        // If there was an exception we will rollback this transaction and then we
        // can check if we have exceeded the maximum attempt count for this and
        // if we haven't we will return and try this query again in our loop.
        $this-&gt;rollBack();

        if ($this-&gt;causedByConcurrencyError($e) &amp;&amp;
            $currentAttempt &lt; $maxAttempts) {
            return;
        }

        throw $e;
    }

    /**
     * Start a new database transaction.
     *
     * @return void
     *
     * @throws \Throwable
     */
    public function beginTransaction()
    {
        $this-&gt;createTransaction();

        $this-&gt;transactions++;

        optional($this-&gt;transactionsManager)-&gt;begin(
            $this-&gt;getName(), $this-&gt;transactions
        );

        $this-&gt;fireConnectionEvent('beganTransaction');
    }

    /**
     * Create a transaction within the database.
     *
     * @return void
     *
     * @throws \Throwable
     */
    protected function createTransaction()
    {
        if ($this-&gt;transactions == 0) {
            $this-&gt;reconnectIfMissingConnection();

            try {
                $this-&gt;getPdo()-&gt;beginTransaction();
            } catch (Throwable $e) {
                $this-&gt;handleBeginTransactionException($e);
            }
        } elseif ($this-&gt;transactions &gt;= 1 &amp;&amp; $this-&gt;queryGrammar-&gt;supportsSavepoints()) {
            $this-&gt;createSavepoint();
        }
    }

    /**
     * Create a save point within the database.
     *
     * @return void
     *
     * @throws \Throwable
     */
    protected function createSavepoint()
    {
        $this-&gt;getPdo()-&gt;exec(
            $this-&gt;queryGrammar-&gt;compileSavepoint('trans'.($this-&gt;transactions + 1))
        );
    }

    /**
     * Handle an exception from a transaction beginning.
     *
     * @param  \Throwable  $e
     * @return void
     *
     * @throws \Throwable
     */
    protected function handleBeginTransactionException(Throwable $e)
    {
        if ($this-&gt;causedByLostConnection($e)) {
            $this-&gt;reconnect();

            $this-&gt;getPdo()-&gt;beginTransaction();
        } else {
            throw $e;
        }
    }

    /**
     * Commit the active database transaction.
     *
     * @return void
     *
     * @throws \Throwable
     */
    public function commit()
    {
        if ($this-&gt;transactions == 1) {
            $this-&gt;getPdo()-&gt;commit();
        }

        $this-&gt;transactions = max(0, $this-&gt;transactions - 1);

        if ($this-&gt;transactions == 0) {
            optional($this-&gt;transactionsManager)-&gt;commit($this-&gt;getName());
        }

        $this-&gt;fireConnectionEvent('committed');
    }

    /**
     * Handle an exception encountered when committing a transaction.
     *
     * @param  \Throwable  $e
     * @param  int  $currentAttempt
     * @param  int  $maxAttempts
     * @return void
     *
     * @throws \Throwable
     */
    protected function handleCommitTransactionException(Throwable $e, $currentAttempt, $maxAttempts)
    {
        $this-&gt;transactions = max(0, $this-&gt;transactions - 1);

        if ($this-&gt;causedByConcurrencyError($e) &amp;&amp;
            $currentAttempt &lt; $maxAttempts) {
            return;
        }

        if ($this-&gt;causedByLostConnection($e)) {
            $this-&gt;transactions = 0;
        }

        throw $e;
    }

    /**
     * Rollback the active database transaction.
     *
     * @param  int|null  $toLevel
     * @return void
     *
     * @throws \Throwable
     */
    public function rollBack($toLevel = null)
    {
        // We allow developers to rollback to a certain transaction level. We will verify
        // that this given transaction level is valid before attempting to rollback to
        // that level. If it's not we will just return out and not attempt anything.
        $toLevel = is_null($toLevel)
                    ? $this-&gt;transactions - 1
                    : $toLevel;

        if ($toLevel &lt; 0 || $toLevel &gt;= $this-&gt;transactions) {
            return;
        }

        // Next, we will actually perform this rollback within this database and fire the
        // rollback event. We will also set the current transaction level to the given
        // level that was passed into this method so it will be right from here out.
        try {
            $this-&gt;performRollBack($toLevel);
        } catch (Throwable $e) {
            $this-&gt;handleRollBackException($e);
        }

        $this-&gt;transactions = $toLevel;

        optional($this-&gt;transactionsManager)-&gt;rollback(
            $this-&gt;getName(), $this-&gt;transactions
        );

        $this-&gt;fireConnectionEvent('rollingBack');
    }

    /**
     * Perform a rollback within the database.
     *
     * @param  int  $toLevel
     * @return void
     *
     * @throws \Throwable
     */
    protected function performRollBack($toLevel)
    {
        if ($toLevel == 0) {
            $this-&gt;getPdo()-&gt;rollBack();
        } elseif ($this-&gt;queryGrammar-&gt;supportsSavepoints()) {
            $this-&gt;getPdo()-&gt;exec(
                $this-&gt;queryGrammar-&gt;compileSavepointRollBack('trans'.($toLevel + 1))
            );
        }
    }

    /**
     * Handle an exception from a rollback.
     *
     * @param  \Throwable  $e
     * @return void
     *
     * @throws \Throwable
     */
    protected function handleRollBackException(Throwable $e)
    {
        if ($this-&gt;causedByLostConnection($e)) {
            $this-&gt;transactions = 0;

            optional($this-&gt;transactionsManager)-&gt;rollback(
                $this-&gt;getName(), $this-&gt;transactions
            );
        }

        throw $e;
    }

    /**
     * Get the number of active transactions.
     *
     * @return int
     */
    public function transactionLevel()
    {
        return $this-&gt;transactions;
    }

    /**
     * Execute the callback after a transaction commits.
     *
     * @param  callable  $callback
     * @return void
     *
     * @throws \RuntimeException
     */
    public function afterCommit($callback)
    {
        if ($this-&gt;transactionsManager) {
            return $this-&gt;transactionsManager-&gt;addCallback($callback);
        }

        throw new RuntimeException('Transactions Manager has not been set.');
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>