les entités developpeur, projet et taches basées sur le schéma donné. 1. Requête avec where pour filtrer les développeurs par nom

$devs = Developpeur::where('nom', 'Doe')->get();

2. Requête avec orWhere pour filtrer les développeurs par nom ou prénom

$devs = Developpeur::where('nom', 'Doe')
    ->orWhere('prenom', 'John')
    ->get();

3. Filtrer les projets contenant un mot-clé dans le titre ou la description

use App\Models\Projet;

$projets = Projet::where('titre', 'like', '%Laravel%')
    ->orWhere('description', 'like', '%framework%')
    ->get();

4. Requête avec where et orWhere sur les tâches selon le coût et la durée

use App\Models\Tache;

$taches = Tache::where('coutHeure', '>', 50)
    ->orWhere('DureeHeure', '<', 10)
    ->get();

5. Filtrer les tâches pour un développeur et un projet spécifique

$taches = Tache::where('idDev', 1)
    ->where('idP', 2)
    ->get();

6. Filtrer les tâches par développeur ou par coût horaire élevé

$taches = Tache::where('idDev', 1)
    ->orWhere('coutHeure', '>=', 100)
    ->get();

7. Requête combinée avec des groupes conditionnels

$taches = Tache::where(function ($query) {
        $query->where('coutHeure', '>', 50)
              ->orWhere('DureeHeure', '<', 5);
    })
    ->where('idP', 3)
    ->get();

8. Lister les tâches d'un développeur spécifique avec un coût horaire ou une durée spécifique

$taches = Tache::where('idDev', 2)
    ->where(function ($query) {
        $query->where('coutHeure', '>', 100)
              ->orWhere('DureeHeure', '<', 20);
    })
    ->get();

9. Filtrer les projets avec un titre spécifique et description vide

$projets = Projet::where('titre', 'Projet Laravel')
    ->orWhere('description', '=', '')
    ->get();

10. Obtenir les tâches où le coût est supérieur à 70 ou la durée est entre 10 et 20 heures

$taches = Tache::where('coutHeure', '>', 70)
    ->orWhere(function ($query) {
        $query->where('DureeHeure', '>=', 10)
              ->where('DureeHeure', '<=', 20);
    })
    ->get();

// Développeur.php
public function taches() {
    return $this->hasMany(Tache::class, 'idDev');
}

// Projet.php
public function taches() {
    return $this->hasMany(Tache::class, 'idP');
}

// Tache.php
public function developpeur() {
    return $this->belongsTo(Developpeur::class, 'idDev');
}

public function projet() {
    return $this->belongsTo(Projet::class, 'idP');
}

🔥 Exemples avec with 1. Charger les tâches d'un développeur avec with

$devs = Developpeur::with('taches')->get();

2. Charger les projets avec leurs tâches

$projets = Projet::with('taches')->get();

3. Charger les tâches et leurs développeurs associés

$taches = Tache::with('developpeur')->get();

4. Charger les développeurs avec leurs projets via les tâches

$devs = Developpeur::with('taches.projet')->get();

✅ Exemples avec has et whereHas 5. Obtenir les développeurs qui ont au moins une tâche

$devs = Developpeur::has('taches')->get();

6. Obtenir les projets qui ont des tâches avec un coût supérieur à 100

$projets = Projet::whereHas('taches', function ($query) {
    $query->where('coutHeure', '>', 100);
})->get();

7. Obtenir les développeurs qui ont plus de 5 tâches

$devs = Developpeur::has('taches', '>', 5)->get();

8. Obtenir les projets qui ont des tâches avec une durée inférieure à 10 heures

$projets = Projet::whereHas('taches', function ($query) {
    $query->where('DureeHeure', '<', 10);
})->get();

🚫 Exemples avec whereDoesntHave 9. Obtenir les développeurs qui n'ont pas de tâches

$devs = Developpeur::whereDoesntHave('taches')->get();

10. Obtenir les projets sans aucune tâche

$projets = Projet::whereDoesntHave('taches')->get();

11. Obtenir les développeurs sans tâches de coût supérieur à 200

$devs = Developpeur::whereDoesntHave('taches', function ($query) {
    $query->where('coutHeure', '>', 200);
})->get();

🔢 Exemples avec withCount 12. Compter le nombre de tâches par développeur

$devs = Developpeur::withCount('taches')->get();

13. Compter le nombre de tâches par projet

$projets = Projet::withCount('taches')->get();

14. Obtenir les développeurs qui ont au moins 3 tâches

$devs = Developpeur::withCount('taches')
    ->having('taches_count', '>=', 3)
    ->get();

➕ Exemples avec withSum 15. Obtenir la somme du coût horaire des tâches par projet

$projets = Projet::withSum('taches', 'coutHeure')->get();

16. Obtenir la somme des durées des tâches par développeur

