Vad är Query Builder och hur förhåller det sig till Eloquent?

Question

Accepted Answer

Laravels **Query Builder** är ett flytande, kedjande gränssnitt för att bygga och köra databasfrågor utan att skriva raw SQL. **Eloquent är byggt ovanpå Query Builder** — Eloquent-modeller använder det under huven, och Eloquent-frågor kan använda alla Query Builder-metoder.

## Query Builder (databasnivå, via DB-fasaden)

```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 arbetar direkt med tabeller (returnerar vanliga objekt, inte Eloquent-modeller). Det är kedjande och **använder automatiskt parameteruppbindning** — förhindrar SQL-injection.

## Eloquent använder samma flytande 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 kedjar metoder på en Eloquent-modell använder du Query Builder under huven — men du får tillbaka **modeller** (med relationer, accessorer och metoder) istället för vanliga objekt.

## Avancerade frågor (båda stöder dessa)

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

Båda stöder joins, aggregat, subqueries och komplexa villkor.

## När du ska använda vilket

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

## Varför det spelar roll

Att förstå Query Builder och dess förhållande till Eloquent är viktigt för att arbeta effektivt med databaser i Laravel och för att välja rätt verktyg för varje situation.

Nyckelinsikten är att **Eloquent är byggt ovanpå Query Builder** — så de flytande, kedjande metoderna du använder på Eloquent-modeller (`where`, `orderBy`, `join`, osv.) är Query Builders, vilket betyder att att lära sig det ena lär dig båda.

Query Builder erbjuder ett rent, SQL-injection-säkert (via automatisk parameteruppbindning) sätt att bygga frågor utan att skriva raw SQL, och Eloquent lägger modellfunktionalitet (relationer, accessorer, metoder) ovanpå.

Att veta **när du ska använda vilket** är den praktiska färdigheten: **Eloquent** för mest programlogik (du får rika modelobjekt med relationer och beteende), och **Query Builder direkt** (`DB::table`) för lätta frågor utan modellkostnad, komplex rapportering/aggregat, eller när du inte behöver fullständiga modeller — vilket kan vara mer effektivt för vissa fall.

Båda hanterar säkert komplexa frågor (joins, aggregat, subqueries) med samma flytande API.

Att förstå Query Builder, hur Eloquent bygger på det, den delade säkra parameteruppbindningen (förhindrar SQL-injection), och valet mellan dem är viktig kunskap för att skriva effektiv, säker databaskod i Laravel, eftersom databasåtkomst är central för de flesta applikationer och att välja rätt nivå (modellrik Eloquent mot lätt Query Builder) påverkar både klarhet och prestanda.