Laravel: Requêtes avancées avec Eloquent

Utilisation des scopes

Les scopes permettent de définir des conditions de requête réutilisables et de les appliquer facilement aux requêtes Eloquent.

Définition d'un scope

Pour définir un scope, ajoutez une méthode au modèle en préfixant son nom par scope.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    public function scopePublished($query)
    {
        return $query->where('status', 'published');
    }
}

Utilisation d'un scope

Vous pouvez utiliser un scope dans vos requêtes comme suit :

$publishedPosts = Post::published()->get();

Requêtes conditionnelles

Les requêtes conditionnelles permettent d'ajouter des conditions dynamiques aux requêtes Eloquent.

Utilisation de la méthode when

La méthode when permet d'ajouter des conditions à une requête en fonction de l'évaluation d'un paramètre.

$status = 'published';

$posts = Post::when($status, function ($query, $status) {
    return $query->where('status', $status);
})->get();

Jointures et relations

Les jointures permettent de combiner les enregistrements de deux tables ou plus en fonction d'une colonne liée entre elles.

Jointure avec Eloquent

$posts = DB::table('posts')
    ->join('users', 'posts.user_id', '=', 'users.id')
    ->select('posts.*', 'users.name')
    ->get();

Relations Eloquent

Les relations Eloquent permettent de définir les relations entre les modèles et de les charger facilement.

Exemple de relation One-to-Many :

$user = User::find(1);
$posts = $user->posts;

Exemple de relation Many-to-Many :

$user = User::find(1);
$roles = $user->roles;

Utilisation des sous-requêtes

Les sous-requêtes permettent d'imbriquer une requête dans une autre requête pour effectuer des opérations complexes.

Exemple de sous-requête

Supposons que nous voulons récupérer les utilisateurs qui ont le plus de posts :

$topUsers = User::select('users.*')
    ->withCount('posts')
    ->orderBy('posts_count', 'desc')
    ->get();

Exemple de sous-requête avec where

Récupérer les posts dont le titre correspond à un certain mot clé :

$keyword = 'Laravel';

$posts = Post::where(function($query) use ($keyword) {
    $query->select('title')
          ->from('posts')
          ->where('title', 'LIKE', "%{$keyword}%");
})->get();

Laravel: Utilisation des Scopes avec Eloquent

Introduction

Les scopes dans Laravel Eloquent sont des méthodes qui permettent de définir des portions de requêtes réutilisables. Ils simplifient la logique des requêtes en permettant de la réutiliser dans différentes parties de votre application.

Scopes Locaux

Les scopes locaux permettent de définir des conditions spécifiques pour une requête. Ces scopes sont définis dans le modèle et peuvent être utilisés pour ajouter des conditions courantes aux requêtes.

Définition d'un Scope Local

Pour définir un scope local, ajoutez une méthode au modèle en préfixant son nom par scope. Cette méthode prend deux arguments : une instance de Builder et toute valeur de paramètre que vous souhaitez passer au scope.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    public function scopePublished($query)
    {
        return $query->where('status', 'published');
    }
    
    public function scopePopular($query)
    {
        return $query->where('views', '>', 100);
    }

    public function scopeRecent($query)
    {
        return $query->orderBy('created_at', 'desc');
    }
}

Utilisation d'un Scope Local

Pour utiliser un scope local, appelez simplement la méthode scope comme une méthode Eloquent normale.

$publishedPosts = Post::published()->get();

$popularPosts = Post::popular()->get();

$recentPosts = Post::recent()->get();

Chaînage de Scopes Locaux

Vous pouvez chaîner plusieurs scopes locaux pour construire des requêtes complexes.

$popularRecentPosts = Post::popular()->recent()->get();

$publishedPopularPosts = Post::published()->popular()->get();

Scopes Globaux

Les scopes globaux permettent d'appliquer automatiquement des contraintes à toutes les requêtes pour un modèle donné. Ils sont définis en utilisant le méthode booted dans le modèle.

Définition d'un Scope Global

Pour définir un scope global, utilisez la méthode booted de votre modèle et appliquez un callback à la requête.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Builder;

