Repas

1. Calcul relationnel de domaine :

   • \(R=\{ p \; | repas(jour='2017-01-01',p:personne)\}\)

2. Algèbre relationnelle :

   • \(R=\Pi_{personne}(\sigma_{[jour='2017-01-01']}(repas))\)

3. Requête SQL :

   SELECT personne FROM repas
   WHERE jour='2017-01-01';
   

1. Calcul relationnel de n-uplets

   • \(R=\{ m.plat \; | \; m \in menus \land r \in repas \land m.jour=r.jour \land r.personne='Nono'\}\)

2. Algèbre relationnelle :

   • \(R=\Pi_{plat}(\Join_{[menus.jour=repas.jour]}(menu,\sigma_{[personne='Nono']}(repas)) )\)

3. Requête SQL :

   -- produit cartésien et restriction
   SELECT DISTINCT plat
   FROM repas r, menus m
   WHERE r.jour=m.jour AND personne='Nono';
   
   -- jointure naturelle
   SELECT DISTINCT plat
   FROM repas r NATURAL JOIN  menus m
   WHERE personne='Nono';
   

• \(R=\Pi_{personne}(\Join_{[repas.jour=menus.jour]}(repas,\Join_{[menus.plat=gouts.plat]}(menus,gouts)) )\)

1. Une formulation en langage naturel pourrait être :

   • « Rechercher les personnes qui lors d’un repas ont eu au moins un de leur plat préféré. »

2. Ecrire la requête SQL correspondante

   -- Jointure naturelle
   SELECT DISTINCT personne
   FROM repas NATURAL JOIN  menus NATURAL JOIN  gouts;
   
   -- Produit cartesien, restriction
   SELECT DISTINCT r.personne
   FROM repas r, menus m, gouts g
   WHERE r.jour=m.jour AND g.plat=m.plat AND r.personne=g.personne;
   

3. Ecrire la requête en calcul relationnel de n-uplets

   • \(R=\{ r.personne \; | \; r \in repas \land m \in menus \land p \in gouts \land r.jour=m.jour \land m.plat=p.plat\}\)

1. Calcul relationnel de n-uplets

   • \(R=\{ nom \; | \; (nom:g.personne, g \in gouts) \land \neg (nom:r.personne, r \in repas) \}\)

   ou :

   • \(R=\{ nom \; | \; (nom:g.personne, g \in gouts) \} \setminus \{ nom \; | \; (nom:r.personne, r \in repas) \}\)

2. Algèbre relationnelle :

   • \(R_1=\Pi_{personne}(gouts)\)
   • \(R_2=\Pi_{personne}(repas)\)
   • \(R=\setminus(R_1,R_2)\)

   ou :

   • \(R=\setminus(\Pi_{personne}(gouts),\Pi_{personne}(repas))\)

3. Requête SQL :

   SELECT personne FROM gouts
   EXCEPT
   SELECT personne FROM repas;
   
   -- ou : requete imbriquee avec IN
   
   SELECT personne
   FROM gouts
   WHERE personne NOT IN (
                          SELECT personne
                          FROM repas
                         );
   
   -- ou : requete imbriquee avec EXISTS
   
   SELECT personne
   FROM gouts g
   WHERE NOT EXISTS (
                     SELECT *
                     FROM repas r
                     WHERE g.personne=r.personne
                    );
   

\(R=\{ p \; | \; \forall j \; repas(j:jour,p:personne), menus(j,-) \}\)

1. Une formulation en langage naturel pourrait être :

   • « Rechercher les personnes qui sont venues à tous les repas. »

2. Ecrire la requête SQL correspondante

   --  Double  NOT EXISTS
   SELECT DISTINCT personne
   FROM  repas re
   WHERE NOT EXISTS (
                     SELECT *
                     FROM menus m
                     WHERE NOT EXISTS (
                                       SELECT *
                                       FROM repas ri
                                       WHERE m.jour=ri.jour AND ri.personne=re.personne
                                      )
                    );
   -- NOT EXISTS, EXCEPT
   SELECT DISTINCT personne
   FROM repas re
   WHERE NOT EXISTS (SELECT jour
                     FROM menus
                     EXCEPT
                     SELECT jour
                     FROM repas ri
                     WHERE  ri.personne=re.personne);
   
   
   -- GROUP BY HAVING, COUNT
   SELECT personne FROM repas
   GROUP BY personne
   HAVING COUNT(DISTINCT jour) = (
                                  SELECT COUNT(DISTINCT jour)
                                  FROM menus
                                 );
   

3. Ecrire la requête en algèbre relationnelle.

   • \(R=\div(repas,\Pi_{jour}(menus))\)

SELECT *
FROM menus me
WHERE
   (
    SELECT plat
    FROM gouts
    WHERE personne='Jojo'
    EXCEPT
    SELECT plat
    FROM  menus mi
    WHERE me.jour = mi.jour
   ) IS NULL;

Trouvez les formulations :

1. En langage naturel :

   • Rechercher les menus dont les plats correspondront à tous les goûts de “Jojo”

2. En calcul relationnel de n-uplets :

   • \(R=\{ m \; | \; m \in menus \land \forall ('Jojo',plat) \in gouts, (m.jour,plat) \in menus\}\)

3. En algèbre relationnelle :

   • \(R=\div(menus,\Pi_{plat}(\sigma_{[personne='Jojo']}(gouts)))\)