Wat is de query builder en hoe verhoudt deze zich tot Eloquent?

Question

Accepted Answer

Laravel's **Query Builder** is een vloeiende, ketelbouwbare interface voor het bouwen en uitvoeren van databasequery's zonder het schrijven van raw SQL. **Eloquent is gebouwd op top van de Query Builder** — Eloquent-modellen gebruiken het onder de motorkap, en Eloquent-query's kunnen alle Query Builder-methodes gebruiken.

## The Query Builder (database-level, via DB facade)

```php
use Illuminate\Support\Facades\DB;

DB::table('users')
    ->where('active', true)
    ->where('age', '>', 18)
    ->orderBy('name')
    ->limit(10)
    ->get();                          // returns generic objects (not models)

DB::table('users')->where('id', 1)->update(['name' => 'X']);
DB::table('users')->insert(['name' => 'Ann']);
```

De Query Builder werkt rechtstreeks met tabellen (retourneert gewone objecten, geen Eloquent-modellen). Het is ketelbouwbaar en **maakt automatisch gebruik van parameter binding** — wat SQL-injectie voorkomt.

## Eloquent gebruikt dezelfde vloeiende methodes

```php
// Eloquent queries support ALL Query Builder methods (it's built on top)
User::where('active', true)
    ->where('age', '>', 18)
    ->orderBy('name')
    ->get();                          // returns User MODELS (with relationships, etc.)
```

Wanneer je methodes op een Eloquent-model ketelt, gebruik je de Query Builder eronder — maar je krijgt terug **modellen** (met relaties, accessors en methodes) in plaats van gewone objecten.

## Geavanceerde query's (beide ondersteunen deze)

```php
DB::table('orders')
    ->join('users', 'orders.user_id', '=', 'users.id')   // joins
    ->select('orders.*', 'users.name')
    ->where('orders.total', '>', 100)
    ->groupBy('users.id')
    ->havingRaw('SUM(orders.total) > 1000')
    ->get();

User::where('role', 'admin')
    ->orWhere('role', 'editor')
    ->whereIn('status', ['active', 'pending'])
    ->get();
```

Beiden ondersteunen joins, aggregates, subquery's en complexe voorwaarden.

## Wanneer welke gebruiken

```text
Eloquent (Model::...) → the default — get models with relationships/accessors/methods.
                        Best for most application logic.
Query Builder (DB::table) → when you want lightweight queries without model overhead,
                            complex reporting/aggregations, or to avoid loading models.
```

## Waarom het belangrijk is

Begrip van de Query Builder en de relatie ervan tot Eloquent is belangrijk voor effectief werken met databases in Laravel en voor het kiezen van het juiste gereedschap voor elke situatie.

Het belangrijkste inzicht is dat **Eloquent gebouwd is op de Query Builder** — dus de vloeiende, ketelbouwbare methodes die je op Eloquent-modellen gebruikt (`where`, `orderBy`, `join`, enz.) zijn die van de Query Builder, wat betekent dat het leren van de ene je beide leert.

De Query Builder biedt een schone, SQL-injectie-veilige (via automatische parameter binding) manier om query's te bouwen zonder raw SQL te schrijven, en Eloquent laagt modelfunctionaliteit (relaties, accessors, methodes) erbovenop.
"+weten **wanneer welke gebruiken** is de praktische vaardigheid: **Eloquent** voor de meeste applicatielogica (je krijgt rijke modelobjecten met relaties en gedrag), en de **Query Builder rechtstreeks** (`DB::table`) voor lichte query's zonder modeloverhead, complexe rapportages/aggregaties, of wanneer je niet volledige modellen nodig hebt — wat in bepaalde gevallen efficiënter kan zijn.

Beiden verwerken veilig complexe query's (joins, aggregates, subquery's) met dezelfde vloeiende API.

Begrip van de Query Builder, hoe Eloquent erop voortbouwt, de gedeelde veilige parameter binding (voorkomt SQL-injectie), en de keuze ertussen is belangrijke kennis voor het schrijven van efficiënte, veilige databasecode in Laravel, omdat databasetoegang centraal staat in de meeste applicaties en het kiezen van het passende niveau (modelrijke Eloquent versus lichte Query Builder) zowel duidelijkheid als prestaties beïnvloedt.