Czym jest Query Builder i jak się ma do Eloquenta?

Question

Accepted Answer

**Query Builder** w Laravelu to płynny, łańcuchy interfejs do budowania i uruchamiania zapytań do bazy danych bez pisania surowego SQL. **Eloquent został zbudowany na bazie Query Builder** — modele Eloquenta używają go pod spodem, a zapytania Eloquenta mogą korzystać ze wszystkich metod Query Builder.

## Query Builder (poziom bazy danych, poprzez fasadę DB)

```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 pracuje bezpośrednio z tabelami (zwracając zwykłe obiekty, nie modele Eloquenta). Jest łańcuchowy i **automatycznie używa wiązania parametrów** — zapobiegając atakom SQL injection.

## Eloquent używa tych samych metod płynnych

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

Kiedy łańcusujesz metody na modelu Eloquenta, używasz Query Builder pod spodem — ale otrzymujesz **modele** (z relacjami, akcesorami i metodami) zamiast zwykłych obiektów.

## Zaawansowane zapytania (oba wspierają te)

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

Oba wspierają joinów, agregaty, podzapytania i złożone warunki.

## Kiedy używać którego

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

## Dlaczego to ważne

Zrozumienie Query Builder i jego związku z Eloquentem jest ważne dla efektywnej pracy z bazami danych w Laravelu i wyboru odpowiedniego narzędzia dla każdej sytuacji.

Kluczową intuicją jest fakt, że **Eloquent jest zbudowany na Query Builder** — więc płynne, łańcuchowe metody, które używasz na modelach Eloquenta (`where`, `orderBy`, `join`, itd.) pochodzą z Query Builder, co oznacza, że nauka jednego uczy cię obu.

Query Builder zapewnia czysty, bezpieczny przed atakami SQL injection (poprzez automatyczne wiązanie parametrów) sposób budowania zapytań bez pisania surowego SQL, a Eloquent nakłada na to funkcjonalność modelu (relacje, akcesory, metody).

Znajomość **kiedy używać którego** to praktyczna umiejętność: **Eloquent** do większości logiki aplikacji (otrzymujesz bogate obiekty modeli z relacjami i zachowaniem), a **Query Builder bezpośrednio** (`DB::table`) do lekkich zapytań bez narzutu modelu, złożonych raportów/agregacji, lub gdy nie potrzebujesz pełnych modeli — co może być bardziej efektywne w niektórych przypadkach.

Oba bezpiecznie obsługują złożone zapytania (joinów, agregaty, podzapytania) za pomocą tego samego płynnego API.

Zrozumienie Query Builder, jak Eloquent na nim się buduje, wspólnego bezpiecznego wiązania parametrów (zapobiegającego atakom SQL injection) i wyboru między nimi to ważna wiedza do pisania efektywnego i bezpiecznego kodu dostępu do bazy danych w Laravelu, ponieważ dostęp do bazy danych jest centralny dla większości aplikacji i wybór odpowiedniego poziomu (bogaty modelami Eloquent vs lekki Query Builder) wpływa zarówno na przejrzystość, jak i wydajność.