Eloquent ORM : where, orWhere, whereIn, orderBy, etc

1. Utilisation de where :

//Récupérer tous les clients avec le nom "Dupont"
$clients = Client::where('nom', 'Dupont')->get();

2. Utilisation de orWhere :

//Récupérer les produits avec un prix inférieur à 50 ou une quantité en stock supérieure à 100
$produits = Produit::where('prix', '<', 50)
                    ->orWhere('quantiteStock', '>', 100)
                    ->get();

3. Utilisation de whereIn :

//Récupérer les produits de la catégorie 1, 3 ou 5
$produits = Produit::whereIn('idcategorie', [1, 3, 5])->get();

4. Utilisation de orderBy :

//Récupérer tous les produits triés par prix de manière ascendante
$produits = Produit::orderBy('prix')->get();

5. Utilisation de where avec des relations :

//Récupérer toutes les ventes pour un client spécifique avec une quantité supérieure à 5
$ventes = Vente::where('idclient', 1)
               ->where('quantite', '>', 5)
               ->get();

6. Utilisation de orWhere avec des relations :

//Récupérer toutes les ventes pour un client spécifique ou un produit spécifique
$ventes = Vente::where('idclient', 1)
               ->orWhere('idproduit', 2)
               ->get();

7. Utilisation de whereIn avec des relations :

//Récupérer toutes les ventes pour les produits de la catégorie 1, 3 ou 5
$ventes = Vente::whereIn('idproduit', Produit::whereIn('idcategorie', [1, 3, 5])->pluck('idproduit'))
               ->get();

8. Utilisation de orderBy avec des relations :

//Récupérer toutes les ventes triées par date de vente de manière descendante
$ventes = Vente::orderBy('datevente', 'desc')->get();

9. Utilisation de where avec des opérateurs logiques :

//Récupérer tous les produits avec un prix supérieur à 50 et une quantité en stock inférieure à 100
$produits = Produit::where('prix', '>', 50)
                    ->where('quantiteStock', '<', 100)
                    ->get();

10. Utilisation de orWhere avec des opérateurs logiques :

//Récupérer les clients avec le nom "Dupont" ou "Durand" qui ont effectué une vente
$clients = Client::where('nom', 'Dupont')
                 ->orWhere('nom', 'Durand')
                 ->whereHas('ventes') // Assure qu'il existe au moins une vente associée
                 ->get();

11. Utilisation de where avec une clause orWhere imbriquée :

//Récupérer tous les produits avec un prix inférieur à 50 ou (une marque spécifique et une quantité en stock supérieure à 50)
$produits = Produit::where('prix', '<', 50)
                    ->orWhere(function ($query) {
                        $query->where('marque', 'Samsung')
                              ->where('quantiteStock', '>', 50);
                    })
                    ->get();

12. Utilisation de where avec like pour la recherche :

//Récupérer tous les clients dont le prénom commence par "A"
$clients = Client::where('prenom', 'like', 'A%')->get();

13. Utilisation de whereNotNull :

//Récupérer tous les clients avec un nom défini
$clients = Client::whereNotNull('nom')->get();

14. Utilisation de whereDate :

//Récupérer toutes les ventes effectuées après une date spécifique
$ventes = Vente::whereDate('datevente', '>', '2023-01-01')->get();

15. Utilisation de whereBetween :

//Récupérer les produits avec un prix compris entre 20 et 50
$produits = Produit::whereBetween('prix', [20, 50])->get();

16. Utilisation de orWhereBetween :

//Récupérer les produits avec un prix compris entre 20 et 50 ou une quantité en stock entre 10 et 30
$produits = Produit::orWhereBetween('prix', [20, 50])
                    ->orWhereBetween('quantiteStock', [10, 30])
                    ->get();

17. Utilisation de orWhere avec des relations multiples :

//Récupérer les ventes pour les produits de la catégorie 1 ou 3, et dont la quantité est supérieure à 5
$ventes = Vente::whereHas('produit', function ($query) {
                $query->whereIn('idcategorie', [1, 3]);
             })
             ->where('quantite', '>', 5)
             ->get();

18. Utilisation de whereHas avec des conditions supplémentaires :

//Récupérer les clients ayant effectué une vente avec un produit de la catégorie 1
$clients = Client::whereHas('ventes', function ($query) {
                $query->whereHas('produit', function ($innerQuery) {
                    $innerQuery->where('idcategorie', 1);
                });
             })
             ->get();

19. Utilisation de with pour charger des relations en même temps :

//Récupérer tous les produits avec les informations sur la catégorie préchargées
$produits = Produit::with('categorie')->get();

20. Utilisation de doesntHave pour trouver des enregistrements sans relation :

//Récupérer les clients sans vente
$clientsSansVente = Client::doesntHave('ventes')->get();

21. Utilisation de withCount pour compter le nombre de relations :

//Récupérer les catégories avec le nombre total de produits
$categories = Categorie::withCount('produits')->get();

22. Utilisation de whereJsonContains pour les colonnes JSON :

//Récupérer les produits avec une description JSON contenant le mot "premium"
$produits = Produit::whereJsonContains('description->tags', 'premium')->get();

