1. Créer les tables :

   
      CREATE TABLE Salles (
          id_salle INT PRIMARY KEY,
          nom VARCHAR(100),
          capacite INT,
          equipement TEXT
      );

      CREATE TABLE Clients (
          id_client INT PRIMARY KEY,
          nom VARCHAR(100),
          entreprise VARCHAR(100),
          telephone VARCHAR(20),
          email VARCHAR(100)
      );

      CREATE TABLE Reservations (
          id_reservation INT PRIMARY KEY,
          id_salle INT,
          date_debut DATETIME,
          date_fin DATETIME,
          id_client INT,
          statut VARCHAR(50),
          FOREIGN KEY (id_salle) REFERENCES Salles(id_salle),
          FOREIGN KEY (id_client) REFERENCES Clients(id_client)
      );
        
        

2. Afficher la liste des salles disponibles à une date et heure données :

   
      SELECT s.nom, s.capacite, s.equipement
      FROM Salles s
      WHERE s.id_salle NOT IN (
          SELECT r.id_salle
          FROM Reservations r
          WHERE r.date_debut <= '2024-08-06 18:00:00' AND r.date_fin >= '2024-08-06 20:00:00'
      );
        
        

3. Trouver les 3 clients ayant effectué le plus de réservations au cours des 12 derniers mois :

   
      SELECT c.nom, c.entreprise, COUNT(*) AS nb_reservations
      FROM Clients c
      JOIN Reservations r ON c.id_client = r.id_client
      WHERE r.date_debut >= DATE_SUB(CURDATE(), INTERVAL 12 MONTH)
      GROUP BY c.nom, c.entreprise
      ORDER BY nb_reservations DESC
      LIMIT 3;
        
        

4. Générer un rapport des réservations à venir pour la semaine prochaine, avec le nom de la salle, les dates de réservation et le nom du client :

   
      SELECT 
          s.nom AS nom_salle,
          r.date_debut,
          r.date_fin,
          c.nom AS nom_client
      FROM Reservations r
      JOIN Salles s ON r.id_salle = s.id_salle
      JOIN Clients c ON r.id_client = c.id_client
      WHERE r.date_debut BETWEEN DATE_ADD(CURDATE(), INTERVAL 7 DAY) AND DATE_ADD(CURDATE(), INTERVAL 14 DAY)
      ORDER BY r.date_debut;
        
        

5. Mettre à jour le statut d'une réservation (annulée, confirmée, etc.) en fonction de l'id de la réservation :

   
      UPDATE Reservations
      SET statut = 'Confirmée'
      WHERE id_reservation = 123;
        
        

1. Créer les tables :

   
      CREATE TABLE Utilisateurs (
          id_utilisateur INT PRIMARY KEY,
          nom VARCHAR(100),
          prenom VARCHAR(100),
          service VARCHAR(100),
          email VARCHAR(100)
      );

      CREATE TABLE Techniciens (
          id_technicien INT PRIMARY KEY,
          nom VARCHAR(100),
          prenom VARCHAR(100),
          specialite VARCHAR(100)
      );

      CREATE TABLE Incidents (
          id_incident INT PRIMARY KEY,
          titre VARCHAR(100),
          description TEXT,
          date_ouverture DATETIME,
          date_fermeture DATETIME,
          id_utilisateur INT,
          id_technicien INT,
          statut VARCHAR(50),
          FOREIGN KEY (id_utilisateur) REFERENCES Utilisateurs(id_utilisateur),
          FOREIGN KEY (id_technicien) REFERENCES Techniciens(id_technicien)
      );
        
        

2. Afficher la liste des incidents ouverts par un utilisateur spécifique :

   
      SELECT i.id_incident, i.titre, i.date_ouverture, i.date_fermeture, i.statut
      FROM Incidents i
      JOIN Utilisateurs u ON i.id_utilisateur = u.id_utilisateur
      WHERE u.id_utilisateur = 123 AND i.statut = 'Ouvert';
        
        

3. Trouver les 5 incidents les plus longs à résoudre (date_fermeture - date_ouverture) :

   
      SELECT i.id_incident, i.titre, TIMESTAMPDIFF(DAY, i.date_ouverture, i.date_fermeture) AS duree_resolution
      FROM Incidents i
      ORDER BY duree_resolution DESC
      LIMIT 5;
        
        

