Hva er spørringsbyggeren (Query Builder) og hvordan forhold den seg til Eloquent?

Question

Accepted Answer

Laravels **Query Builder** er et flytende, kjedibart grensesnitt for å bygge og kjøre databasespørringer uten å skrive rå SQL. **Eloquent er bygget på toppen av Query Builder** — Eloquent-modeller bruker den under panseret, og Eloquent-spørringer kan bruke alle Query Builder-metoder.

## Query Builder (databasenivå, 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 fungerer direkte med tabeller (returnerer vanlige objekter, ikke Eloquent-modeller). Det er kjedibart og **bruker automatisk parameterindekapsling** — som forhindrer SQL-injeksjon.

## Eloquent bruker de samme flytende metodene

```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 kjeder metoder på en Eloquent-modell, bruker du Query Builder under panseret — men du får tilbake **modeller** (med relasjoner, aksessorer og metoder) i stedet for vanlige objekter.

## Avanserte spørringer (begge stø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 støtter joins, aggregater, underspørringer og komplekse betingelser.

## Når du skal bruke hvilken

```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 er viktig

Å forstå Query Builder og dets forhold til Eloquent er viktig for å arbeide effektivt med databaser i Laravel og for å velge det riktige verktøyet for hver situasjon.

Hovedinsikten er at **Eloquent er bygget på Query Builder** — så de flytende, kjedbare metodene du bruker på Eloquent-modeller (`where`, `orderBy`, `join` osv.) er fra Query Builder, noe som betyr at å lære den ene lærer deg begge.

Query Builder gir en ren, SQL-injeksjonssikker (via automatisk parameterindekapsling) måte å bygge spørringer på uten å skrive rå SQL, og Eloquent legger modellfunksjonalitet (relasjoner, aksessorer, metoder) på toppen.

Å vite **når du skal bruke hvilken** er den praktiske ferdigheten: **Eloquent** for det meste av applikasjonslogikken (du får rike modellobjekter med relasjoner og oppførsel), og **Query Builder direkte** (`DB::table`) for lette spørringer uten modelloverhø, kompleks rapportering/aggregering, eller når du ikke trenger fulle modeller — som kan være mer effektivt i visse tilfeller.

Begge håndterer sikkert komplekse spørringer (joins, aggregater, underspørringer) med samme flytende API.

Å forstå Query Builder, hvordan Eloquent bygger på den, den delte sikre parameterindekapslingen (som forhindrer SQL-injeksjon), og valget mellom dem er viktig kunnskap for å skrive effektiv, sikker databasekode i Laravel, siden databasetilgang er sentralt for de fleste applikasjoner og å velge det passende nivået (modellrik Eloquent vs lett Query Builder) påvirker både klarhet og ytelse.