1. Créer la table des étudiants :

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

2. Créer la table des cours :

      CREATE TABLE Cours (
          id_cours INT PRIMARY KEY,
          titre VARCHAR(100),
          credit INT
      );
        

3. Créer la table des inscriptions :

      CREATE TABLE Inscription (
          id_inscription INT PRIMARY KEY,
          id_etudiant INT,
          id_cours INT,
          FOREIGN KEY (id_etudiant) REFERENCES Etudiants(id_etudiant),
          FOREIGN KEY (id_cours) REFERENCES Cours(id_cours)
      );
        

4. Afficher tous les étudiants avec les cours auxquels ils sont inscrits :

      SELECT Etudiants.nom, Etudiants.prenom, Cours.titre
      FROM Inscription
      JOIN Etudiants ON Inscription.id_etudiant = Etudiants.id_etudiant
      JOIN Cours ON Inscription.id_cours = Cours.id_cours;
        

1. Créer la table des chauffeurs :

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

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

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

3. Créer la table des trajets :

      CREATE TABLE Trajets (
          id_trajet INT PRIMARY KEY,
          id_chauffeur INT,
          id_vehicule INT,
          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 avec les informations du chauffeur et du véhicule :

      SELECT Trajets.distance, Chauffeurs.nom, Chauffeurs.prenom, Vehicules.marque, Vehicules.modele
      FROM Trajets
      JOIN Chauffeurs ON Trajets.id_chauffeur = Chauffeurs.id_chauffeur
      JOIN Vehicules ON Trajets.id_vehicule = Vehicules.id_vehicule;
        

1. Créer la table des clients :

      CREATE TABLE Clients (
          id_client INT PRIMARY KEY,
          nom VARCHAR(50),
          adresse VARCHAR(100)
      );
        

2. Créer la table des commandes :

      CREATE TABLE Commandes (
          id_commande INT PRIMARY KEY,
          id_client INT,
          date_commande DATE,
          FOREIGN KEY (id_client) REFERENCES Clients(id_client)
      );
        

3. Créer la table des plats :

      CREATE TABLE Plats (
          id_plat INT PRIMARY KEY,
          nom_plat VARCHAR(50),
          prix DECIMAL(10,2)
      );
        

4. Créer la table des lignes de commande :

      CREATE TABLE Lignes_Commande (
          id_commande INT,
          id_plat INT,
          quantite INT,
          PRIMARY KEY (id_commande, id_plat),
          FOREIGN KEY (id_commande) REFERENCES Commandes(id_commande),
          FOREIGN KEY (id_plat) REFERENCES Plats(id_plat)
      );
        

5. Afficher toutes les commandes avec les détails des plats commandés et les informations du client :

      SELECT Clients.nom, Commandes.date_commande, Plats.nom_plat, Lignes_Commande.quantite
      FROM Lignes_Commande
      JOIN Commandes ON Lignes_Commande.id_commande = Commandes.id_commande
      JOIN Clients ON Commandes.id_client = Clients.id_client
      JOIN Plats ON Lignes_Commande.id_plat = Plats.id_plat;
        

1. Créer la table des utilisateurs :

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

2. Créer la table des amis :

      CREATE TABLE Amis (
          id_utilisateur1 INT,
          id_utilisateur2 INT,
          PRIMARY KEY (id_utilisateur1, id_utilisateur2),
          FOREIGN KEY (id_utilisateur1) REFERENCES Utilisateurs(id_utilisateur),
          FOREIGN KEY (id_utilisateur2) REFERENCES Utilisateurs(id_utilisateur)
      );
        

3. Créer la table des publications :

      CREATE TABLE Publications (
          id_publication INT PRIMARY KEY,
          id_utilisateur INT,
          contenu TEXT,
          FOREIGN KEY (id_utilisateur) REFERENCES Utilisateurs(id_utilisateur)
      );
        

4. Afficher toutes les publications avec les informations de l'utilisateur :

      SELECT Publications.contenu, Utilisateurs.nom, Utilisateurs.prenom
      FROM Publications
      JOIN Utilisateurs ON Publications.id_utilisateur = Utilisateurs.id_utilisateur;
        

1. Créer la table des fournisseurs :

      CREATE TABLE Fournisseurs (
          id_fournisseur INT PRIMARY KEY,
          nom VARCHAR(50),
          contact VARCHAR(50)
      );
        

2. Créer la table des produits :

      CREATE TABLE Produits (
          id_produit INT PRIMARY KEY,
          nom_produit VARCHAR(50),
          id_fournisseur INT,
          prix DECIMAL(10,2),
          FOREIGN KEY (id_fournisseur) REFERENCES Fournisseurs(id_fournisseur)
      );
        

3. Créer la table des commandes :

      CREATE TABLE Commandes (
          id_commande INT PRIMARY KEY,
          id_produit INT,
          quantite INT,
          FOREIGN KEY (id_produit) REFERENCES Produits(id_produit)
      );
        

4. Afficher toutes les commandes avec les informations du produit et du fournisseur :

      SELECT Commandes.quantite, Produits.nom_produit, Fournisseurs.nom
      FROM Commandes
      JOIN Produits ON Commandes.id_produit = Produits.id_produit
      JOIN Fournisseurs ON Produits.id_fournisseur = Fournisseurs.id_fournisseur;
        

1. Créer la table des clients :

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

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

      CREATE TABLE Reservations (
          id_reservation INT PRIMARY KEY,
          id_client INT,
          id_voiture INT,
          date_reservation DATE,
          FOREIGN KEY (id_client) REFERENCES Clients(id_client)
      );
        

3. Créer la table des voitures :

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

4. Afficher toutes les réservations avec les informations du client et de la voiture :

      SELECT Clients.nom, Voitures.marque, Voitures.modele, Reservations.date_reservation
      FROM Reservations
      JOIN Clients ON Reservations.id_client = Clients.id_client
      JOIN Voitures ON Reservations.id_voiture = Voitures.id_voiture;
        

1. Créer la table des auteurs :

      CREATE TABLE Auteurs (
          id_auteur INT PRIMARY KEY,
          nom VARCHAR(50),
          prenom VARCHAR(50)
      );
        

2. Créer la table des livres :

      CREATE TABLE Livres (
          id_livre INT PRIMARY KEY,
          titre VARCHAR(100),
          id_auteur INT,
          FOREIGN KEY (id_auteur) REFERENCES Auteurs(id_auteur)
      );
        

3. Créer la table des emprunts :

      CREATE TABLE Emprunts (
          id_emprunt INT PRIMARY KEY,
          id_livre INT,
          date_emprunt DATE,
          id_emprunteur INT,
          FOREIGN KEY (id_livre) REFERENCES Livres(id_livre)
      );
        

4. Afficher tous les livres empruntés avec les informations de l'auteur :

      SELECT Livres.titre, Auteurs.nom, Auteurs.prenom, Emprunts.date_emprunt
      FROM Emprunts
      JOIN Livres ON Emprunts.id_livre = Livres.id_livre
      JOIN Auteurs ON Livres.id_auteur = Auteurs.id_auteur;
        

1. Créer la table des participants :

      CREATE TABLE Participants (
          id_participant INT PRIMARY KEY,
          nom VARCHAR(50),
          prenom VARCHAR(50)
      );
        

2. Créer la table des ateliers :

      CREATE TABLE Ateliers (
          id_atelier INT PRIMARY KEY,
          titre VARCHAR(100),
          date_atelier DATE
      );
        

3. Créer la table des inscriptions :

      CREATE TABLE Inscription (
          id_inscription INT PRIMARY KEY,
          id_participant INT,
          id_atelier INT,
          FOREIGN KEY (id_participant) REFERENCES Participants(id_participant),
          FOREIGN KEY (id_atelier) REFERENCES Ateliers(id_atelier)
      );
        

4. Afficher tous les ateliers avec les informations des participants inscrits :

      SELECT Ateliers.titre, Participants.nom, Participants.prenom
      FROM Inscription
      JOIN Ateliers ON Inscription.id_atelier = Ateliers.id_atelier
      JOIN Participants ON Inscription.id_participant = Participants.id_participant;
        

1. Créer la table des patients :

      CREATE TABLE Patients (
          id_patient INT PRIMARY KEY,
          nom VARCHAR(50),
          prenom VARCHAR(50)
      );
        

2. Créer la table des docteurs :

      CREATE TABLE Docteurs (
          id_docteur INT PRIMARY KEY,
          nom VARCHAR(50),
          specialite VARCHAR(50)
      );
        

3. Créer la table des consultations :

      CREATE TABLE Consultations (
          id_consultation INT PRIMARY KEY,
          id_patient INT,
          id_docteur INT,
          date_consultation DATE,
          FOREIGN KEY (id_patient) REFERENCES Patients(id_patient),
          FOREIGN KEY (id_docteur) REFERENCES Docteurs(id_docteur)
      );
        

4. Afficher toutes les consultations avec les informations des patients et des docteurs :

      SELECT Patients.nom AS patient_nom, Patients.prenom AS patient_prenom, Docteurs.nom AS docteur_nom, Consultations.date_consultation
      FROM Consultations
      JOIN Patients ON Consultations.id_patient = Patients.id_patient
      JOIN Docteurs ON Consultations.id_docteur = Docteurs.id_docteur;
        

1. Créer la table des citoyens :

      CREATE TABLE Citoyens (
          id_citoyen INT PRIMARY KEY,
          nom VARCHAR(50),
          prenom VARCHAR(50)
      );
        

2. Créer la table des services :

      CREATE TABLE Services (
          id_service INT PRIMARY KEY,
          nom_service VARCHAR(50)
      );
        

3. Créer la table des demandes :

      CREATE TABLE Demandes (
          id_demande INT PRIMARY KEY,
          id_citoyen INT,
          id_service INT,
          date_demande DATE,
          FOREIGN KEY (id_citoyen) REFERENCES Citoyens(id_citoyen),
          FOREIGN KEY (id_service) REFERENCES Services(id_service)
      );
        

4. Afficher toutes les demandes avec les informations du citoyen et du service demandé :

      SELECT Citoyens.nom AS citoyen_nom, Citoyens.prenom AS citoyen_prenom, Services.nom_service, Demandes.date_demande
      FROM Demandes
      JOIN Citoyens ON Demandes.id_citoyen = Citoyens.id_citoyen
      JOIN Services ON Demandes.id_service = Services.id_service;