Chapitre 6 Calcul - SQL - Algèbre : Cinémas - Films

6.1 Schéma

Les exemples suivants sont tirés du livre Foundations of Databases de S. Abiteboul, R. Hull et V. Vianu.

SALLE (Nom,Horaire,Titre)
FILM (Titre, Realisateur, Acteur)
PRODUIT (Producteur,Titre)
VU (Spectateur,Titre)
AIME (Spectateur,Titre)

Un film est réalisé par un metteur en scène mais peut être financé par plusieurs Producteurs. Un Spectateur peut aimer un film sans l'avoir vu.

6.2 Requêtes

Écrire les requêtes suivantes en algèbre relationnel, en calcul à variable n-uplet et en calcul à variable domaine.

6.2.1 Interrogation d'une seule Relation

Requête 1 :

Dans quelle salle et à quelle heure peut on voir le film ``Mad Max''?

Algèbre :

pi_Nom,Horaire (sigma_{Titre='Mad Max'}(SALLE))

SQL :

         SELECT Nom, Horaire
           FROM SALLE
          WHERE Titre = 'Mad Max'

Calcul n-uplet :

{ sx.Nom, sx.Horaire | SALLE(sx) /\ sx.Titre = 'Mad Max' }

Calcul domaine :

{ nx, hx | SALLE('Mad Max', nx, hx) }

Requête 2 :

Quels sont les films réalisés par Orson Welles ?

Algèbre :

pi_Titre (sigma_{Realisateur='Welles'} (FILM))

SQL :

         SELECT Titre
           FROM FILM
          WHERE Realisateur = 'Welles'

Calcul n-uplet :

{ fx.Titre | FILM(fx) /\ fx.Realisateur = 'Welles' }

Calcul domaine :

{ tx | il existe ax FILM(tx, 'Welles', ax) }

Requête 3 :

Quels sont les Acteurs du film ``Ran'' ?

Algèbre :

pi_Acteur (sigma_Titre='Ran' (FILM))

SQL :

         SELECT Acteur
           FROM FILM
          WHERE Titre = 'Ran'

Calcul n-uplet :

{ fx.Acteur | FILM(fx) /\ fx.Titre = 'Ran' }

Calcul domaine :