4. Générer un rapport hebdomadaire des incidents par statut (ouvert, en cours, résolu, etc.) :

   
      SELECT 
          DATE(i.date_ouverture) AS date_rapport,
          i.statut,
          COUNT(*) AS nb_incidents
      FROM Incidents i
      WHERE i.date_ouverture BETWEEN DATE_SUB(CURDATE(), INTERVAL 7 DAY) AND CURDATE()
      GROUP BY DATE(i.date_ouverture), i.statut
      ORDER BY date_rapport, i.statut;
        
        

5. Mettre à jour le statut d'un incident et affecter un technicien en fonction de l'id de l'incident :

   
      UPDATE Incidents
      SET statut = 'En cours',
          id_technicien = 456
      WHERE id_incident = 789;
        
        

1. Création des tables :

   
      CREATE TABLE Departements (
          id_departement INT PRIMARY KEY,
          nom VARCHAR(100),
          responsable VARCHAR(100)
      );

      CREATE TABLE Employes (
          id_employe INT PRIMARY KEY,
          nom VARCHAR(100),
          prenom VARCHAR(100),
          date_naissance DATE,
          date_embauche DATE,
          poste VARCHAR(100),
          salaire DECIMAL(10,2),
          id_departement INT,
          FOREIGN KEY (id_departement) REFERENCES Departements(id_departement)
      );

      CREATE TABLE Formations (
          id_formation INT PRIMARY KEY,
          nom VARCHAR(100),
          description TEXT,
          date_debut DATE,
          date_fin DATE
      );

      CREATE TABLE Participation (
          id_employe INT,
          id_formation INT,
          note DECIMAL(5,2),
          PRIMARY KEY (id_employe, id_formation),
          FOREIGN KEY (id_employe) REFERENCES Employes(id_employe),
          FOREIGN KEY (id_formation) REFERENCES Formations(id_formation)
      );
        
        

2. Afficher la liste des employés d'un département spécifique, triés par salaire décroissant :

   
      SELECT e.id_employe, e.nom, e.prenom, e.salaire
      FROM Employes e
      WHERE e.id_departement = 123
      ORDER BY e.salaire DESC;
        
        

3. Trouver les 3 employés ayant suivi le plus de formations au cours des 2 dernières années :

   
      SELECT e.id_employe, e.nom, e.prenom, COUNT(p.id_formation) AS nb_formations
      FROM Employes e
      JOIN Participation p ON e.id_employe = p.id_employe
      WHERE p.date_debut >= DATE_SUB(CURDATE(), INTERVAL 2 YEAR)
      GROUP BY e.id_employe
      ORDER BY nb_formations DESC
      LIMIT 3;
        
        

4. Générer un rapport des formations à venir, avec le nom de la formation, les dates et la liste des employés inscrits :

   
      SELECT 
          f.nom AS formation,
          f.date_debut,
          f.date_fin,
          GROUP_CONCAT(e.nom, ' ', e.prenom) AS employes_inscrits
      FROM Formations f
      JOIN Participation p ON f.id_formation = p.id_formation
      JOIN Employes e ON p.id_employe = e.id_employe
      WHERE f.date_debut > CURDATE()
      GROUP BY f.id_formation;
        
        

5. Calculer la masse salariale totale de l'entreprise, par département :

   
      SELECT 
          d.nom AS departement,
          SUM(e.salaire) AS masse_salariale
      FROM Employes e
      JOIN Departements d ON e.id_departement = d.id_departement
      GROUP BY d.id_departement;
        
        

1. Afficher la liste des projets d'un client spécifique, avec le budget total et le pourcentage d'avancement :

   
      SELECT 
          p.id_projet,
          p.nom AS projet,
          p.budget,
          ROUND(100 * SUM(CASE WHEN t.date_fin < CURDATE() THEN 1 ELSE 0 END) / COUNT(t.id_tache), 2) AS pourcentage_avancement
      FROM Projets p
      JOIN Tâches t ON p.id_projet = t.id_projet
      WHERE p.id_client = 123
      GROUP BY p.id_projet;
        
        

