Working with Transactions in Laravel

Transactions in Laravel provide a powerful way to handle database operations safely and ensure data integrity, especially when working with multiple related operations. This blog explores how to use transactions effectively in Laravel.

What is a Transaction?

A transaction is a sequence of database operations executed as a single unit of work. If one operation fails, all changes made during the transaction are rolled back, ensuring no partial data is stored.

Basic Usage of Transactions

Laravel provides a simple method to use transactions via the DB facade.

use Illuminate\Support\Facades\DB;

DB::transaction(function () {
    DB::table('users')->update(['status' => 'active']);
    DB::table('orders')->update(['status' => 'completed']);
});

Explanation:

• All database operations inside the closure are executed as a single transaction.
• If any error occurs, changes will be rolled back.

Handling Rollbacks Manually

You can also control transactions manually using beginTransaction, commit, and rollBack methods.

use Illuminate\Support\Facades\DB;

DB::beginTransaction();

try {
    DB::table('users')->update(['status' => 'active']);
    DB::table('orders')->update(['status' => 'completed']);
    DB::commit();
} catch (Exception $e) {
    DB::rollBack();
    throw $e;
}

Explanation:

• beginTransaction starts a transaction.
• commit commits the changes if everything is successful.
• rollBack reverts changes if an exception occurs.

Transactions with Eloquent

Transactions can also be used with Eloquent models.

use App\Models\User;
use Illuminate\Support\Facades\DB;

DB::transaction(function () {
    $user = User::find(1);
    $user->update(['status' => 'active']);
    $user->orders()->update(['status' => 'completed']);
});

Nested Transactions

Laravel also supports nested transactions.

DB::transaction(function () {
    DB::transaction(function () {
        DB::table('users')->update(['status' => 'pending']);
    });
    DB::table('orders')->update(['status' => 'completed']);
});

Explanation:

• Inner transactions will only commit if the outer transaction completes successfully.

Using Savepoints

You can use DB::savepoint for finer control in nested transactions.

DB::beginTransaction();
try {
    DB::table('users')->update(['status' => 'active']);
    DB::savepoint('sp1');

    DB::table('orders')->update(['status' => 'completed']);
    DB::rollbackToSavepoint('sp1');

    DB::commit();
} catch (Exception $e) {
    DB::rollBack();
}

Explanation:

• Savepoints allow partial rollbacks within a transaction.

Using lockForUpdate

The lockForUpdate() method prevents other transactions from modifying the selected rows until the current transaction is committed. This is useful when you need to ensure data consistency while performing updates or processing critical data.

use Illuminate\Support\Facades\DB;
use App\Models\User;

DB::transaction(function () {
    $user = User::where('status', 'pending')->lockForUpdate()->first();
    $user->update(['status' => 'active']);
});

Explanation:

• The lockForUpdate method locks the selected rows for the duration of the transaction.
• Other transactions attempting to modify the same rows will be blocked until the current transaction is completed.

Best Practices

• Keep Transactions Short: Minimize the number of operations within a transaction to avoid lock issues.
• Handle Exceptions Properly: Always catch exceptions and ensure transactions are rolled back.
• Use Database Constraints: Transactions do not replace proper database constraints like foreign keys.

Conclusion

Laravel provides a powerful and flexible way to work with transactions, whether using the DB facade or Eloquent. Understanding transactions can help you ensure data integrity and consistency in your applications.