What is the query builder and how does it relate to Eloquent?

Question

Accepted Answer

Laravel's **Query Builder** is a fluent, chainable interface for building and running database queries without writing raw SQL. **Eloquent is built on top of the Query Builder** — Eloquent models use it under the hood, and Eloquent queries can use all Query Builder methods.

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

The Query Builder works directly with tables (returning plain objects, not Eloquent models). It's chainable and **automatically uses parameter binding** — preventing SQL injection.

## Eloquent uses the same fluent methods

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

When you chain methods on an Eloquent model, you're using the Query Builder underneath — but you get back **models** (with relationships, accessors, and methods) rather than plain objects.

## Advanced queries (both support these)

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

Both support joins, aggregates, subqueries, and complex conditions.

## When to use which

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

## Why it matters

Understanding the Query Builder and its relationship to Eloquent is important for working effectively with databases in Laravel and choosing the right tool for each situation.

The key insight is that **Eloquent is built on the Query Builder** — so the fluent, chainable methods you use on Eloquent models (`where`, `orderBy`, `join`, etc.) are the Query Builder's, meaning learning one teaches you both.

The Query Builder provides a clean, SQL-injection-safe (via automatic parameter binding) way to build queries without writing raw SQL, and Eloquent layers model functionality (relationships, accessors, methods) on top.

Knowing **when to use which** is the practical skill: **Eloquent** for most application logic (you get rich model objects with relationships and behavior), and the **Query Builder directly** (`DB::table`) for lightweight queries without model overhead, complex reporting/aggregations, or when you don't need full models — which can be more efficient for certain cases.

Both safely handle complex queries (joins, aggregates, subqueries) with the same fluent API.

Understanding the Query Builder, how Eloquent builds on it, the shared safe parameter binding (preventing SQL injection), and the choice between them is important knowledge for writing efficient, secure database code in Laravel, since database access is central to most applications and choosing the appropriate level (model-rich Eloquent vs lightweight Query Builder) affects both clarity and performance.