2. Trouver les 5 employés les plus sollicités (nombre de tâches assignées) :

   
      SELECT 
          e.id_employe,
          e.nom,
          e.prenom,
          COUNT(t.id_tache) AS nb_taches_assignees
      FROM Employés e
      JOIN Tâches t ON e.id_employe = t.assignee
      GROUP BY e.id_employe
      ORDER BY nb_taches_assignees DESC
      LIMIT 5;
        
        

3. Générer un rapport des tâches en retard (date_fin < date_actuelle), avec le nom du projet, le nom de la tâche et l'assignee :

   
      SELECT 
          p.nom AS projet,
          t.nom AS tâche,
          e.nom AS assignee
      FROM Tâches t
      JOIN Projets p ON t.id_projet = p.id_projet
      JOIN Employés e ON t.assignee = e.id_employe
      WHERE t.date_fin < CURDATE();
        
        

4. Mettre à jour le budget d'un projet spécifique en fonction de son id :

   
      UPDATE Projets
      SET budget = 500000
      WHERE id_projet = 456;
        
        

1. Afficher la liste des produits en rupture de stock (quantite_stock < seuil_alerte) :

   
      SELECT 
          p.id_produit,
          p.nom, 
          p.quantite_stock
      FROM Produits p
      WHERE p.quantite_stock < 10; -- seuil d'alerte de 10 unités
        
        

2. Trouver les 10 produits les plus vendus au cours des 6 derniers mois :

   
      SELECT 
          p.id_produit,
          p.nom,
          SUM(v.quantite) AS quantite_vendue
      FROM Produits p
      JOIN Ventes v ON p.id_produit = v.id_produit
      WHERE v.date_vente >= DATE_SUB(CURDATE(), INTERVAL 6 MONTH)
      GROUP BY p.id_produit
      ORDER BY quantite_vendue DESC
      LIMIT 10;
        
        

3. Générer un rapport des commandes passées auprès d'un fournisseur spécifique, avec le nom du produit, la quantité et le prix total :

   
      SELECT 
          p.nom AS produit,
          c.quantite,
          c.prix_total
      FROM Commandes c
      JOIN Produits p ON c.id_produit = p.id_produit
      WHERE c.id_fournisseur = 123
      ORDER BY c.date_commande DESC;
        
        

4. Mettre à jour la quantité en stock d'un produit spécifique en fonction de son id, après une vente ou une commande :

   
      -- Après une vente
      UPDATE Produits
      SET quantite_stock = quantite_stock - 5 -- quantité vendue
      WHERE id_produit = 456;

      -- Après une commande
      UPDATE Produits 
      SET quantite_stock = quantite_stock + 10 -- quantité commandée
      WHERE id_produit = 456;
        
        

1. Créer la table des utilisateurs :

      CREATE TABLE Utilisateurs (
          id_utilisateur INT PRIMARY KEY,
          nom VARCHAR(50),
          email VARCHAR(50) UNIQUE,
          date_inscription DATE
      );
        

2. Créer la table des films :

      CREATE TABLE Films (
          id_film INT PRIMARY KEY,
          titre VARCHAR(100),
          genre VARCHAR(50),
          annee_sortie INT
      );
        

3. Créer la table des visionnages :

      CREATE TABLE Visionnages (
          id_utilisateur INT,
          id_film INT,
          date_visionnage DATE,
          FOREIGN KEY (id_utilisateur) REFERENCES Utilisateurs(id_utilisateur),
          FOREIGN KEY (id_film) REFERENCES Films(id_film)
      );
        

4. Afficher la liste des films visionnés par un utilisateur spécifique :

      SELECT Films.titre
      FROM Visionnages
      JOIN Films ON Visionnages.id_film = Films.id_film
      WHERE Visionnages.id_utilisateur = 1;  -- Remplacez 1 par l'id de l'utilisateur
        

5. Trouver les 5 films les plus visionnés :

      SELECT Films.titre, COUNT(Visionnages.id_film) AS nombre_visionnages
      FROM Visionnages
      JOIN Films ON Visionnages.id_film = Films.id_film
      GROUP BY Films.titre
      ORDER BY nombre_visionnages DESC
      LIMIT 5;
        

1. Créer la table des étudiants :

      CREATE TABLE Etudiants (
          id_etudiant INT PRIMARY KEY,
          nom VARCHAR(50),
          prenom VARCHAR(50),
          date_naissance DATE
      );
        