$devs = Developpeur::withSum('taches', 'DureeHeure')->get();

17. Filtrer les projets ayant une somme des coûts de tâches supérieure à 1000

$projets = Projet::withSum('taches', 'coutHeure')
    ->having('taches_sum_coutHeure', '>', 1000)
    ->get();

📊 Exemples avec withAvg 18. Obtenir la durée moyenne des tâches par développeur

$devs = Developpeur::withAvg('taches', 'DureeHeure')->get();

19. Obtenir le coût horaire moyen des tâches par projet

$projets = Projet::withAvg('taches', 'coutHeure')->get();

20. Obtenir les développeurs ayant une durée moyenne de tâches supérieure à 10 heures

$devs = Developpeur::withAvg('taches', 'DureeHeure')
    ->having('taches_avg_DureeHeure', '>', 10)
    ->get();

1. Obtenir les développeurs avec le nombre de tâches et le coût total de leurs tâches (Utilisation de withCount et withSum)

$developpeurs = Developpeur::withCount('taches')  // Compte le nombre de tâches pour chaque développeur
    ->withSum('taches as total_cout', DB::raw('coutHeure * DureeHeure'))  // Somme du coût des tâches
    ->get();

2. Obtenir les projets avec la durée totale des tâches et le coût moyen des tâches (Utilisation de withSum et withAvg)
Ici, on utilise withSum pour obtenir la durée totale des tâches, et withAvg pour calculer le coût moyen des tâches.

$projets = Projet::withSum('taches as total_duree', 'DureeHeure')  // Somme de la durée des tâches
    ->withAvg('taches as cout_moyen', DB::raw('coutHeure * DureeHeure'))  // Moyenne du coût des tâches
    ->get();

3. Obtenir les développeurs avec des projets spécifiques et le nombre de tâches par projet (Utilisation de with et withCount)
Si tu veux obtenir tous les développeurs avec leurs projets associés, et le nombre de tâches pour chaque projet, tu peux faire ceci :

$developpeurs = Developpeur::with(['projets' => function ($query) {
        $query->withCount('taches');  // Compter les tâches de chaque projet
    }])
    ->get();

Cela récupère tous les développeurs et, pour chaque projet, le nombre de tâches associées. 4. Obtenir les développeurs ayant des tâches avec un coût total supérieur à un certain seuil (Utilisation de withHas et withSum)
Supposons que tu veuilles obtenir tous les développeurs ayant des tâches dont le coût total dépasse un certain seuil (par exemple 1000).

$developpeurs = Developpeur::with(['taches' => function ($query) {
        $query->select(DB::raw('SUM(coutHeure * DureeHeure) as total_cout'))
              ->groupBy('idDev')
              ->havingRaw('total_cout > ?', [1000]);  // Filtrer selon le coût total des tâches
    }])
    ->get();

Ici, on filtre les développeurs selon le coût total des tâches (par développeur). 5. Obtenir les projets ayant un certain nombre de tâches et un coût moyen des tâches supérieur à un seuil (Utilisation de withHas et withAvg)
Cet exemple montre comment obtenir des projets qui ont un certain nombre de tâches et où le coût moyen des tâches est supérieur à une valeur donnée.

$projets = Projet::with(['taches' => function ($query) {
        $query->havingRaw('AVG(coutHeure * DureeHeure) > ?', [500]);  // Coût moyen des tâches supérieur à 500
    }])
    ->withCount('taches')  // Compter les tâches de chaque projet
    ->get();

6. Obtenir les projets et les développeurs associés avec un coût total de tâches supérieur à un seuil (Utilisation de withHas, withCount, et withSum)
Ce code permet d'obtenir les projets et les développeurs qui ont des tâches dont le coût total dépasse une certaine valeur.

$projets = Projet::with(['taches' => function ($query) {
        $query->select(DB::raw('SUM(coutHeure * DureeHeure) as total_cout'))
              ->groupBy('idP')
              ->havingRaw('total_cout > ?', [1000]);  // Coût total des tâches > 1000
    }])
    ->withCount('taches')  // Nombre de tâches pour chaque projet
    ->get();

7. Obtenir les développeurs ayant travaillé sur des projets avec un coût total supérieur à une valeur (Utilisation de withHas et withCount)
Cet exemple permet de récupérer les développeurs qui ont travaillé sur des projets où le coût total des tâches dépasse une certaine valeur (par exemple 1000).

$developpeurs = Developpeur::with(['projets' => function ($query) {
        $query->withSum('taches as cout_total', DB::raw('coutHeure * DureeHeure'))
              ->having('cout_total', '>', 1000);  // Projets dont le coût total des tâches > 1000
    }])
    ->withCount('projets')  // Nombre de projets par développeur
    ->get();

