Databaseconfiguratie

Aan de slag

Laravel ondersteunt officieel de volgende databases:

MySQL / MariaDB
PostgreSQL
SQLite
SQL Server

Je kunt dezelfde verbindingsconfiguratie gebruiken met rauwe SQL, de Query Builder of Eloquent ORM.

Deze pagina behandelt de basis van databaseverbindingen. Zie Query Builder voor praktische queries, Migrations voor schemabeheer en Seeding voor het inladen van initiële data.

Configuratie

De databaseconfiguratie is gecentraliseerd in config/database.php. Met default kies je de standaardverbindingsnaam en met connections definieer je de details per verbinding.

// config/database.php
'default' => env('DB_CONNECTION', 'sqlite'),

'connections' => [
    'mysql' => [
        'driver' => 'mysql',
        'host' => env('DB_HOST', '127.0.0.1'),
        'port' => env('DB_PORT', '3306'),
        'database' => env('DB_DATABASE', 'laravel'),
        'username' => env('DB_USERNAME', 'root'),
        'password' => env('DB_PASSWORD', ''),
    ],
],

Stel in .env minimaal het volgende in:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=app
DB_USERNAME=app_user
DB_PASSWORD=secret

Gebruik je SQLite, stel dan DB_CONNECTION=sqlite en het pad in DB_DATABASE in.

Lees- en schrijfverbindingen scheiden

Wil je lezen (SELECT) en schrijven (INSERT / UPDATE / DELETE) naar aparte hosts scheiden, configureer dan read en write binnen dezelfde verbinding.

'mysql' => [
    'driver' => 'mysql',
    'read' => [
        'host' => ['10.0.0.10', '10.0.0.11'],
    ],
    'write' => [
        'host' => ['10.0.0.20'],
    ],
    'sticky' => true,

    'port' => env('DB_PORT', '3306'),
    'database' => env('DB_DATABASE', 'laravel'),
    'username' => env('DB_USERNAME', 'root'),
    'password' => env('DB_PASSWORD', ''),
],

Als je sticky op true zet, worden leesbewerkingen na een schrijfbewerking binnen hetzelfde request vastgezet op de write-verbinding.

In opstellingen met replica-vertraging verlaag je met sticky het risico om vlak na een schrijfbewerking verouderde data te lezen.

Verouderde leesbewerkingen ook in volgende requests voorkomen

sticky werkt alleen binnen hetzelfde request. Wil je ook in volgende requests binnen dezelfde sessie de zojuist geschreven data lezen, voeg dan de middleware PreventStaleDatabaseReads toe aan de middlewaregroep web.

use Illuminate\Foundation\Configuration\Middleware;
use Illuminate\Foundation\Http\Middleware\PreventStaleDatabaseReads;

->withMiddleware(function (Middleware $middleware): void {
    $middleware->web(append: [
        PreventStaleDatabaseReads::class,
    ]);
})

De middleware legt schrijfbewerkingen op de standaard databaseverbinding vast in de sessie. Standaard gebruiken requests binnen 2 seconden na een schrijfbewerking de write-verbinding voor leesbewerkingen op die verbinding. Gebruik for om de duur te wijzigen.

$middleware->web(append: [
    PreventStaleDatabaseReads::for(5),
]);

Omdat deze middleware afhankelijk is van de sessie, moet hij na de middleware StartSession worden uitgevoerd. Leesbewerkingen van andere sessies of andere databaseverbindingen worden niet beïnvloed.

Tijdelijk lezen via de write-verbinding

Gebruik de methode usingWritePdo van de verbinding om leesbewerkingen binnen een callback vast te zetten op de write-verbinding.

use Illuminate\Support\Facades\DB;

$users = DB::connection()->usingWritePdo(
    fn ($connection) => $connection->table('users')->get(),
);

Dit geldt ook voor Eloquent- en relationship-queries die binnen de callback dezelfde verbinding gebruiken. Zodra de callback klaar is, wordt de leesinstelling van de verbinding hersteld, ongeacht of er een exception is opgetreden.

Pooled PostgreSQL-verbindingen

Gebruik je een managed PostgreSQL-service die connection pooling in transactiemodus biedt, zoals PgBouncer, stel dan de opties pooled en direct in.

'pgsql' => [
    'driver' => 'pgsql',
    // ...
    'pooled' => env('DB_POOLED', false),
    'direct' => array_filter([
        'host' => env('DB_DIRECT_HOST'),
        'port' => env('DB_DIRECT_PORT'),
        'username' => env('DB_DIRECT_USERNAME'),
        'password' => env('DB_DIRECT_PASSWORD'),
        'sslmode' => env('DB_DIRECT_SSLMODE'),
    ]),
],

