![1.png](https://blog.radicalloop.com/uploads/1_4301b51fa1.png)

Sometimes we require to do **bulk** **insert/update/delete** operation in database, or chained database operations, and if any exception occurs at any step, it should not perform any database operation in the chain.

“Transactions” gives us power to commit a group of database operations, like bulk insert, or rollback the entire transaction if any error occurs.
Laravel provides very easy API for Transaction. Recently, we needed to parse multiple CSV files having around 50k records each, where it should delete all records first and then insert all records in database.

Laravel provides DB::beginTransaction() method to begin transaction and within try — catch block, to commit the transaction DB::commit() and to undo / rollback, we have DB::rollback(). Here is a simple example showing how to use [Transactions in Laravel](https://laravel.com/docs/5.5/database#database-transactions).

```php
use Eod;

$exchange = Eod::exchange();

// Save CSV to specific path
$exchange->symbol($this->exchangeCode)->save(storage_path($csvPath), true);
$exchangeSymbol = fopen(storage_path($csvPath), 'r');

if ($exchangeSymbol !== false) 
{
    // Begin Transaction
    DB::beginTransaction();
  
    try 
    {
        // Delete data from table
        $securities = AllSecurity::where('country', $this->exchangeCode)->delete();
        $rowData = [];
        
        // Read CSV
        while (($data = fgetcsv($exchangeSymbol)) !== false) 
        {
            if (isset($data[1])) 
            {
                $symbol_ticker = $data[0] . '.' . $data[2];

                $rowData[] = [
                    'symbol' => $data[0],
                    'name' => $data[1],
                    'country' => $data[2],
                    'exchange' => $data[3],
                    'currency' => $data[4],
                    'symbol_ticker' => $symbol_ticker,
                    'created_at' => $now,
                    'updated_at' => $now,
                ];

                if (count($rowData) == 10000) 
                {
                    DB::table('all_securities')->insert($rowData);
                    unset($rowData);
                }
            }
        }

        if (isset($rowData) && count($rowData) > 0) 
        {
            DB::table('all_securities')->insert($rowData);
            unset($rowData);
        }
        
        // Commit Transaction
        DB::commit();
    } catch (\Exception $e) {
        // Rollback Transaction
        DB::rollback();
    }
  
    fclose($exchangeSymbol);
}
```

As you might note, we insert bunches of 10,000 records. We can change this limit as per our need / database server.

So here in our example, if any exception gets thrown at delete operation or any insert operation in the while loop, the transaction is rolled-back in the catch block, and none of the database changes occur. And if all goes well, we commit the transaction.

So, next time thinking to use Transactions in your Laravel project? All the best!
Any questions or suggestions? please comment!


----------


[RadicalLoop](https://www.radicalloop.com) is a web development company. Follow RadicalLoop on [Twitter](https://twitter.com/radicalloop), [Facebook](https://www.facebook.com/radicalloop). ?

large_1.png

medium_1.png

small_1.png

thumbnail_1.png

1.png

Sometimes we require to do bulk insert/update/delete operation in database, or chained database operations, and if any exception occurs at 

Database Transactions in Laravel

Radicalloop