{ ax | il existe rx FILM('Ran', rx, ax)

6.2.2 Jointures

Requête 4 :

Dans quelles salles peut-on voir un film avec Simone Signoret ?

Algèbre :

pi_Nom (SALLE (sigma_{Acteur='Signoret'} (FILM)))

SQL :

         SELECT Nom
           FROM SALLE, FILM
          WHERE SALLE.Titre = FILM.Titre
                AND FILM.Acteur = 'Signoret'

Calcul n-uplet :

{ sx.Nom | il existe fx (SALLE(sx) /\ FILM(fx) /\ fx.Acteur = 'Signoret' /\ sx.Titre = fx.Titre) }

Calcul domaine :

{ nx	\|	il existe tx,rx,hx (FILM(tx,rx,'Signoret') /\
		SALLE(nx,hx,tx))}

Requête 5 :

Dans quelles salles peut on voir Marlon Brando après 16h ?

Algèbre :

pi_Nom (sigma_Horaire>16 (SALLE) (sigma_{Acteur='Brando'}(FILM)))

SQL :

         SELECT Nom
           FROM SALLE, FILM
          WHERE SALLE.Titre = FILM.Titre
                AND FILM.Acteur = 'Brando'
                AND SALLE.Horaire > 16

Calcul n-uplet :

{sx.Nom	\|	il existe fx (SALLE(sx) /\ FILM(fx) /\ fx.Acteur = 'Brando' /\
		sx.Horaire > 16 /\ sx.Titre = fx.Titre)}

Calcul domaine :

{nx | il existe tx,rx,hx (FILM(tx,rx,'Brando') /\ SALLE(nx,hx,tx) /\ hx > 16) }

Requête 6 :

Quels sont les Acteurs qui ont produit un film ?

Algèbre :

pi_Acteur (FILM _{Acteur=Producteur} PRODUIT)

SQL :

         SELECT Acteur
           FROM PRODUIT, FILM
          WHERE Acteur = Producteur

Calcul n-uplet :

{fx.Acteur	\|	il existe px (PRODUIT(px) /\ FILM(fx) /\
		fx.Acteur = px.Producteur) }

Calcul domaine :

{ax | il existe tx,ty,rx (FILM(tx,rx,ax) /\ PRODUIT(ax,ty)) }

Requête 7 :

Quels sont les Acteurs qui ont produit un film dans lequel ils jouent ?

Algèbre :

pi_Acteur(sigma_{Acteur=Producteur}(FILM PRODUIT))

SQL :

         SELECT Acteur 
           FROM FILM, PRODUIT 
          WHERE FILM.Titre = PRODUIT.Titre
                AND Acteur = Producteur

Calcul n-uplet :

{fx.Acteur	\|	il existe px (PRODUIT(px) /\ FILM(fx) /\
		fx.Acteur=px.Producteur /\ fx.Titre = px.Titre )}

Calcul domaine :

{ax | il existe tx,rx (FILM(tx,rx,ax) /\ PRODUIT(ax,tx))}

Requête 8 :

Quels sont les Acteurs qui ont produit et réalisé un film ?

Algèbre :

R1	:=	pi_Realisateur(sigma_{Producteur=Realisateur}(PRODUIT FILM))
R2	:=	pi_Acteur(FILM _{Acteur = Realisateur} R1)

SQL :

         SELECT A.Acteur
           FROM FILM A, FILM B, PRODUIT C
          WHERE A.Acteur = B.Realisateur
                AND B.Realisateur = C.Producteur 
                AND B.Titre = C.Titre

Calcul n-uplet :

{fx.Acteur	\|	il existe fy,px (FILM(fx) /\ FILM(fy) /\ PRODUIT(px) /\
		fx.Acteur = px.Producteur /\ fy.Realisateur = fx.Acteur /\
		px.Titre = fy.Titre) }

Calcul domaine :

{ ax

il existe tx,ty,rx,ay (FILM(tx,rx,ax) /\ PRODUIT(ax,ty) /\ FILM(ty,ax,ay)) }

Requête 9 :

Quels sont les Producteurs qui regardent les films qu'ils ont produits ?

Algèbre :

pi_Producteur(sigma_{Spectateur=Producteur}(PRODUIT VU))

Calcul n-uplet :

{px.Producteur | il existe vx (PRODUIT(px) /\ VU(vx) /\ px.Producteur = vx.Spectateur

/\ px.Titre = vx.Titre) }

Calcul domaine :

{ px | il existe tx (PRODUIT(px,tx) /\ VU(px,tx)) }

6.2.3 Difference

Requête 10 :

Quels films ne passent en ce moment dans aucune salle ?

Algèbre :

pi_Titre (FILM) - pi_Titre (SALLE)

Calcul n-uplet :

{fx.Titre | FILM(fx) /\ ¬ il existe sx (SALLE(sx) /\ sx.Titre = fx.Titre) }

Calcul domaine :

{ tx | il existe rx,ax FILM(tx,rx,ax) /\ ¬ il existe nx,hx (SALLE(nx,hx,tx)) }

Requête 11 :

Quel est le résultat de la requête suivante (ATTENTION, la requête n'est pas saine!) ?

{fx.Titre | FILM(fx) /\ pour tout sx (SALLE(sx) /\ sx.Titre != fx.Titre) }

La requête n'est pas indépendante du domaine : la variable sx peut correspondre à toutes les salles, mais aussi à toutes les acteurs, films etc.... Dans le dernier cas, le résultat est vide.

Requête 12 :

Quels Spectateurs aiment un film qu'ils n'ont pas vu ?

Algèbre :

pi_Spectateur (AIME - VU)

Calcul n-uplet :

{ ax.Spectateur	\|	AIME(ax) /\ ¬ il existe vx (VU(vx) /\
		ax.Spectateur = vx.Spectateur /\ ax.Titre = vx.Titre) }

Calcul domaine :

{ sx | il existe tx AIME(sx, tx) /\ ¬ VU(sx, tx) }

Requête 13 :

Qui n'aime aucun film qu'il a vu ?

Algèbre :

pi_Spectateur (VU) - pi_Spectateur (AIME VU)

Calcul n-uplet :

{ vx.Spectateur	\|	VU(vx) /\ ¬ il existe ax,vz (AIME(ax) /\ VU(vz)
		/\ ax.Spectateur = vx.Spectateur /\ ax.Titre = vz.Titre /\
		vx.Spectateur = vz.Spectateur) }

Calcul domaine :

{ sx | VU(sx,tx) /\ ¬ il existe ty (AIME(sx,ty) /\ VU(sx,ty)) }

Requête 14 :

Qui n'a produit aucun film de Doillon ?

Algèbre :

pi_Producteur(PRODUIT) - pi_Producteur (PRODUIT (sigma_{Realisateur = 'Doillon'} FILM))

Calcul n-uplet :

{px.Producteur	\|	PRODUIT(px) /\ ¬ il existe px', fx (PRODUIT(px') /\ FILM(fx) /\
		fx.Realisateur = 'Doillon' /\ fx.Titre = px'.Titre /\ px'.Producteur = px.Producteur) }