Als je pooled inschakelt, verdeelt Laravel automatisch:

Operatie	Gebruikte verbinding
Applicatiequeries	pooled (geëmuleerde prepares automatisch ingeschakeld)
Migraties / `db:wipe` / `db:show` / `db:table`	direct (automatisch)
`php artisan db`	direct (standaard), met `--pooled` overschakelen naar pooled

Wil je in applicatiecode expliciet de directe verbinding gebruiken, voeg dan de suffix ::direct toe aan de verbindingsnaam.

DB::connection('pgsql::direct')->statement('create extension if not exists "uuid-ossp"');

Meerdere databaseverbindingen

Je kunt in config/database.php meerdere verbindingen definiëren en wisselen met DB::connection().

use Illuminate\Support\Facades\DB;

$users = DB::connection('sqlite')->select('select * from users');
$pdo = DB::connection('pgsql')->getPdo();

SQL-queries uitvoeren

De DB-facade heeft speciale methoden per type query.

use Illuminate\Support\Facades\DB;

$users = DB::select('select * from users where active = ?', [1]);

DB::insert('insert into users (name, email) values (?, ?)', ['Taylor', '[email protected]']);

$affected = DB::update('update users set votes = 100 where name = ?', ['Taylor']);

$deleted = DB::delete('delete from sessions where user_id = ?', [1]);

DB::statement('drop table temporary_imports');

Plak nooit gebruikersinvoer rechtstreeks in een SQL-string. Gebruik altijd bindingargumenten om SQL-injectie te voorkomen.

Query-listening

Wil je uitgevoerde SQL volgen, registreer dan DB::listen() in de boot() van een serviceprovider.

use Illuminate\Database\Events\QueryExecuted;
use Illuminate\Support\Facades\DB;

public function boot(): void
{
    DB::listen(function (QueryExecuted $query) {
        logger()->debug('SQL executed', [
            'sql' => $query->toRawSql(),
            'time_ms' => $query->time,
        ]);
    });
}

Transacties

Wil je meerdere updates als één geheel behandelen, gebruik dan DB::transaction(). Bij een exception voert Laravel automatisch een rollback uit.

use Illuminate\Support\Facades\DB;

DB::transaction(function () {
    DB::update('update users set votes = 1');
    DB::delete('delete from posts where archived = 1');
});

Heb je herhaalpogingen bij deadlocks nodig, dan kun je attempts opgeven.

DB::transaction(function () {
    // ...
}, attempts: 5);

Wil je handmatig controle houden, gebruik dan beginTransaction / rollBack / commit.

DB::beginTransaction();

try {
    DB::update('update accounts set balance = balance - 100 where id = ?', [1]);
    DB::update('update accounts set balance = balance + 100 where id = ?', [2]);

    DB::commit();
} catch (\Throwable $e) {
    DB::rollBack();
    throw $e;
}

Volgende stappen

Query Builder

Leer hoe je met de verbindingsconfiguratie veilig queries opbouwt.

Migrations

Leer hoe je het schema van je gekoppelde database onder versiebeheer houdt.

Seeding

Leer hoe je ontwikkel- en testdata op een reproduceerbare manier inlaadt.

Architectuur

Database

Eloquent

Beveiliging

Events

E-mail en notificaties

Betalingen

Asynchrone verwerking

Realtime communicatie

Taakplanning

Caching en optimalisatie

Internationalisatie

Bestanden en opslag

Debugging en monitoring

Console en CLI

Performance

Frontend

AI-ontwikkeling

Ontwikkelomgeving

Aan de slag

Configuratie

Lees- en schrijfverbindingen scheiden

Verouderde leesbewerkingen ook in volgende requests voorkomen

Tijdelijk lezen via de write-verbinding

Pooled PostgreSQL-verbindingen

Meerdere databaseverbindingen

SQL-queries uitvoeren

Query-listening

Transacties

Volgende stappen

Query Builder

Migrations

Seeding

​Aan de slag

​Configuratie

​Lees- en schrijfverbindingen scheiden

​Verouderde leesbewerkingen ook in volgende requests voorkomen

​Tijdelijk lezen via de write-verbinding

​Pooled PostgreSQL-verbindingen

​Meerdere databaseverbindingen

​SQL-queries uitvoeren

​Query-listening

​Transacties

​Volgende stappen

Query Builder

Migrations

Seeding

Aan de slag

Configuratie

Lees- en schrijfverbindingen scheiden

Verouderde leesbewerkingen ook in volgende requests voorkomen

Tijdelijk lezen via de write-verbinding

Pooled PostgreSQL-verbindingen

Meerdere databaseverbindingen

SQL-queries uitvoeren

Query-listening

Transacties

Volgende stappen