23. Utilisation de whereDoesntHave pour exclure certains résultats :

//Récupérer les clients sans vente pour le produit de la catégorie 2
$clientsSansVentePourCategorie2 = Client::whereDoesntHave('ventes', function ($query) {
    $query->whereHas('produit', function ($innerQuery) {
        $innerQuery->where('idcategorie', 2);
    });
})->get();

24. Utilisation de orWhereHas avec des conditions complexes :

//Récupérer les clients qui ont effectué une vente avec un produit de la catégorie 1
// OU les clients dont le nom est "Dupont" et prénom est "Jean"
$clients = Client::orWhereHas('ventes.produit', function ($query) {
                $query->where('idcategorie', 1);
             })
             ->orWhere(function ($query) {
                 $query->where('nom', 'Dupont')->where('prenom', 'Jean');
             })
             ->get();

25. Utilisation de with pour charger des relations imbriquées :

//Récupérer tous les clients avec leurs ventes et les détails des produits associés
$clients = Client::with('ventes.produit')->get();

26. Utilisation de whereHas avec des conditions complexes sur plusieurs relations :

//Récupérer les clients qui ont effectué une vente avec un produit de la catégorie 1
// ET les clients dont le nom est "Dupont" et prénom est "Jean"
$clients = Client::whereHas('ventes.produit', function ($query) {
                $query->where('idcategorie', 1);
             })
             ->where(function ($query) {
                 $query->where('nom', 'Dupont')->where('prenom', 'Jean');
             })
             ->get();

27. Utilisation de orWhereHas avec des conditions sur une relation et une colonne :

//Récupérer les clients qui ont effectué une vente avec un produit de la catégorie 1
// OU les clients dont le nom est "Dupont" et prénom est "Jean"
$clients = Client::orWhereHas('ventes.produit', function ($query) {
                $query->where('idcategorie', 1);
             })
             ->orWhere(function ($query) {
                 $query->where('nom', 'Dupont')->where('prenom', 'Jean');
             })
             ->get();

28. Utilisation de whereDate avec une relation :

//Récupérer les ventes pour un produit spécifique effectuées après une date spécifique
$ventes = Vente::whereHas('produit', function ($query) {
                $query->whereDate('datevente', '>', '2023-01-01');
            })
            ->get();

29. Utilisation de orWhereHas avec une condition complexe sur une relation :

//Récupérer les clients qui ont effectué une vente avec un produit de la catégorie 1
// OU les clients dont le nom est "Dupont" et prénom est "Jean"
$clients = Client::orWhereHas('ventes', function ($query) {
                $query->whereHas('produit', function ($innerQuery) {
                    $innerQuery->where('idcategorie', 1);
                });
             })
             ->orWhere(function ($query) {
                 $query->where('nom', 'Dupont')->where('prenom', 'Jean');
             })
             ->get();

30. Utilisation de whereHas pour exclure certains résultats :

//Récupérer les clients qui n'ont pas effectué de vente pour un produit spécifique
$clientsSansVente = Client::whereDoesntHave('ventes', function ($query) {
                        $query->where('idproduit', 1);
                    })
                    ->get();

31. Utilisation de whereNotNull avec une relation :

//Récupérer les clients qui ont effectué une vente (relation non nulle)
$clientsAvecVente = Client::whereHas('ventes')->get();

32. Utilisation de whereNull avec une relation :

//Récupérer les clients qui n'ont pas effectué de vente
$clientsSansVente = Client::whereDoesntHave('ventes')->get();

33. Utilisation de orWhere avec plusieurs conditions imbriquées :

//Récupérer les produits avec un prix inférieur à 50 OU (une marque spécifique ET une quantité en stock supérieure à 50)
$produits = Produit::where('prix', '<', 50)
                    ->orWhere(function ($query) {
                        $query->where('marque', 'Samsung')
                              ->where('quantiteStock', '>', 50);
                    })
                    ->get();

34. Utilisation de whereHas pour filtrer par rapport à une relation :

//Récupérer les clients qui ont effectué une vente avec un produit de la marque "Apple"
$clients = Client::whereHas('ventes.produit', function ($query) {
                $query->where('marque', 'Apple');
            })
            ->get();

35. Utilisation de whereBetween avec une relation :

//Récupérer les ventes avec une quantité entre 5 et 10
$ventes = Vente::whereBetween('quantite', [5, 10])->get();

36. Utilisation de orWhereBetween avec une relation :

//Récupérer les ventes avec une quantité entre 5 et 10 ou une quantité supérieure à 20
$ventes = Vente::orWhereBetween('quantite', [5, 10])
               ->orWhere('quantite', '>', 20)
               ->get();

37. Utilisation de whereNotBetween avec une relation :

//Récupérer les ventes avec une quantité en dehors de la plage de 5 à 10
$ventes = Vente::whereNotBetween('quantite', [5, 10])->get();

38. Utilisation de orWhereNotBetween avec une relation :

//Récupérer les ventes avec une quantité en dehors de la plage de 5 à 10 ou en dehors de la plage de 20 à 30
$ventes = Vente::orWhereNotBetween('quantite', [5, 10])
               ->orWhereNotBetween('quantite', [20, 30])
               ->get();