Calcul domaine :

{ px	\|	il existe tx PRODUIT(px,tx) /\
		¬ il existe ax, tx' (PRODUIT(px, tx') /\ FILM(tx','Doillon',ax)) }

Requête 15 :

Qui a produit un film qui ne passe dans aucune salle ?

Algèbre :

pi_Producteur(PRODUIT (pi_Titre FILM - pi_Titre SALLE))

Calcul n-uplet :

{px.Producteur	\|	PRODUIT(px) /\ il existe fx (FILM(fx) /\ fx.Titre = px.Titre /\
		¬ il existe sx (SALLE(sx) /\ sx.Titre = fx.Titre)) }

Calcul domaine :

{ px	\|	il existe tx PRODUIT(px,tx) /\ il existe rx,ax (FILM(tx,rx,ax) /\
		¬ il existe nx,hx (SALLE(nx,hx,tx))) }

6.2.4 Division

Requête 15 :

Quels Spectateurs ont vu tous les films ? (ou Spectateurs pour lesquels il n'existe pas un film qu'ils n'ont pas vu)

Algèbre :

VU ÷ pi_Titre (FILM)

Calcul n-uplet :

{ vx.Spectateur	\|	VU(vx) /\ ¬ il existe fx (FILM(fx) /\ ¬ il existe vy (VU(vy) /\
		vy.Titre = fx.Titre /\ vy.Spectateur = vx.Spectateur)) }

Calcul domaine :

{ sx | il existe tx VU(sx,tx) /\ ¬ il existe ty (il existe rx,ax (FILM(ty,rx,ax) /\ ¬ VU(sx,ty)))}

Attention, la requête suivante n'est pas saine : la variable tx peut correspondre aux titre de films mais aussi aux acteurs, spectateurs etc... Dans le dernier cas, le résultat est toujours vide.

{ sx | pour tout tx (il existe rx,ax (FILM(tx,rx,ax) /\ VU(sx,tx))) }

Requête 16 :

Quels Acteurs jouent dans tous les films de Welles ? (ou Acteurs pour lesquels il n'existe pas un film de Welles qu'ils n'ont pas joué)

Algèbre :

(pi_Acteur,Titre (FILM))÷ (pi_Titre (sigma_{Realisateur='Welles'} (FILM)))

SQL :

  SELECT fx.Acteur
    FROM FILM fx
   WHERE NOT EXISTS ( SELECT fy
                        FROM FILM fy
                       WHERE fy.Realisateur = 'Welles'
                         AND NOT EXISTS ( SELECT fz
                                            FROM FILM fz
                                           WHERE fz.Titre = fy.Titre
                                             AND fz.Acteur = fx.Acteur
                                             ) )

Calcul n-uplet :

{ fx.Acteur	\|	FILM(fx) /\ ¬ il existe fy (FILM(fy) /\
		fy.Realisateur = 'Welles' /\ ¬ il existe fz (FILM(fz) /\
		fz.Titre = fy.Titre /\ fz.Acteur = fx.Acteur)) }

Calcul domaine :

{ax	\|	il existe tx,rx FILM(tx,rx,ax) /\
		¬ il existe ty(il existe ay FILM(ty,'Welles',ay)) /\ ¬ il existe ry FILM(ty,ry,ax) }

Attention, la requête suivante n'est pas saine (indépendante du domaine) : elle donne le bon résultat, si ty correspond à tous les films d'Orson Welles et faux sinon.

{ax

pour tout ty FILM(ty,'Welles',ax) }

Requête 17 :

Quels sont les Spectateurs qui aiment tous les films qu'ils ont vu ? (ou Spectateurs pour lesquels il n'existe pas un film qu'ils ont vu et qu'ils n'ont pas aimé)

Algèbre :

(AIME rho_{Spectateur/Spectateur'}(VU)) ÷ VU

Calcul n-uplet :

{ ax.Spectateur	\|	AIME(ax) /\ ¬ il existe vx (VU(vx) /\
		¬ il existe ay (AIME(ay) /\ ay.Titre = vx.Titre /\
		ay.Spectateur = ax.Spectateur)) }

Calcul domaine :

{ sx | il existe tx AIME(sx,tx) /\ ¬ il existe ty (VU(sx,ty) /\ ¬ AIME(sx,ty)) }

Requête 18 :

Quels sont les Producteurs qui voient tous les films qu'ils ont produit ? (ou Producteurs pour lesquels il n'existe pas un film qu'ils ont produit et qu'ils n'ont pas vu)

Algèbre :

(pi_Producteur PRODUIT _{Producteur=Spectateur} VU) ÷ PRODUIT

Calcul n-uplet :

{ px.Producteur	\|	PRODUIT(px) /\ ¬ il existe vx (VU(vx) /\
		px.Producteur = vx.Spectateur /\ ¬ il existe py (PRODUIT(py) /\
		py.Titre = vx.Titre /\ py.Producteur = px.Producteur)) }

Calcul domaine :

{ px | il existe tx PRODUIT(px,tx) /\ ¬ il existe ty (VU(px,ty) /\ ¬ PRODUIT(px,ty)) }

Requête 19 :

Quels Producteurs voient tous les films de Kurosawa ? (ou Producteurs pour lesquels il n'existe pas un film de Kurosawa qu'ils n'ont pas vu)

Algèbre :

R1	:=	pi_Titre(sigma_{Realisateur='Kurosawa'} FILM)
R2	:=	VU semijoin_{Spectateur=Producteur} PRODUIT
R3	:=	pi_Spectateur(R2 ÷ R1)

R1(Titre) : tous les Titres de films de Kurosawa
R2(...) : les films vus par des Producteurs
R3(Spectateur) : résultat

Calcul n-uplet :

{ px.Producteur	\|	px PRODUIT(px) /\ ¬ il existe fx (FILM(fx) /\

		fx.Realisateur='Kurosawa' /\ ¬ il existe vx (VU(vx) /\
		vx.Titre = fx.Titre /\ vx.Spectateur = px.Producteur)) }

Calcul domaine :

{px	\|	il existe tx PRODUIT(px,tx) /\ ¬ il existe (ty il existe ax(FILM(ty,'Kurosawa',ax)) /\
		¬ VU(px,ty)) }