Hvad er query builder, og hvordan forholder det sig til Eloquent?

Question

Accepted Answer

Laravels **Query Builder** er en fluent, chainable interface til at bygge og køre databaseforespørgsler uden at skrive rå SQL. **Eloquent er bygget oven på Query Builder** — Eloquent-modeller bruger det under motorhjelmen, og Eloquent-forespørgsler kan bruge alle Query Builder-metoder.

## Query Builder (databaseniveau, 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']);
```

Query Builder arbejder direkte med tabeller (returnerer almindelige objekter, ikke Eloquent-modeller). Det er chainable og **bruger automatisk parameterBinding** — hvilket forhindrer SQL injection.

## Eloquent bruger de samme fluent metoder

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

Når du kæder metoder på en Eloquent-model, bruger du Query Builder under motorhjelmen — men du får tilbage **modeller** (med relationer, accessors og metoder) i stedet for almindelige objekter.

## Avancerede forespørgsler (begge understøtter disse)

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

Begge understøtter joins, aggregater, subqueries og komplekse betingelser.

## Hvornår bruges hvad

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

## Hvorfor det betyder noget

At forstå Query Builder og dets forhold til Eloquent er vigtigt for at arbejde effektivt med databaser i Laravel og vælge det rigtige værktøj til hver situation.

Det vigtigste indsigt er, at **Eloquent er bygget på Query Builder** — så de fluent, chainable metoder, du bruger på Eloquent-modeller (`where`, `orderBy`, `join` osv.), er Query Builders, hvilket betyder, at det at lære den ene lærer dig begge dele.

Query Builder giver en ren, SQL-injection-sikker (via automatisk parameterBinding) måde at bygge forespørgsler uden at skrive rå SQL, og Eloquent lagrer modelfunktionalitet (relationer, accessors, metoder) ovenpå.

At vide **hvornår du skal bruge hvad** er den praktiske færdighed: **Eloquent** til det meste af applikationslogik (du får rige modelobjekter med relationer og adfærd), og **Query Builder direkte** (`DB::table`) til lette forespørgsler uden modeloverhead, kompleks rapportering/aggregering, eller når du ikke har brug for fulde modeller — hvilket kan være mere effektivt i visse tilfælde.

Begge håndterer sikkert komplekse forespørgsler (joins, aggregater, subqueries) med samme fluent API.

At forstå Query Builder, hvordan Eloquent bygger på det, den delte sikre parameterBinding (forhindring af SQL injection) og valget mellem dem er vigtig viden for at skrive effektiv, sikker databasekode i Laravel, da databaseadgang er central for de fleste applikationer, og valget af passende niveau (modelrig Eloquent vs let Query Builder) påvirker både klarhed og ydeevne.