2. Créer la table des cours :

      CREATE TABLE Cours (
          id_cours INT PRIMARY KEY,
          titre VARCHAR(100),
          description TEXT,
          credits INT
      );
        

3. Créer la table des inscriptions :

      CREATE TABLE Inscription (
          id_etudiant INT,
          id_cours INT,
          date_inscription DATE,
          FOREIGN KEY (id_etudiant) REFERENCES Etudiants(id_etudiant),
          FOREIGN KEY (id_cours) REFERENCES Cours(id_cours)
      );
        

4. Afficher tous les cours suivis par un étudiant spécifique :

      SELECT Cours.titre
      FROM Inscription
      JOIN Cours ON Inscription.id_cours = Cours.id_cours
      WHERE Inscription.id_etudiant = 1;  -- Remplacez 1 par l'id de l'étudiant
        

5. Compter le nombre d'étudiants inscrits à chaque cours :

      SELECT Cours.titre, COUNT(Inscription.id_etudiant) AS nombre_etudiants
      FROM Inscription
      JOIN Cours ON Inscription.id_cours = Cours.id_cours
      GROUP BY Cours.titre;
        

1. Créer la table des clients :

      CREATE TABLE Clients (
          id_client INT PRIMARY KEY,
          nom VARCHAR(50),
          prenom VARCHAR(50),
          email VARCHAR(50) UNIQUE
      );
        

2. Créer la table des voitures :

      CREATE TABLE Voitures (
          id_voiture INT PRIMARY KEY,
          marque VARCHAR(50),
          modele VARCHAR(50),
          annee INT
      );
        

3. Créer la table des locations :

      CREATE TABLE Locations (
          id_location INT PRIMARY KEY,
          id_client INT,
          id_voiture INT,
          date_location DATE,
          date_retour DATE,
          FOREIGN KEY (id_client) REFERENCES Clients(id_client),
          FOREIGN KEY (id_voiture) REFERENCES Voitures(id_voiture)
      );
        

4. Afficher toutes les locations effectuées par un client spécifique :

      SELECT Voitures.marque, Voitures.modele, Locations.date_location, Locations.date_retour
      FROM Locations
      JOIN Voitures ON Locations.id_voiture = Voitures.id_voiture
      WHERE Locations.id_client = 1;  -- Remplacez 1 par l'id du client
        

5. Trouver la voiture la plus souvent louée :

      SELECT Voitures.marque, Voitures.modele, COUNT(Locations.id_voiture) AS nombre_locations
      FROM Locations
      JOIN Voitures ON Locations.id_voiture = Voitures.id_voiture
      GROUP BY Voitures.id_voiture
      ORDER BY nombre_locations DESC
      LIMIT 1;
        

1. Créer la table des produits :

      CREATE TABLE Produits (
          id_produit INT PRIMARY KEY,
          nom VARCHAR(100),
          prix DECIMAL(10,2),
          stock INT
      );
        

2. Créer la table des vendeurs :

      CREATE TABLE Vendeurs (
          id_vendeur INT PRIMARY KEY,
          nom VARCHAR(50),
          prenom VARCHAR(50),
          email VARCHAR(50) UNIQUE
      );
        

3. Créer la table des ventes :

      CREATE TABLE Ventes (
          id_vente INT PRIMARY KEY,
          id_produit INT,
          id_vendeur INT,
          date_vente DATE,
          quantite INT,
          FOREIGN KEY (id_produit) REFERENCES Produits(id_produit),
          FOREIGN KEY (id_vendeur) REFERENCES Vendeurs(id_vendeur)
      );
        

4. Afficher le total des ventes pour un vendeur spécifique :

      SELECT SUM(Ventes.quantite * Produits.prix) AS total_ventes
      FROM Ventes
      JOIN Produits ON Ventes.id_produit = Produits.id_produit
      WHERE Ventes.id_vendeur = 1;  -- Remplacez 1 par l'id du vendeur
        

5. Trouver le produit le plus vendu :

      SELECT Produits.nom, SUM(Ventes.quantite) AS total_vendu
      FROM Ventes
      JOIN Produits ON Ventes.id_produit = Produits.id_produit
      GROUP BY Produits.id_produit
      ORDER BY total_vendu DESC
      LIMIT 1;
        