class Post extends Model
{
    protected static function booted()
    {
        static::addGlobalScope('published', function (Builder $builder) {
            $builder->where('status', 'published');
        });
    }
}

Utilisation d'un Scope Global

Un scope global est automatiquement appliqué à toutes les requêtes pour le modèle. Vous pouvez également ignorer un scope global en utilisant la méthode withoutGlobalScope.

$posts = Post::all(); // Seulement les posts avec le statut 'published'

$allPosts = Post::withoutGlobalScope('published')->get(); // Tous les posts

Scopes Dynamiques

Les scopes dynamiques vous permettent de passer des paramètres à vos scopes pour personnaliser davantage les requêtes.

Définition d'un Scope Dynamique

Pour définir un scope dynamique, ajoutez des paramètres à la méthode du scope dans votre modèle.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    public function scopeOfType($query, $type)
    {
        return $query->where('type', $type);
    }

    public function scopeFromDate($query, $date)
    {
        return $query->whereDate('created_at', '>=', $date);
    }
}

Utilisation d'un Scope Dynamique

Pour utiliser un scope dynamique, passez les paramètres nécessaires lors de l'appel de la méthode scope.

$newsPosts = Post::ofType('news')->get();

$recentPosts = Post::fromDate('2023-01-01')->get();

Laravel: Requêtes Conditionnelles avec Eloquent

Introduction

Les requêtes conditionnelles en Laravel Eloquent permettent d'ajouter des conditions dynamiques aux requêtes. Cela est particulièrement utile pour construire des requêtes basées sur des critères variables.

Utilisation de la Méthode when

La méthode when permet d'ajouter une condition à une requête seulement si un certain paramètre est vrai.

Condition simple

Voici comment ajouter une condition si un paramètre donné est vrai :

$status = 'published';

$posts = Post::when($status, function ($query, $status) {
    return $query->where('status', $status);
})->get();

Condition avec plusieurs paramètres

Vous pouvez également passer plusieurs paramètres à la méthode when :

$status = 'published';
$sortBy = 'created_at';

$posts = Post::when($status, function ($query, $status) {
    return $query->where('status', $status);
})->when($sortBy, function ($query, $sortBy) {
    return $query->orderBy($sortBy, 'desc');
})->get();

Condition avec une valeur par défaut

Vous pouvez aussi fournir une valeur par défaut à utiliser si la condition est fausse :

$status = null;

$posts = Post::when($status, function ($query, $status) {
    return $query->where('status', $status);
}, function ($query) {
    return $query->where('status', 'draft');
})->get();

Utilisation de la Méthode tap

La méthode tap permet d'exécuter une fonction sur une requête Eloquent, quel que soit l'état de la condition. Cela est utile pour des tâches telles que le logging ou le profiling.

$posts = Post::tap(function ($query) {
    // Logique additionnelle ici
    Log::info('Requête exécutée : ', ['query' => $query->toSql()]);
})->get();

Utilisation de Conditions Alternatives

Laravel permet également d'utiliser des conditions alternatives directement dans les méthodes de requête.

Condition dans where

Vous pouvez utiliser une condition ternaire pour simplifier la logique des requêtes :

$status = 'published';

$posts = Post::where('status', $status ?? 'draft')->get();

Utilisation de unless

La méthode unless fonctionne de manière similaire à when, mais exécute la condition seulement si le paramètre donné est faux.

$isAdmin = false;

$posts = Post::unless($isAdmin, function ($query) {
    return $query->where('status', 'published');
})->get();

Combinaison de Plusieurs Conditions

Vous pouvez combiner plusieurs conditions pour créer des requêtes complexes et dynamiques.

$status = 'published';
$authorId = 1;

$posts = Post::when($status, function ($query, $status) {
    return $query->where('status', $status);
})->when($authorId, function ($query, $authorId) {
    return $query->where('author_id', $authorId);
})->get();

Conclusion

Les requêtes avancées avec Laravel Eloquent permettent de manipuler les données de manière puissante et flexible. En utilisant des scopes, des requêtes conditionnelles, des jointures, des relations et des sous-requêtes, vous pouvez effectuer des opérations complexes de manière simple et intuitive.