39. Utilisation de whereHas avec plusieurs conditions complexes sur des relations imbriquées :

//Récupérer les clients qui ont effectué une vente avec un produit de la catégorie 1
// ET les clients dont le nom est "Dupont" et prénom est "Jean"
// ET les ventes dont la quantité est supérieure à 5
$clients = Client::whereHas('ventes.produit', function ($query) {
                $query->where('idcategorie', 1);
             })
             ->where(function ($query) {
                 $query->where('nom', 'Dupont')->where('prenom', 'Jean');
             })
             ->whereHas('ventes', function ($query) {
                 $query->where('quantite', '>', 5);
             })
             ->get();

40. Utilisation de orWhere avec des conditions complexes sur plusieurs relations :

//Récupérer les produits avec un prix inférieur à 50 OU (une marque spécifique ET une quantité en stock supérieure à 50)
// OU (une vente avec un client ayant le nom "Dupont" ET une vente avec un client ayant le prénom "Jean")
$produits = Produit::where('prix', '<', 50)
                    ->orWhere(function ($query) {
                        $query->where('marque', 'Samsung')
                              ->where('quantiteStock', '>', 50);
                    })
                    ->orWhere(function ($query) {
                        $query->whereHas('ventes.client', function ($innerQuery) {
                            $innerQuery->where('nom', 'Dupont');
                        })
                        ->orWhereHas('ventes.client', function ($innerQuery) {
                            $innerQuery->where('prenom', 'Jean');
                        });
                    })
                    ->get();

41. Utilisation de whereRaw pour des conditions SQL brutes :

//Récupérer les produits avec un prix inférieur à 50 ET une quantité en stock supérieure à 10
$produits = Produit::whereRaw('prix < 50 AND quantiteStock > 10')->get();

42. Utilisation de orWhereRaw pour des conditions SQL brutes avec orWhere :

//Récupérer les produits avec un prix inférieur à 50 OU une quantité en stock supérieure à 10
$produits = Produit::orWhereRaw('prix < 50')
                    ->orWhereRaw('quantiteStock > 10')
                    ->get();

43. Utilisation de whereYear et orWhereYear pour filtrer par année :

//Récupérer les ventes de l'année 2022 ou dont la date de vente est en 2023
$ventes = Vente::whereYear('datevente', 2022)
               ->orWhereYear('datevente', 2023)
               ->get();

44. Utilisation de whereColumn pour comparer deux colonnes :

//Récupérer les ventes où la quantité est égale à la quantité en stock
$ventes = Vente::whereColumn('quantite', 'produits.quantiteStock')->get();

45. Utilisation de sous-requêtes dans where :

//Récupérer les clients qui ont effectué une vente avec un produit de la catégorie 1
// ET dont la quantité totale de ventes est supérieure à la moyenne globale de toutes les ventes
$clients = Client::whereHas('ventes.produit', function ($query) {
                $query->where('idcategorie', 1);
             })
             ->whereHas('ventes', function ($query) {
                 $query->selectRaw('sum(quantite) as total_ventes')
                       ->groupBy('idclient')
                       ->havingRaw('total_ventes > (select avg(quantite) from ventes)');
             })
             ->get();

46. Utilisation de whereJsonContains dans une relation JSON :

//Récupérer les produits avec une description JSON contenant "premium" ET une étiquette "sale"
$produits = Produit::whereJsonContains('description->tags', 'premium')
                    ->whereJsonContains('description->tags', 'sale')
                    ->get();

47. Utilisation de orWhere avec une sous-requête dans where :

//Récupérer les produits avec un prix inférieur à 50 OU une quantité en stock supérieure à la moyenne globale des stocks
$produits = Produit::where('prix', '<', 50)
                    ->orWhere('quantiteStock', '>', function ($query) {
                        $query->selectRaw('avg(quantiteStock)')->from('produits');
                    })
                    ->get();

48. Utilisation de whereExists pour vérifier l'existence d'une sous-requête :

//Récupérer les clients qui ont effectué une vente avec un produit de la catégorie 1
// ET dont la quantité totale de ventes est supérieure à 5
$clients = Client::whereExists(function ($query) {
                $query->select(DB::raw(1))
                      ->from('ventes')
                      ->whereRaw('clients.idclient = ventes.idclient')
                      ->where('idcategorie', 1)
                      ->groupBy('idclient')
                      ->havingRaw('sum(quantite) > 5');
             })
             ->get();

49. Utilisation de where avec une jointure :

//Récupérer les clients ayant effectué une vente avec un produit de la catégorie 1
$clients = Client::join('ventes', 'clients.idclient', '=', 'ventes.idclient')
                 ->join('produits', 'ventes.idproduit', '=', 'produits.idproduit')
                 ->where('idcategorie', 1)
                 ->select('clients.*')
                 ->distinct()
                 ->get();

50. Utilisation de orderBy avec une fonction agrégée :

//Récupérer les catégories triées par le nombre total de produits en stock de manière descendante
$categories = Categorie::withCount('produits')
                      ->orderByDesc('produits_count')
                      ->get();