1. Créer la table des chauffeurs :

      CREATE TABLE Chauffeurs (
          id_chauffeur INT PRIMARY KEY,
          nom VARCHAR(50),
          prenom VARCHAR(50),
          permis VARCHAR(20)
      );
        

2. Créer la table des véhicules :

      CREATE TABLE Vehicules (
          id_vehicule INT PRIMARY KEY,
          marque VARCHAR(50),
          modele VARCHAR(50),
          annee INT
      );
        

3. Créer la table des trajets :

      CREATE TABLE Trajets (
          id_trajet INT PRIMARY KEY,
          id_chauffeur INT,
          id_vehicule INT,
          date_trajet DATE,
          distance DECIMAL(10,2),
          FOREIGN KEY (id_chauffeur) REFERENCES Chauffeurs(id_chauffeur),
          FOREIGN KEY (id_vehicule) REFERENCES Vehicules(id_vehicule)
      );
        

4. Afficher tous les trajets effectués par un chauffeur spécifique :

      SELECT Trajets.date_trajet, Trajets.distance
      FROM Trajets
      WHERE Trajets.id_chauffeur = 1;  -- Remplacez 1 par l'id du chauffeur
        

5. Calculer la distance totale parcourue par un véhicule spécifique :

      SELECT SUM(Trajets.distance) AS distance_totale
      FROM Trajets
      WHERE Trajets.id_vehicule = 1;  -- Remplacez 1 par l'id du véhicule
        

1. Créer la table des utilisateurs :

      CREATE TABLE Utilisateurs (
          id_utilisateur INT PRIMARY KEY,
          nom VARCHAR(50),
          adresse VARCHAR(100),
          telephone VARCHAR(20)
      );
        

2. Créer la table des livraisons :

      CREATE TABLE Livraisons (
          id_livraison INT PRIMARY KEY,
          id_utilisateur INT,
          date_livraison DATE,
          FOREIGN KEY (id_utilisateur) REFERENCES Utilisateurs(id_utilisateur)
      );
        

3. Créer la table des produits :

      CREATE TABLE Produits (
          id_produit INT PRIMARY KEY,
          nom VARCHAR(50),
          prix DECIMAL(10,2)
      );
        

4. Afficher toutes les livraisons effectuées pour un utilisateur spécifique :

      SELECT * FROM Livraisons WHERE id_utilisateur = 1;  -- Remplacez 1 par l'id de l'utilisateur
        

5. Calculer le montant total des livraisons effectuées par un utilisateur :

      SELECT SUM(Produits.prix) AS montant_total
      FROM Livraisons
      JOIN Produits ON Livraisons.id_livraison = Produits.id_produit
      WHERE Livraisons.id_utilisateur = 1;  -- Remplacez 1 par l'id de l'utilisateur
        

1. Créer la table des clients :

      CREATE TABLE Clients (
          id_client INT PRIMARY KEY,
          nom VARCHAR(50),
          prenom VARCHAR(50),
          date_naissance DATE
      );
        

2. Créer la table des polices :

      CREATE TABLE Polices (
          id_police INT PRIMARY KEY,
          id_client INT,
          type_assurance VARCHAR(50),
          date_debut DATE,
          FOREIGN KEY (id_client) REFERENCES Clients(id_client)
      );
        

3. Créer la table des sinistres :

      CREATE TABLE Sinistres (
          id_sinistre INT PRIMARY KEY,
          id_police INT,
          date_sinistre DATE,
          montant DECIMAL(10,2),
          FOREIGN KEY (id_police) REFERENCES Polices(id_police)
      );
        

4. Afficher tous les sinistres d'une police spécifique :

      SELECT * FROM Sinistres WHERE id_police = 1;  -- Remplacez 1 par l'id de la police
        

5. Compter le nombre de sinistres pour chaque type d'assurance :

      SELECT Polices.type_assurance, COUNT(Sinistres.id_sinistre) AS nombre_sinistres
      FROM Polices
      LEFT JOIN Sinistres ON Polices.id_police = Sinistres.id_police
      GROUP BY Polices.type_assurance;
        

1. Créer la table des utilisateurs :

      CREATE TABLE Utilisateurs (
          id_utilisateur INT PRIMARY KEY,
          nom VARCHAR(50),
          prenom VARCHAR(50),
          date_inscription DATE
      );
        

