How does Laravel handle transactional integrity across multiple database connections

Using the `DB` Facade

The `DB` facade in Laravel provides a `transaction()` method that allows you to wrap database operations in a transaction. This method will automatically handle the transaction across the default database connection.

php
DB::transaction(function () {
    // Database operations here
});

Specifying a Connection

If you need to use a specific database connection for the transaction, you can pass the connection name as the second argument to the `DB::transaction()` method.

php
DB::connection('mysql')->transaction(function () {
    // Database operations here
});

Manually Managing Transactions

You can also manually start, commit, and rollback transactions using the `DB` facade methods:

php
DB::beginTransaction();

try {
    // Database operations here
    DB::commit();
} catch (\Exception $e) {
    DB::rollBack();
    throw $e;
}

This approach gives you more control over the transaction lifecycle, but you need to handle the commit and rollback logic yourself.

Transactions Across Multiple Connections

If you need to perform transactions across multiple database connections, you can use the `DB::transaction()` method and specify the connections you want to use.

php
DB::transaction(function () {
    DB::connection('mysql')->table('users')->insert([...]);
    DB::connection('pgsql')->table('logs')->insert([...]);
});

In this example, the transaction will span both the `mysql` and `pgsql` connections, ensuring that all operations are executed as a single atomic unit.

Handling Deadlocks

The `DB::transaction()` method accepts an optional second argument that defines the number of times a transaction should be reattempted when a deadlock occurs. Once these attempts have been exhausted, an exception will be thrown.

php
DB::transaction(function () {
    // Database operations here
}, 5);

By using the `DB` facade and its transaction-related methods, you can easily manage database transactions in Laravel, regardless of the underlying database driver or connection being used. This ensures transactional integrity across multiple database connections.