When it comes to web application development, one of the biggest challenges for startups and enterprises alike is handling databases efficiently.
Laravel, a leading PHP framework, solves this by providing built-in support for MySQL and PostgreSQL. Its modern toolset — including Eloquent ORM, Query Builder, migrations, and seeding — allows developers to work with databases easily while ensuring scalability and maintainability.
As an Official Laravel Partner, Acquaint Softtech helps businesses leverage these features to build powerful, database-driven applications. Let’s break down how Laravel interacts with MySQL and PostgreSQL.
Database Configuration
Before Laravel can interact with a database, it needs to be configured. This involves setting up the database connection parameters in the config/database.php file. For MySQL and PostgreSQL, the configuration might look like this:
php
'mysql' => [
'driver' => 'mysql',
'host' => env('DB_HOST', '127.0.0.1'),
'port' => env('DB_PORT', '3306'),
'database' => env('DB_DATABASE', 'forge'),
'username' => env('DB_USERNAME', 'forge'),
'password' => env('DB_PASSWORD', ''),
'unix_socket' => env('DB_SOCKET', ''),
'charset' => 'utf8mb4',
'collation' => 'utf8mb4_unicode_ci',
'prefix' => '',
'strict' => true,
'engine' => null,
],
'pgsql' => [
'driver' => 'pgsql',
'host' => env('DB_HOST', '127.0.0.1'),
'port' => env('DB_PORT', '5432'),
'database' => env('DB_DATABASE', 'forge'),
'username' => env('DB_USERNAME', 'forge'),
'password' => env('DB_PASSWORD', ''),
'charset' => 'utf8',
'prefix' => '',
'schema' => 'public',
'sslmode' => 'prefer',
]
These settings tell Laravel how to connect to your MySQL or PostgreSQL database by providing the necessary credentials and connection details.
Eloquent ORM: Simplified Database Interaction
Laravel’s Eloquent ORM is one of its most powerful features. Instead of writing raw SQL, developers interact with data using object-oriented models.
Example: A User model represents the users table. With Eloquent, you can:
Create a user with $user->save()
Fetch records with User::all()
Update with $user->update()
Delete with $user->delete()
This makes database interaction intuitive and developer-friendly.
Defining Models
For example, to interact with a users table, you would create a User model:
php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
class User extends Model
{
// The table associated with the model.
protected $table = 'users';
// The attributes that are mass assignable.
protected $fillable = ['name', 'email', 'password'];
}
CRUD Operations
Eloquent provides a simple, expressive syntax for performing CRUD (Create, Read, Update, Delete) operations:
Create
php
$user = new User;
$user->name = 'John Doe';
$user->email = 'john@example.com';
$user->password = bcrypt('secret');
$user->save();
```
Read
php
$users = User::all(); // Retrieves all users
$user = User::find(1); // Retrieves a user by primary key
Update
php
$user = User::find(1);
$user->email = 'john.doe@example.com';
$user->save();
```
Delete
php
$user = User::find(1);
$user->delete();
```
Query Builder
Laravel also offers a fluent query builder for those who prefer to write SQL-like queries. This builder provides a more direct way to interact with the database:
Select
php
$users = DB::table('users')->get();
Insert
php
DB::table('users')->insert([
'name' => 'John Doe',
'email' => 'john@example.com',
'password' => bcrypt('secret')
]);
Update
```php
DB::table('users')
->where('id', 1)
->update(['email' => 'john.doe@example.com']);
Delete
```php
DB::table('users')->where('id', 1)->delete();
Database Migrations
Migrations are like version control for your database, allowing you to define and share the application's database schema. Migrations are typically stored in the database/migrations directory.
Creating Migrations
You can create a new migration using the Artisan command:
bash
php artisan make:migration create_users_table
This command generates a migration file where you can define the table structure:
php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
class CreateUsersTable extends Migration
{
public function up()
{
Schema::create('users', function (Blueprint $table) {
$table->id();
$table->string('name');
$table->string('email')->unique();
$table->timestamp('email_verified_at')->nullable();
$table->string('password');
$table->rememberToken();
$table->timestamps();
});
}
public function down()
{
Schema::dropIfExists('users');
}
}
Running Migrations
To apply the migrations and create the tables in your database, you use:
bash
php artisan migrate
Database Seeding
Laravel provides a convenient way to seed your database with test data using seed classes. Seeders are stored in the database/seeders directory.
Creating Seeders
You can create a new seeder using the Artisan command:
```bash
php artisan make:seeder UsersTableSeeder
```
Within the seeder, you can define how to populate the users table with data:
```php
use Illuminate\Database\Seeder;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;
class UsersTableSeeder extends Seeder
{
public function run()
{
DB::table('users')->insert([
'name' => 'John Doe',
'email' => 'john@example.com',
'password' => Hash::make('password'),
]);
}
}
Running Seeders
To execute the seeders and insert data into the database, you use:
bash
php artisan db:seed --class=UsersTableSeeder
Conclusion
Laravel’s seamless integration with MySQL and PostgreSQL empowers developers to build applications that are scalable, maintainable, and future-ready.
From Eloquent ORM for simplicity to migrations and seeding for efficiency, Laravel provides all the tools needed to manage databases with ease.
At Acquaint Softtech, our dedicated Laravel developers specialize in building and scaling apps with robust MySQL and PostgreSQL setups. Whether you need a new app, database optimization, or migration — our remote teams deliver on time and within budget.