8. Obtenir les projets avec le coût total des tâches, le nombre de tâches et le nombre de développeurs (Utilisation de withCount et withSum)
Si tu souhaites obtenir des projets avec le coût total des tâches, le nombre de tâches, et le nombre de développeurs associés, tu peux faire comme suit :

$projets = Projet::withCount('taches')  // Nombre de tâches
    ->withCount('developpeurs')  // Nombre de développeurs
    ->withSum('taches as cout_total', DB::raw('coutHeure * DureeHeure'))  // Coût total des tâches
    ->get();

9. Obtenir les développeurs ayant travaillé plus de 100 heures sur un projet avec un coût total des tâches supérieur à 500 (Utilisation de withHas, withSum, et withCount)

Cet exemple utilise withHas pour récupérer uniquement les développeurs ayant des tâches dont la durée totale est supérieure à 100 heures et dont le coût total des tâches est supérieur à 500.

$developpeurs = Developpeur::with(['taches' => function ($query) {
        $query->select(DB::raw('SUM(DureeHeure) as total_duree, SUM(coutHeure * DureeHeure) as total_cout'))
              ->groupBy('idDev')
              ->havingRaw('total_duree > 100 AND total_cout > 500');  // Durée totale > 100 heures et coût total > 500
    }])
    ->withCount('taches')  // Nombre de tâches
    ->get();

10. Obtenir les projets avec les développeurs qui ont travaillé plus de 50 heures et dont le coût total des tâches dépasse 1000 (Utilisation de with et withHas)


Ici, nous récupérons les projets avec les développeurs qui ont travaillé plus de 50 heures et dont le coût total des tâches dépasse 1000.

$projets = Projet::with(['developpeurs' => function ($query) {
        $query->whereHas('taches', function ($query) {
            $query->select(DB::raw('SUM(DureeHeure) as total_duree, SUM(coutHeure * DureeHeure) as total_cout'))
                  ->groupBy('idDev')
                  ->havingRaw('total_duree > 50 AND total_cout > 1000');  // Durée > 50 heures et coût total > 1000
        });
    }])
    ->get();

$projets = DB::select('SELECT * FROM projet WHERE titre LIKE ?', ['%Laravel%']);

3. Sélectionner les tâches avec un coût supérieur à 100

$taches = DB::select('SELECT * FROM taches WHERE coutHeure > ?', [100]);

4. Requête avec plusieurs conditions (AND)

$taches = DB::select('SELECT * FROM taches WHERE coutHeure > ? AND DureeHeure < ?', [100, 10]);

5. Requête avec condition OR

$developpeurs = DB::select('SELECT * FROM developpeur WHERE nom = ? OR prenom = ?', ['Doe', 'John']);

6. Requête avec IN

$projets = DB::select('SELECT * FROM projet WHERE idP IN (?, ?, ?)', [1, 2, 3]);

7. Requête avec BETWEEN

$taches = DB::select('SELECT * FROM taches WHERE coutHeure BETWEEN ? AND ?', [50, 200]);

8. Sélectionner les développeurs qui n'ont pas de tâches

