Was ist der Query Builder und wie verhält er sich zu Eloquent?

Question

Accepted Answer

Laravel's **Query Builder** ist eine fluent, verkettbare Schnittstelle zum Erstellen und Ausführen von Datenbankabfragen ohne das Schreiben von Raw SQL. **Eloquent ist auf dem Query Builder aufgebaut** — Eloquent-Modelle verwenden ihn intern, und Eloquent-Abfragen können alle Query-Builder-Methoden nutzen.

## Der Query Builder (Datenbankebene, über DB-Fassade)

```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']);
```

Der Query Builder arbeitet direkt mit Tabellen (gibt einfache Objekte zurück, keine Eloquent-Modelle). Er ist verkettbar und **nutzt automatisch Parameter Binding** — zur Vermeidung von SQL-Injection.

## Eloquent nutzt dieselben fluent Methoden

```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.)
```

Wenn Sie Methoden auf einem Eloquent-Modell verketten, verwenden Sie intern den Query Builder — erhalten aber **Modelle** (mit Beziehungen, Accessoren und Methoden) statt einfache Objekte zurück.

## Erweiterte Abfragen (beide unterstützen diese)

```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();
```

Beide unterstützen Joins, Aggregate, Subqueries und komplexe Bedingungen.

## Wann man welches nutzt

```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.
```

## Warum es wichtig ist

Das Verständnis des Query Builders und seiner Beziehung zu Eloquent ist wichtig für effektive Arbeit mit Datenbanken in Laravel und für die Wahl des richtigen Werkzeugs für jede Situation.

Die Schlüsselidee ist, dass **Eloquent auf dem Query Builder aufgebaut ist** — so dass die fluent, verkettbaren Methoden, die Sie auf Eloquent-Modellen verwenden (`where`, `orderBy`, `join`, etc.), die des Query Builders sind, weshalb das Erlernen des einen beide lehrt.

Der Query Builder bietet eine saubere, vor SQL-Injection sichere (durch automatisches Parameter Binding) Möglichkeit, Abfragen zu erstellen, ohne Raw SQL zu schreiben, und Eloquent lagert Modellfunktionalität (Beziehungen, Accessoren, Methoden) darauf.

Die Kenntnis **wann man welches nutzt** ist die praktische Fähigkeit: **Eloquent** für die meiste Anwendungslogik (Sie erhalten reichhaltige Modellobjekte mit Beziehungen und Verhalten), und den **Query Builder direkt** (`DB::table`) für einfache Abfragen ohne Modell-Overhead, komplexe Berichterstattung/Aggregate oder wenn Sie keine vollständigen Modelle benötigen — was in bestimmten Fällen effizienter sein kann.

Beide handhaben sicher komplexe Abfragen (Joins, Aggregate, Subqueries) mit derselben fluent API.

Das Verständnis des Query Builders, wie Eloquent darauf aufbaut, das gemeinsame sichere Parameter Binding (zur Vermeidung von SQL-Injection) und die Wahl zwischen ihnen ist wichtiges Wissen für das Schreiben von effizienten, sicheren Datenbankcode in Laravel, da Datenbankzugriff zentral für die meisten Anwendungen ist und die Wahl der angemessenen Ebene (modellreiches Eloquent gegenüber leichtgewichtigem Query Builder) sowohl Klarheit als auch Performance beeinflusst.