Qu'est-ce que le Query Builder et comment se rapporte-t-il à Eloquent ?

Question

Accepted Answer

Le **Query Builder** de Laravel est une interface fluide et chaînable pour construire et exécuter des requêtes de base de données sans écrire du SQL brut. **Eloquent est construit au-dessus du Query Builder** — les modèles Eloquent l'utilisent en arrière-plan, et les requêtes Eloquent peuvent utiliser toutes les méthodes du Query Builder.

## Le Query Builder (au niveau de la base de données, via la facade 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']);
```

Le Query Builder fonctionne directement avec les tables (retournant des objets simples, pas des modèles Eloquent). Il est chaînable et **utilise automatiquement la liaison des paramètres** — prévenant les injections SQL.

## Eloquent utilise les mêmes méthodes fluides

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

Quand vous chaînez des méthodes sur un modèle Eloquent, vous utilisez le Query Builder en arrière-plan — mais vous récupérez des **modèles** (avec des relations, des accesseurs et des méthodes) plutôt que des objets simples.

## Requêtes avancées (les deux les supportent)

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

Les deux supportent les jointures, les agrégats, les sous-requêtes et les conditions complexes.

## Quand utiliser lequel

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

## Pourquoi c'est important

Comprendre le Query Builder et sa relation avec Eloquent est important pour travailler efficacement avec les bases de données dans Laravel et choisir le bon outil pour chaque situation.

L'idée clé est qu'**Eloquent est construit sur le Query Builder** — donc les méthodes fluides et chaînables que vous utilisez sur les modèles Eloquent (`where`, `orderBy`, `join`, etc.) sont celles du Query Builder, ce qui signifie qu'apprendre l'une vous enseigne les deux.

Le Query Builder fournit un moyen propre et sûr contre les injections SQL (via la liaison automatique des paramètres) de construire des requêtes sans écrire du SQL brut, et Eloquent ajoute la fonctionnalité de modèle (relations, accesseurs, méthodes) par-dessus.

Savoir **quand utiliser lequel** est la compétence pratique : **Eloquent** pour la plupart de la logique applicative (vous obtenez des objets de modèle riches avec des relations et du comportement), et le **Query Builder directement** (`DB::table`) pour les requêtes légères sans surcharge de modèle, les rapports/agrégations complexes, ou quand vous n'avez pas besoin de modèles complets — ce qui peut être plus efficace dans certains cas.

Les deux gèrent en toute sécurité les requêtes complexes (jointures, agrégats, sous-requêtes) avec la même API fluide.

Comprendre le Query Builder, comment Eloquent s'appuie sur lui, la liaison sécurisée des paramètres partagée (prévenant les injections SQL), et le choix entre eux est une connaissance importante pour écrire du code de base de données efficace et sécurisé dans Laravel, car l'accès à la base de données est central dans la plupart des applications et choisir le niveau approprié (Eloquent riche en modèles ou Query Builder léger) affecte à la fois la clarté et les performances.