$developpeurs = DB::select('
    SELECT * FROM developpeur 
    WHERE idDev NOT IN (SELECT DISTINCT idDev FROM taches)
');

9. Sélectionner les tâches avec un projet spécifique

$taches = DB::select('SELECT * FROM taches WHERE idP = ?', [2]);

10. Requête avec jointure pour récupérer les tâches avec les informations des développeurs

$taches = DB::select('
    SELECT taches.*, developpeur.nom, developpeur.prenom
    FROM taches
    JOIN developpeur ON taches.idDev = developpeur.idDev
');

11. Requête avec jointure et conditions

$taches = DB::select('
    SELECT taches.*, developpeur.nom, projet.titre
    FROM taches
    JOIN developpeur ON taches.idDev = developpeur.idDev
    JOIN projet ON taches.idP = projet.idP
    WHERE taches.coutHeure > ?
', [100]);

12. Compter le nombre de tâches par projet

$result = DB::select('
    SELECT idP, COUNT(*) as total_taches
    FROM taches
    GROUP BY idP
');

13. Obtenir la somme des coûts des tâches par développeur

$result = DB::select('
    SELECT idDev, SUM(coutHeure) as total_cout
    FROM taches
    GROUP BY idDev
');

14. Obtenir le coût moyen des tâches pour chaque projet

$result = DB::select('
    SELECT idP, AVG(coutHeure) as avg_cout
    FROM taches
    GROUP BY idP
');

15. Filtrer les projets avec plus de 5 tâches

$result = DB::select('
    SELECT idP, COUNT(*) as total_taches
    FROM taches
    GROUP BY idP
    HAVING total_taches > 5
');

16. Requête avec LIMIT et OFFSET pour la pagination

$projets = DB::select('SELECT * FROM projet LIMIT ? OFFSET ?', [10, 0]);

17. Utiliser des alias dans la requête

$result = DB::select('
    SELECT p.titre AS projet_titre, d.nom AS developpeur_nom
    FROM projet p
    JOIN taches t ON p.idP = t.idP
    JOIN developpeur d ON t.idDev = d.idDev
');

18. Requête avec des paramètres nommés

$result = DB::select('SELECT * FROM taches WHERE coutHeure > :cout', ['cout' => 100]);

19. Obtenir les développeurs avec la somme de leurs coûts de tâches

$result = DB::select('
    SELECT d.idDev, d.nom, SUM(t.coutHeure) as total_cout
    FROM developpeur d
    JOIN taches t ON d.idDev = t.idDev
    GROUP BY d.idDev, d.nom
');

20. Obtenir les projets sans aucune tâche

$result = DB::select('
    SELECT * FROM projet
    WHERE idP NOT IN (SELECT DISTINCT idP FROM taches)
');

1. Supprimer un développeur par ID

use Illuminate\Support\Facades\DB;

DB::delete('DELETE FROM developpeur WHERE idDev = ?', [1]);

2. Supprimer un projet par ID

DB::delete('DELETE FROM projet WHERE idP = ?', [3]);

3. Supprimer toutes les tâches d'un projet spécifique

DB::delete('DELETE FROM taches WHERE idP = ?', [2]);

4. Supprimer les tâches avec un coût horaire inférieur à 50

DB::delete('DELETE FROM taches WHERE coutHeure < ?', [50]);

5. Supprimer tous les développeurs sans tâches associées

DB::delete('
    DELETE FROM developpeur 
    WHERE idDev NOT IN (SELECT DISTINCT idDev FROM taches)
');

6. Supprimer les tâches avec une durée supérieure à 100 heures

DB::delete('DELETE FROM taches WHERE DureeHeure > ?', [100]);

7. Supprimer les projets sans tâches associées

DB::delete('
    DELETE FROM projet 
    WHERE idP NOT IN (SELECT DISTINCT idP FROM taches)
');

8. Supprimer les tâches d'un développeur spécifique

DB::delete('DELETE FROM taches WHERE idDev = ?', [4]);

9. Supprimer toutes les tâches avec coût nul

DB::delete('DELETE FROM taches WHERE coutHeure = 0');

10. Supprimer tous les projets dont le titre commence par 'Test'

DB::delete('DELETE FROM projet WHERE titre LIKE ?', ['Test%']);

🔄 Exemples avec DB::update Utilisé pour mettre à jour des enregistrements. 11. Mettre à jour le nom d'un développeur

DB::update('UPDATE developpeur SET nom = ? WHERE idDev = ?', ['NouveauNom', 1]);

12. Mettre à jour le coût horaire d'une tâche

DB::update('UPDATE taches SET coutHeure = ? WHERE idT = ?', [150, 2]);

13. Mettre à jour la description d'un projet

DB::update('UPDATE projet SET description = ? WHERE idP = ?', ['Nouvelle description', 3]);

14. Augmenter le coût horaire de toutes les tâches de 10%

DB::update('UPDATE taches SET coutHeure = coutHeure * 1.10');

15. Réduire la durée des tâches de 5 heures si supérieure à 20 heures

DB::update('UPDATE taches SET DureeHeure = DureeHeure - 5 WHERE DureeHeure > 20');

16. Mettre à jour le prénom d'un développeur avec une condition

DB::update('UPDATE developpeur SET prenom = ? WHERE nom = ?', ['John', 'Doe']);

17. Mettre à jour le titre des projets qui n'ont pas de description

DB::update('UPDATE projet SET titre = ? WHERE description IS NULL', ['Titre par défaut']);

18. Mettre à jour le coût horaire des tâches avec une durée inférieure à 10 heures

DB::update('UPDATE taches SET coutHeure = ? WHERE DureeHeure < ?', [80, 10]);

19. Mettre à jour tous les projets pour ajouter une mention dans le titre

DB::update("UPDATE projet SET titre = CONCAT(titre, ' - Vérifié')");

20. Réinitialiser les coûts horaires des tâches à zéro pour les tâches longues (>100 heures) ⚙️ Exemples avec DB::raw 1. Sélectionner des données avec une colonne calculée

use Illuminate\Support\Facades\DB;

$taches = DB::table('taches')
    ->select('idT', 'coutHeure', 'DureeHeure', DB::raw('coutHeure * DureeHeure AS total_cout'))
    ->get();

2. Compter le nombre total de tâches

$count = DB::table('taches')
    ->select(DB::raw('COUNT(*) as total'))
    ->first();

3. Utiliser DB::raw dans un select avec alias

$projets = DB::table('projet')
    ->select(DB::raw('titre AS projet_titre'), 'description')
    ->get();

4. Concaténer deux colonnes

$developpeurs = DB::table('developpeur')
    ->select(DB::raw("CONCAT(nom, ' ', prenom) as nom_complet"))
    ->get();

5. Sélectionner l'année actuelle

$year = DB::table('taches')
    ->select(DB::raw('YEAR(NOW()) as current_year'))
    ->first();

🔍 Exemples avec whereRaw 6. Filtrer les tâches dont le coût total dépasse 1000

$taches = DB::table('taches')
    ->whereRaw('coutHeure * DureeHeure > ?', [1000])
    ->get();

7. Filtrer les projets dont le titre commence par "Laravel"

$projets = DB::table('projet')
    ->whereRaw('titre LIKE ?', ['Laravel%'])
    ->get();

8. Filtrer avec plusieurs conditions AND en SQL brut

$taches = DB::table('taches')
    ->whereRaw('coutHeure > ? AND DureeHeure < ?', [100, 20])
    ->get();

9. Filtrer les tâches créées aujourd'hui (avec date fictive)

$taches = DB::table('taches')
    ->whereRaw('DATE(created_at) = CURDATE()')
    ->get();

10. Filtrer les développeurs avec un prénom en minuscules

$developpeurs = DB::table('developpeur')
    ->whereRaw('BINARY prenom = ?', ['john'])
    ->get();

⚡ Exemples avec orWhereRaw 11. Filtrer les tâches avec coût supérieur à 200 ou durée supérieure à 50

$taches = DB::table('taches')
    ->whereRaw('coutHeure > ?', [200])
    ->orWhereRaw('DureeHeure > ?', [50])
    ->get();

12. Filtrer les projets par titre ou description contenant 'API'

$projets = DB::table('projet')
    ->whereRaw('titre LIKE ?', ['%API%'])
    ->orWhereRaw('description LIKE ?', ['%API%'])
    ->get();

📊 Exemples avec havingRaw 13. Filtrer les développeurs ayant plus de 5 tâches

$developpeurs = DB::table('taches')
    ->select('idDev', DB::raw('COUNT(*) as total_taches'))
    ->groupBy('idDev')
    ->havingRaw('COUNT(*) > ?', [5])
    ->get();

14. Filtrer les projets avec coût total des tâches supérieur à 5000

$projets = DB::table('taches')
    ->select('idP', DB::raw('SUM(coutHeure * DureeHeure) as total_cout'))
    ->groupBy('idP')
    ->havingRaw('total_cout > ?', [5000])
    ->get();

🗂️ Exemples avec orderByRaw 15. Trier les tâches par coût total décroissant

$taches = DB::table('taches')
    ->orderByRaw('coutHeure * DureeHeure DESC')
    ->get();

16. Trier les développeurs par nom et prénom

$developpeurs = DB::table('developpeur')
    ->orderByRaw('nom ASC, prenom ASC')
    ->get();

🎯 Combinaison de plusieurs raw 17. Obtenir le coût total et filtrer par développeur

$taches = DB::table('taches')
    ->select('idDev', DB::raw('SUM(coutHeure * DureeHeure) as total_cout'))
    ->groupBy('idDev')
    ->havingRaw('total_cout > ?', [2000])
    ->orderByRaw('total_cout DESC')
    ->get();

18. Filtrer avec whereRaw et trier avec orderByRaw

$projets = DB::table('projet')
    ->whereRaw('LENGTH(description) > ?', [100])
    ->orderByRaw('CHAR_LENGTH(titre) DESC')
    ->get();

🧮 Exemples avancés avec des calculs 19. Obtenir le coût total moyen par projet

$projets = DB::table('taches')
    ->select('idP', DB::raw('AVG(coutHeure * DureeHeure) as avg_cout'))
    ->groupBy('idP')
    ->get();

2. Trier les projets par titre décroissant

$projets = DB::table('projet')
    ->orderBy('titre', 'desc')
    ->get();

3. Trier les tâches par coût horaire décroissant puis par durée croissante

$taches = DB::table('taches')
    ->orderBy('coutHeure', 'desc')
    ->orderBy('DureeHeure', 'asc')
    ->get();

4. Trier les tâches par coût total (coûtHoraire × Durée)

$taches = DB::table('taches')
    ->select('idT', 'coutHeure', 'DureeHeure', DB::raw('coutHeure * DureeHeure AS total_cout'))
    ->orderBy('total_cout', 'desc')
    ->get();

5. Trier les développeurs par le nombre total de tâches (avec withCount)

$developpeurs = DB::table('developpeur')
    ->leftJoin('taches', 'developpeur.idDev', '=', 'taches.idDev')
    ->select('developpeur.*', DB::raw('COUNT(taches.idT) as total_taches'))
    ->groupBy('developpeur.idDev')
    ->orderBy('total_taches', 'desc')
    ->get();

🔍 Exemples avec having Utilisé après des agrégations (groupBy) pour filtrer les résultats. 6. Afficher les développeurs ayant plus de 3 tâches

$developpeurs = DB::table('taches')
    ->select('idDev', DB::raw('COUNT(*) as total_taches'))
    ->groupBy('idDev')
    ->having('total_taches', '>', 3)
    ->get();

7. Afficher les projets avec un coût total supérieur à 1000

$projets = DB::table('taches')
    ->select('idP', DB::raw('SUM(coutHeure * DureeHeure) as total_cout'))
    ->groupBy('idP')
    ->having('total_cout', '>', 1000)
    ->get();

8. Afficher les développeurs dont le coût horaire moyen est supérieur à 80

$developpeurs = DB::table('taches')
    ->select('idDev', DB::raw('AVG(coutHeure) as avg_cout'))
    ->groupBy('idDev')
    ->having('avg_cout', '>', 80)
    ->get();

9. Afficher les projets avec au moins 5 tâches

$projets = DB::table('taches')
    ->select('idP', DB::raw('COUNT(*) as total_taches'))
    ->groupBy('idP')
    ->having('total_taches', '>=', 5)
    ->get();

10. Afficher les développeurs ayant des tâches dont la durée moyenne dépasse 10 heures

$developpeurs = DB::table('taches')
    ->select('idDev', DB::raw('AVG(DureeHeure) as avg_duree'))
    ->groupBy('idDev')
    ->having('avg_duree', '>', 10)
    ->get();

⚡ Combinaisons avancées orderBy et having 11. Afficher les projets par coût total décroissant, en filtrant ceux au-dessus de 500

$projets = DB::table('taches')
    ->select('idP', DB::raw('SUM(coutHeure * DureeHeure) as total_cout'))
    ->groupBy('idP')
    ->having('total_cout', '>', 500)
    ->orderBy('total_cout', 'desc')
    ->get();

12. Lister les développeurs triés par le nombre de tâches, mais afficher uniquement ceux ayant plus de 2 tâches

$developpeurs = DB::table('taches')
    ->select('idDev', DB::raw('COUNT(*) as total_taches'))
    ->groupBy('idDev')
    ->having('total_taches', '>', 2)
    ->orderBy('total_taches', 'desc')
    ->get();

13. Afficher les projets avec le nombre de tâches, triés par le plus petit nombre

$projets = DB::table('taches')
    ->select('idP', DB::raw('COUNT(*) as total_taches'))
    ->groupBy('idP')
    ->having('total_taches', '>', 0)
    ->orderBy('total_taches', 'asc')
    ->get();

14. Lister les développeurs ayant un coût horaire total supérieur à 1000, triés par coût décroissant

$developpeurs = DB::table('taches')
    ->select('idDev', DB::raw('SUM(coutHeure * DureeHeure) as total_cout'))
    ->groupBy('idDev')
    ->having('total_cout', '>', 1000)
    ->orderBy('total_cout', 'desc')
    ->get();

15. Afficher les tâches triées par durée, en ne prenant que celles avec une durée supérieure à 5 heures

$taches = DB::table('taches')
    ->select('idT', 'DureeHeure')
    ->having('DureeHeure', '>', 5)
    ->orderBy('DureeHeure', 'desc')
    ->get();

🔹 1. Exemples Simples avec des Fonctions d'Agrégation Utilisant les fonctions comme count, sum, avg, min, et max. ➡️ Compter le nombre total de tâches

$totalTaches = DB::table('taches')->count();

➡️ Calculer le coût total de toutes les tâches

$totalCout = DB::table('taches')->sum(DB::raw('coutHeure * DureeHeure'));

➡️ Obtenir la durée moyenne des tâches

$moyenneDuree = DB::table('taches')->avg('DureeHeure');

➡️ Trouver le coût horaire minimum et maximum

$coutMin = DB::table('taches')->min('coutHeure');
$coutMax = DB::table('taches')->max('coutHeure');
➡️ Compter le nombre de projets par développeur

$projetsParDev = DB::table('taches')
    ->select('idDev', DB::raw('COUNT(DISTINCT idP) as total_projets'))
    ->groupBy('idDev')
    ->get();

🔷 2. Exemples Complexes avec Fonctions d'Agrégation Combinaison de groupBy, having, orderBy, et raw. ➡️ Lister les développeurs avec le coût total de leurs tâches

$coutParDev = DB::table('taches')
    ->select('idDev', DB::raw('SUM(coutHeure * DureeHeure) as total_cout'))
    ->groupBy('idDev')
    ->get();

➡️ Afficher les projets ayant un coût total supérieur à 1000

$projets = DB::table('taches')
    ->select('idP', DB::raw('SUM(coutHeure * DureeHeure) as total_cout'))
    ->groupBy('idP')
    ->having('total_cout', '>', 1000)
    ->get();

➡️ Afficher les développeurs avec le nombre moyen d'heures par tâche, triés par moyenne décroissante

$devs = DB::table('taches')
    ->select('idDev', DB::raw('AVG(DureeHeure) as moyenne_heures'))
    ->groupBy('idDev')
    ->orderBy('moyenne_heures', 'desc')
    ->get();

➡️ Afficher les projets avec le coût total et le nombre de tâches, filtrés par ceux ayant plus de 5 tâches

$projets = DB::table('taches')
    ->select('idP', DB::raw('COUNT(*) as total_taches'), DB::raw('SUM(coutHeure * DureeHeure) as total_cout'))
    ->groupBy('idP')
    ->having('total_taches', '>', 5)
    ->get();

➡️ Afficher les développeurs ayant des tâches dont la durée moyenne est supérieure à 10 heures

$developpeurs = DB::table('taches')
    ->select('idDev', DB::raw('AVG(DureeHeure) as moyenne_duree'))
    ->groupBy('idDev')
    ->having('moyenne_duree', '>', 10)
    ->get();

➡️ Afficher les projets triés par le coût moyen des tâches

$projets = DB::table('taches')
    ->select('idP', DB::raw('AVG(coutHeure * DureeHeure) as moyenne_cout'))
    ->groupBy('idP')
    ->orderBy('moyenne_cout', 'desc')
    ->get();

➡️ Afficher le coût total et le coût moyen par développeur

$statsDev = DB::table('taches')
    ->select('idDev', DB::raw('SUM(coutHeure * DureeHeure) as total_cout'), DB::raw('AVG(coutHeure * DureeHeure) as moyenne_cout'))
    ->groupBy('idDev')
    ->get();

➡️ Afficher les projets ayant des tâches avec un coût total supérieur à 500 et les trier par ce coût

$projets = DB::table('taches')
    ->select('idP', DB::raw('SUM(coutHeure * DureeHeure) as total_cout'))
    ->groupBy('idP')
    ->having('total_cout', '>', 500)
    ->orderBy('total_cout', 'desc')
    ->get();

➡️ Afficher les développeurs avec le nombre total de tâches, mais uniquement ceux ayant des tâches avec une durée totale supérieure à 50 heures

$developpeurs = DB::table('taches')
    ->select('idDev', DB::raw('COUNT(*) as total_taches'), DB::raw('SUM(DureeHeure) as total_duree'))
    ->groupBy('idDev')
    ->having('total_duree', '>', 50)
    ->get();

➡️ Lister les projets avec le coût total, le coût moyen et le nombre de tâches, en les triant par le coût moyen décroissant

$projets = DB::table('taches')
    ->select('idP', 
             DB::raw('SUM(coutHeure * DureeHeure) as total_cout'), 
             DB::raw('AVG(coutHeure * DureeHeure) as moyenne_cout'), 
             DB::raw('COUNT(*) as total_taches'))
    ->groupBy('idP')
    ->orderBy('moyenne_cout', 'desc')
    ->get();

✅ Pourquoi utiliser ces fonctions ?
sum : Pour additionner des valeurs (coût total).
avg : Pour obtenir la moyenne (durée moyenne).
min / max : Pour les valeurs extrêmes.
count : Pour compter les enregistrements.
having : Pour filtrer les résultats basés sur des agrégations.
groupBy : Pour grouper les données avant agrégation.
orderBy : Pour trier les résultats.
ici une collection d'exemples complexes utilisant différentes fonctions d'Eloquent dans Laravel, en se basant sur le schéma suivant :

📚 Schéma Utilisé
developpeur(idDev, nom, prenom)
projet(idP, titre, description)
taches(idT, idDev, idP, coutHeure, DureeHeure)

🚀 1. Relations Complexes avec with, withCount, withSum, withAvg ➡️ Charger les développeurs avec leurs projets et le total des heures des tâches

$developpeurs = Developpeur::with(['projets', 'taches' => function($query) {
        $query->select('idDev', DB::raw('SUM(DureeHeure) as total_heures'))
              ->groupBy('idDev');
    }])->get();

➡️ Charger les projets avec le nombre de tâches et le coût total des tâches

$projets = Projet::withCount('taches')
    ->withSum('taches as cout_total', DB::raw('coutHeure * DureeHeure'))
    ->get();

➡️ Lister les développeurs avec la durée moyenne de leurs tâches

$developpeurs = Developpeur::withAvg('taches', 'DureeHeure')->get();

🧩 2. Conditions Complexes avec whereHas, orWhereHas, doesntHave, orDoesntHave ➡️ Obtenir les développeurs qui ont des tâches avec un coût horaire supérieur à 100

$developpeurs = Developpeur::whereHas('taches', function ($query) {
    $query->where('coutHeure', '>', 100);
})->get();

➡️ Lister les projets qui n'ont pas de tâches associées

$projets = Projet::doesntHave('taches')->get();

➡️ Lister les développeurs qui n'ont pas de tâches ou dont la tâche la plus chère dépasse 500

$developpeurs = Developpeur::whereDoesntHave('taches')
    ->orWhereHas('taches', function ($query) {
        $query->where(DB::raw('coutHeure * DureeHeure'), '>', 500);
    })->get();

⚡ 3. Requêtes Avancées avec whereRaw, having, orderByRaw, selectRaw ➡️ Afficher les projets dont le coût total des tâches dépasse 1000

$projets = Projet::selectRaw('idP, SUM(coutHeure * DureeHeure) as total_cout')
    ->join('taches', 'taches.idP', '=', 'projets.idP')
    ->groupBy('projets.idP')
    ->having('total_cout', '>', 1000)
    ->get();

➡️ Lister les développeurs en fonction du coût total de leurs tâches, triés par coût décroissant

$developpeurs = Developpeur::selectRaw('developpeurs.*, SUM(coutHeure * DureeHeure) as total_cout')
    ->join('taches', 'taches.idDev', '=', 'developpeurs.idDev')
    ->groupBy('developpeurs.idDev')
    ->orderByRaw('total_cout DESC')
    ->get();

➡️ Obtenir les projets dont le coût moyen par tâche dépasse 200

$projets = Projet::selectRaw('projets.*, AVG(coutHeure * DureeHeure) as avg_cout')
    ->join('taches', 'taches.idP', '=', 'projets.idP')
    ->groupBy('projets.idP')
    ->havingRaw('avg_cout > ?', [200])
    ->get();

🔄 4. Mise à Jour et Suppression Avancée (update, delete) ➡️ Mettre à jour le coût horaire de toutes les tâches d'un développeur spécifique

Tache::where('idDev', '=', 1)->update(['coutHeure' => DB::raw('coutHeure + 10')]);

➡️ Supprimer les tâches dont la durée est inférieure à 2 heures

Tache::where('DureeHeure', '<', 2)->delete();

➡️ Mettre à jour en fonction d'une condition complexe

Tache::whereRaw('coutHeure * DureeHeure < ?', [500])->update(['coutHeure' => DB::raw('coutHeure + 20')]);

⚙️ 5. Sub-queries et Complex Queries ➡️ Obtenir les développeurs avec le coût total de leurs tâches dans une sous-requête

$developpeurs = Developpeur::withSum(['taches as total_cout' => function ($query) {
    $query->select(DB::raw('SUM(coutHeure * DureeHeure)'));
}])->get();

➡️ Lister les projets dont le coût total est supérieur à la moyenne globale

$averageCost = Tache::select(DB::raw('AVG(coutHeure * DureeHeure)'))->first()->avg;

$projets = Projet::whereHas('taches', function($query) use ($averageCost) {
    $query->select(DB::raw('SUM(coutHeure * DureeHeure) as total_cout'))
          ->groupBy('idP')
          ->having('total_cout', '>', $averageCost);
})->get();

🔄 6. Jointures Complexes avec join, leftJoin, crossJoin ➡️ Lister les projets avec les développeurs et le coût total des tâches

$projets = DB::table('projets')
    ->join('taches', 'projets.idP', '=', 'taches.idP')
    ->join('developpeurs', 'taches.idDev', '=', 'developpeurs.idDev')
    ->select('projets.titre', 'developpeurs.nom', DB::raw('SUM(coutHeure * DureeHeure) as total_cout'))
    ->groupBy('projets.idP', 'developpeurs.idDev')
    ->get();

➡️ Lister les développeurs même s'ils n'ont pas de tâches (leftJoin)

$developpeurs = DB::table('developpeurs')
    ->leftJoin('taches', 'developpeurs.idDev', '=', 'taches.idDev')
    ->select('developpeurs.nom', DB::raw('COALESCE(SUM(coutHeure * DureeHeure), 0) as total_cout'))
    ->groupBy('developpeurs.idDev')
    ->get();

⚙️ 7. Utilisation Avancée de Collections avec map, filter, reduce ➡️ Calculer le coût total via des collections

$taches = Tache::all();

$totalCout = $taches->reduce(function ($carry, $item) {
    return $carry + ($item->coutHeure * $item->DureeHeure);
}, 0);
➡️ Filtrer les développeurs ayant des tâches dont le coût total dépasse 1000

$developpeurs = Developpeur::with('taches')->get();

$filtered = $developpeurs->filter(function ($dev) {
    return $dev->taches->sum(function ($tache) {
        return $tache->coutHeure * $tache->DureeHeure;
    }) > 1000;
});