2. Créer la table des amis :

      CREATE TABLE Amis (
          id_utilisateur1 INT,
          id_utilisateur2 INT,
          date_ami DATE,
          PRIMARY KEY (id_utilisateur1, id_utilisateur2)
      );
        

3. Créer la table des messages :

      CREATE TABLE Messages (
          id_message INT PRIMARY KEY,
          id_envoyeur INT,
          id_destinataire INT,
          contenu TEXT,
          date_envoi DATE
      );
        

4. Afficher tous les amis d'un utilisateur spécifique :

      SELECT U2.nom, U2.prenom
      FROM Amis A
      JOIN Utilisateurs U1 ON A.id_utilisateur1 = U1.id_utilisateur
      JOIN Utilisateurs U2 ON A.id_utilisateur2 = U2.id_utilisateur
      WHERE U1.id_utilisateur = 1;  -- Remplacez 1 par l'id de l'utilisateur
        

5. Trouver le nombre total de messages échangés entre deux utilisateurs :

      SELECT COUNT(*) AS nombre_messages
      FROM Messages
      WHERE (id_envoyeur = 1 AND id_destinataire = 2) OR (id_envoyeur = 2 AND id_destinataire = 1);  -- Remplacez 1 et 2 par les ids des utilisateurs
        

1. Créer la table des voyageurs :

      CREATE TABLE Voyageurs (
          id_voyageur INT PRIMARY KEY,
          nom VARCHAR(50),
          prenom VARCHAR(50),
          email VARCHAR(50) UNIQUE
      );
        

2. Créer la table des destinations :

      CREATE TABLE Destinations (
          id_destination INT PRIMARY KEY,
          nom VARCHAR(100),
          pays VARCHAR(50),
          prix DECIMAL(10,2)
      );
        

3. Créer la table des réservations :

      CREATE TABLE Reservations (
          id_reservation INT PRIMARY KEY,
          id_voyageur INT,
          id_destination INT,
          date_reservation DATE,
          FOREIGN KEY (id_voyageur) REFERENCES Voyageurs(id_voyageur),
          FOREIGN KEY (id_destination) REFERENCES Destinations(id_destination)
      );
        

4. Afficher toutes les réservations d'un voyageur spécifique :

      SELECT * FROM Reservations WHERE id_voyageur = 1;  -- Remplacez 1 par l'id du voyageur
        

5. Calculer le montant total des réservations effectuées par un voyageur :

      SELECT SUM(Destinations.prix) AS montant_total
      FROM Reservations
      JOIN Destinations ON Reservations.id_destination = Destinations.id_destination
      WHERE Reservations.id_voyageur = 1;  -- Remplacez 1 par l'id du voyageur
        

1. Créer la table des restaurants :

      CREATE TABLE Restaurants (
          id_restaurant INT PRIMARY KEY,
          nom VARCHAR(100),
          adresse VARCHAR(150),
          type_cuisine VARCHAR(50)
      );
        

2. Créer la table des clients :

      CREATE TABLE Clients (
          id_client INT PRIMARY KEY,
          nom VARCHAR(50),
          prenom VARCHAR(50),
          email VARCHAR(50) UNIQUE
      );
        

3. Créer la table des commandes :

      CREATE TABLE Commandes (
          id_commande INT PRIMARY KEY,
          id_client INT,
          id_restaurant INT,
          date_commande DATE,
          montant_total DECIMAL(10,2),
          FOREIGN KEY (id_client) REFERENCES Clients(id_client),
          FOREIGN KEY (id_restaurant) REFERENCES Restaurants(id_restaurant)
      );
        

4. Afficher toutes les commandes d'un client spécifique :

      SELECT * FROM Commandes WHERE id_client = 1;  -- Remplacez 1 par l'id du client
        

5. Trouver le restaurant avec le montant total des ventes le plus élevé :

      SELECT Restaurants.nom, SUM(Commandes.montant_total) AS total_ventes
      FROM Commandes
      JOIN Restaurants ON Commandes.id_restaurant = Restaurants.id_restaurant
      GROUP BY Restaurants.id_restaurant
      ORDER BY total_ventes DESC
      LIMIT 1;