HAPITRE 7 Langages de Manipulation Relationnels: Les calculs Relationnels C

(1)

C H A P I T R E 7

L a n g a g e s d e M a n i p u l a t i o n R e l a t i o n n e l s : L e s c a l c u l s R e l a t i o n n e l s

1. Introduction

Avec l’algèbre relationnelle, une requête est exprimée comme une séquence d’opérations à réaliser à partir des relations de la BD.

L’objectif des langages prédicatifs (ou langages de type calcul), inspirés du calcul des prédicats de la logique du premier ordre, est d'exprimer une requête par la simple définition du résultat, en faisant abstraction du mécanisme utilisé par le SGBD pour la construction de ce résultat. Ce sont donc des langages déclaratifs.

Les calculs relationnels résultent d'une adaptation du calcul des prédicats à l'interrogation de BD relationnelles. Il en existe deux types, calcul de tuples et calcul de domaines, suivant que les variables utilisées dans les formules du calcul désignent des tuples d'une relation ou des valeurs dans un domaine.

QUEL (pour INGRES) et QBE (IBM) sont des langages commercialisés dérivés du calcul relationnel (respectivement, de tuples et de domaines).

2. Le calcul de tuples

Une requête dans ce langage peut être définie par la composition d'une partie déclarative et d'une expression du calcul:

- la partie déclarative associe des variables aux relations de la BD : x ∈ R : x désignera les tuples de la relation R (“x porte sur R”);

y ∈ S ∪ T : y désignera indifféremment les tuples des relations S et T, pourvu qu'il existe dans S et T des attributs qui soient compatibles deux à deux (même nom, même domaine);

- l'expression a la forme : {x.A, y.B,..., z.D / fx, y,..., z, t, u,…., w}

où x, y,..., z, t, u, …, w sont des variables dont la portée a été déclarée auparavant: x∈R_x, y∈R_y, ..., z∈R_z, t∈R_t, ..., w∈R_w,

A, B,..., D sont des attributs des relations correspondantes,

fx,y,...,z,t,…,w est une formule valide (voir ci-dessous) ayant pour variables libres x, y,...z, et pour variables liées t, u, …,w.

La valeur de cette expression est une projection sur les attributs A,B,...,D du produit cartésien R_x ×R_y × ... ×R_z réduit aux tuples de ce produit pour lesquels la formule fx,y,...,z,t,…,w est vraie.

(2)

Exemples: soit une BD avec les trois relations :

Etudiant (nom, prénom, année de naissance, noétudiant) Inscription (noétudiant, nom cours, note1, note2) Enseignant (nom, prénom, statut)

a) nom et prénom des étudiants nés après 1979:

e ∈ Etudiant ;

{e.nom, e.prénom / e.année de naissance > 1979}

b) numéro, prénom et notes des étudiants de nom DUPONT inscrits au cours BD:

e ∈ Etudiant, i ∈ Inscription ;

{e.noétudiant, e.prénom, i.note1, i.note2 / e.nom = 'DUPONT'

∧ e.noétudiant = i.noétudiant ∧ i.nom cours = 'BD'}

Formules valides

Les formules valides sont construites à partir des règles suivantes :

R1 : une condition de la forme x.A θ a ou x.A θ y.B est une formule valide (θ désigne l'un des opérateurs de comparaison, =,≠,<,≤,>,≥, et a une constante);

R2 : si f, f₁ et f₂ sont des formules valides, alors (f), ¬f, f1 ∧ f2, f₁ ∨ f2 sont aussi des formules valides;

R3 : si fx est une formule valide où x est une variable libre, alors

∃x(fx) et ∀x(fx) sont des formules valides où x est une variable liée;

R4 : rien d'autre n'est une formule valide.

Une variable est dite liée (quantifiée) dans une formule si elle est associée au quantificateur existentiel, ∃, ou au quantificateur universel,∀. Elle est dite libre sinon.

Exemples de formules valides:

- e.année de naissance > 1979 (condition du type x.A θ a, e est une variable libre)

- e.noétudiant = i.noétudiant (condition du type x.A θ y.B, e et i sont des variables libres) - i.note1 = 10 ∨ i.note2 = 10 (formule du type f₁ ∨ f2, i est une variable libre)

- ∃i (i.note1 = 10 ∧ i.note2 = 10) (formule du type ∃x(fx), i est une variable liée).

La dernière formule peut être utilisée, par exemple, pour retrouver les étudiants ayant brillamment réussi dans un cours (les deux notes pour ce cours sont égales à 10):

e∈Etudiant, i∈Inscription;

{e.nom,e.prénom / ∃i (e.noétudiant = i.noétudiant ∧ i.note1 = 10 ∧ i.note2 = 10)}

Pour connaître les étudiants qui ont brillamment réussi tous leurs cours, on utilisera l'expression:

{e.nom,e.prénom / ∀i (e.noétudiant ≠ i.noétudiant ∨ (i.note1 = 10 ∧ i.note2 = 10)) ∧ ∃i (e.noétudiant = i.noétudiant)}

Rappels sur la logique du premier ordre

- On peut toujours mettre une formule valide sous forme prénexe (tous les quantificateurs en préfixe):

Q₁x₁,Q₂x₂,...,Qnxn (fx₁,x₂,...xn)

où Qi ∈ {∀,∃} et fx₁,x₂,...xn est une formule valide sans quantificateur.

- L'ensemble ∨,∧,¬ est redondant, dans la mesure où:

(3)

f₁∧f2 ≡ ¬ (¬f1∨¬f2)

- De même, on peut se passer du quantificateur universel, ∀, dans la mesure où:

∀x (f) ≡ ¬ (∃x(¬f))

- L'implication (qui ne fait pas partie des opérateurs de comparaison des calculs relationnels) peut s'écrire de la façon suivante:

f₁⇒f₂ ≡ ¬f1 ∨ f2

- Les formules avec quantificateurs qui portent sur un ensemble vide se traitent de la façon suivante:

∀x (fx) où x porte sur un ensemble vide ≡ Vrai ∃x (fx) où x porte sur un ensemble vide ≡ Faux et ceci quelle que soit la formule fx .

On peut montrer que le calcul de tuples peut exprimer tous les opérateurs de l'algèbre et vice-versa.

3. QUEL

(langage défini en 1975 pour le système INGRES) 3.1. Interrogation

Une requête d'interrogation s'écrit en QUEL comme suit : RANGE OF nomvariable,... IS nomrelation

....

RETRIEVE [INTO nomrelationtemporaire] ([nouveaunom=] nomvariable.nomattribut, ...) [WHERE formule] ¹

La clause INTO provoque le rangement du résultat dans une relation temporaire. L'utilisation de [nouveaunom=] permet de renommer les attributs dans le résultat.

Il n'y a pas de quantificateurs explicites dans QUEL, qui utilise la règle suivante: toutes les variables apparaissant dans la formule et non citées dans la liste qui suit le RETRIEVE sont implicitement quantifiées par ∃.

QUEL n'offre pas la possiblité d'utiliser le quantificateur universel ∀. Il est néanmoins possible d'obtenir le même effet qu'un ∀, en utilisant la fonction d'agrégation COUNT. ∀x (fx) peut s'écrire en QUEL:

COUNT (x.A WHERE ¬fx) = 0,

ou bien en effectuant l'équivalent de la différence de l'algèbre (voir l'exemple des étudiants ayant réussi tous leurs cours au paragraphe suivant).

En conclusion, la formule qui suit le WHERE est une formule valide du calcul de tuples étendue à la prise en compte des fonctions d’agrégation (voir § 3.3), sous forme prénexe, sans quantificateur universel (∀), où la déclaration des quantificateurs existentiels (∃ nomvar, ...) est omise, et où les connecteurs logiques s'écrivent : AND (et), OR (ou), NOT (non).

Exemple: lister les noms des étudiants ayant eu au moins une note égale à 10.

En calcul de tuples, cela s'écrit : e∈ Etudiant, i∈ Inscription;

{e.nom / ∃i (e.noétudiant = i.noétudiant ∧ (i.note1 = 10 ∨ i.note2 = 10))}

En QUEL, cela s'écrit :

RANGE OF e IS Etudiant RANGE OF i IS Inscription

1 Les crochets [ ] signifient que la clause est facultative.

(4)

RETRIEVE e.nom WHERE e.noétudiant = i.noétudiant AND (i.note1 = 10 OR i.note2 = 10) Exemple : noms des étudiants ayant brillamment réussi tous leurs cours.

RANGE OF e IS Etudiant RANGE OF i, i2 IS Inscription

RETRIEVE e.nom WHERE COUNT( i.noétudiant WHERE e.noétudiant = i.noétudiant AND (i.note1 < 10 OR i.note2 < 10) ) = 0

AND e.noétudiant = i2.noétudiant

En QUEL, une variable ne peut être associée qu'à une seule relation (contrairement au calcul de tuples qui permet aussi de l'associer à l'union de plusieurs relations compatibles). Une opération d'union peut néanmoins être réalisée en utilisant la commande de mise à jour APPEND. De même, on peut réaliser une différence en utilisant la commande DELETE.

Exemple : liste des noms et prénoms des étudiants et des enseignants.

En algèbre :

(π[nom,prénom] Etudiant ∪π[nom,prénom] Enseignant) En calcul de tuples :

e ∈ Etudiant ∪ Enseignant {e.nom, e.prénom}

En QUEL :

RANGE OF et IS Etudiant RANGE OF en IS Enseignant

RETRIEVE INTO EtEns (et.nom, et.prénom) APPEND TO EtEns (en.nom, en.prénom) 3.2. Mise à jour

La commande APPEND sert à insérer dans une relation soit un tuple constant, soit un ensemble de tuples provenant (recopiés) d'une autre relation. Le format général de la commande est:

APPEND TO nom relation ([nomatt₁ =] c₁, [nomatt₂ =] c₂, ..., [nomattn =] cn) [WHERE formule]

où c₁, c₂, ... , cn sont les valeurs des attributs du ou des tuples à insérer; ces valeurs peuvent être des constantes ou des expressions. La clause "WHERE formule" est employée dans le cas d'insertion de tuples provenant d'une autre relation; elle sert à sélectionner l'ensemble des tuples à insérer.

Exemple : liste des noms et des prénoms des étudiants et des enseignants assistants.

RANGE OF et IS Etudiant RANGE OF en IS Enseignant

RETRIEVE INTO EtEns (et.nom, et.prénom)

APPEND TO EtEns (en.nom, en.prénom) WHERE en.statut = "assistant"

Les autres commandes de mise à jour sont DELETE et REPLACE. La commande:

DELETE nomvariable [WHERE formule]

permet de supprimer dans la relation associée à la variable nomvariable, les tuples pour lesquels la formule est vraie.

Exemple : noms des étudiants ayant brillamment réussi tous leurs cours.

RANGE OF e IS Etudiant

RETRIEVE INTO Résultat ( n°=e.n°étudiant, nom=e.nom )

(5)

RANGE OF i IS Inscription RANGE OF r IS Résultat

DELETE r WHERE r.n°=i.n°étudiant AND ( i.note1<10 OR i.note2 <10 ) RETRIEVE r.nom /* on obtient le résultat désiré */

La commande:

REPLACE nomvariable (nomattribut1 = expression1, ...) [WHERE formule]

permet de modifier, dans la relation associée à la variable nomvariable, la valeur d'un ou de plusieurs attributs dans les tuples pour lesquels la formule est vraie.

3.3. Autres possibilités

QUEL offre également une commande de tri : SORT nomrelation

qui, en triant la relation, supprime les doubles éventuels. Car QUEL ne supprime les doubles du résultat d'une requête que si cela lui est explicitement demandé. En effet, de nombreux langages commercialisés agissent de même, car la suppression des doubles est une opération coûteuse en entrées/sorties.

QUEL permet de calculer des fonctions d'agrégation sur l'ensemble des valeurs prises par un attribut. Ces fonctions, COUNT, SUM, AVG, MIN et MAX, peuvent être utilisées dans les formules et dans les expressions des clauses:

RETRIEVE ( [nvnom=] expression , .... )

APPEND TO nomrelation ( nomatt = expression , .... ) REPLACE nomvar ( nomatt = expression , .... ) .

Le format général d'emploi d'une fonction d'agrégation est le suivant:

fonctionagreg ( nomvariable.nomatt [WHERE formule] )

où la formule de la clause WHERE est identique à celle des requêtes RETRIEVE. Le résultat d'une telle fonction d'aggrégation est une constante, dont la valeur est le cardinal (COUNT), la moyenne (AVG), le minimum (MIN), le maximum (MAX), ou la somme (SUM) des valeurs de l'attribut nomatt des tuples de la relation correspondant à nomvariable et pour lesquels la formule est vraie.

Exemples:

Nombre total d'étudiants RANGE OF e IS Etudiant

RETRIEVE COUNT(e.n°étudiant) Pour chaque cours, nombre d'étudiants inscrits

RANGE OF i, j IS Inscription

RETRIEVE i.nom cours, COUNT( j.n°étudiant WHERE j.nom cours=i.nom cours ) (1) Etant donné que les requêtes semblables à (1) sont fréquentes:

"dans la relation R(X,Y,...) calculer, pour chaque X le nombre (la moyenne, le minimum,...) de Y correspondant à cette valeur de X"

QUEL autorise un raccourci d'écriture avec l'emploi d'une seule variable et la clause BY. La requête (1) peut aussi s'écrire:

RANGE OF i IS Inscription

RETRIEVE i.nom cours, COUNT( i.n°étudiant BY i.nom cours ) L'exécution de cette requête est identique à celle de la requête (1).

Le format général des fonctions d'agrégation avec la clause BY est le suivant:

fonctionagreg ( nomvariable.nomatt1 BY nomvariable.nomatt2, ..., nomvariable.nomattk [WHERE formule] )

où la clause WHERE permet de faire une sélection sur la relation avant d'effectuer la fonction d'agrégation.

(6)

Exemple: pour chaque cours, nombre d'étudiants inscrits qui ont eu un 10 RANGE OF i IS Inscription

RETRIEVE i.nom cours, COUNT( i.n°étudiant BY i.nom cours

WHERE i.note1=10 OR i.note2=10 ) ou bien:

RANGE OF i, j IS Inscription

RETRIEVE i.nom cours, COUNT( j.n°étudiant WHERE j.nom cours=i.nom cours

AND (i.note1=10 OR i.note2=10 ) )

Remarque: QUEL est complet, c'est-à-dire qu'il permet d'exprimer toute requête d'algèbre ou du calcul (voir la démonstration par exemple dans le livre de Ullman).

4. Le calcul de domaines

Il est similaire au calcul de tuples, mais les variables portent sur les valeurs d'un attribut (et non sur les tuples d'une relation).

La partie déclarative d'une requête a la forme suivante : x ∈ R.A ou x ∈ R.A. ∪ S.B ∪ ....

L'expression a la forme : {x,y,...,z / fx,y...,z}

où f est une formule valide dont les seules variables libres sont x, y, ..., z.

Les formules valides sont définies de la même façon qu'en calcul de tuples, à ceci près que les formules élémentaires sont de deux types:

- x1 θ x2 ou x1 θ a où a est une constante, et x1 et x2 sont des variables,

- formules d'appartenance: R(A:v₁, B:v₂,...), où A,B,... sont des attributs de la relation R, et v₁,v₂,... sont soit des constantes, soit des variables. Une condition d'appartenance R(A:v₁, B:v₂, ..., E:vi) est vraie ssi dans la relation R il existe au moins un tuple ayant v₁ comme valeur pour l'attribut A, v₂ comme valeur pour l'attribut B, ..., et vi comme valeur pour l'attribut E.

Exemples:

a) noms et prénoms des étudiants nés après 1969 :

n∈ Etudiant.nom, p∈ Etudiant.prénom, a∈ Etudiant.année de naissance;

{n,p / ∃a ( Etudiant(nom:n, prénom:p, année de naissance:a) ∧ a > 1969)}

b) numéros, prénoms et notes en BD des étudiants de nom DUPONT : no∈Etudiant.noétudiant ∪ Inscription.noétudiant, p∈Etudiant.prénom, n1∈Inscription.note1, n2∈Inscription.note2;

{no,p,n1,n2 / Etudiant (nom : 'DUPONT', prénom : p, noétudiant : no) ∧ Inscription (noétudiant : no, nom cours : 'BD', note1 : n1, note2 : n2) c) noms et prénoms des étudiants ayant brillamment réussi un cours :

n∈ Etudiant.nom, p∈ Etudiant.prénom, no∈ Etudiant.noétudiant ∪ Inscription.noétudiant

{n,p / ∃no (Etudiant (nom:n, prénom:p, noétudiant:no) ∧ Inscription (noétudiant:no, note1:10, note2:10)}

d) noms et prénoms des étudiants ayant brillamment réussi tous leurs cours :

n∈ Etudiant.nom, p∈ Etudiant.prénom, no∈ Etudiant.noétudiant ∪ Inscription.noétudiant, c∈ Inscription.nom cours

{n,p / ∃no (Etudiant (nom:n, prénom:p, noétudiant:no) ∧

(7)

∀c(¬Inscription (noétudiant:no, nom cours:c) ∨

Inscription (noétudiant:no, nom cours:c, note1:10, note2:10)) ∧ ∃c (Inscription (noétudiant:no, nom cours : c)))}

On peut montrer que le calcul des domaines peut exprimer tous les opérateurs de l'algèbre et vice-versa.

5. QBE

(Query By Example, IBM)

C'est un langage visuel, défini en 1977, basé sur le calcul de domaines.

Pour spécifier une requête, d'interrogation ou de mise à jour, l'utilisateur doit d'abord demander au SGBD l'affichage des relations sur lesquelles porte la requête. Ces relations sont affichées à l'écran comme des esquisses de tableau où apparaissent, en en-tête des colonnes vides, le nom de la relation et les noms de ses attributs. Par exemple :

Etudiant nom prénom année de naissance noétudiant

Inscription noétudiant nomcours note1 note2

Une déclaration explicite de toutes les variables n'est pas nécessaire : les éléments qui composent la requête étant inscrits dans les colonnes correspondantes, ceci définit implicitement leur portée.

5.1. Interrogation

Le format du résultat (la projection finale) d'une requête d'interrogation est spécifié en inscrivant la commande P. (pour Print) dans les colonnes voulues.

Les conditions du type "nom.variable θ constante" sont spécifiées en écrivant simplement:

θ constante

dans la colonne correspondante (si θ est omis, = est implicite).

Exemple: noms et prénoms des étudiants nés après 1969.

P. P. > 1969

Pour exprimer des conditions entre variables (nomvariable₁ θ nomvariable₂) ou le fait que la même variable doit apparaître en plusieurs endroits avec la même valeur (Etudiant (noétudiant : no) ∧ Inscription (noétudiant : no)), QBE utilise des "valeurs exemple", soulignées (déclaration explicite de variable).

Ainsi la requête "numéros et prénoms des étudiants de nom DUPONT qui sont inscrits en BD" s'écrit:

DUPONT P. P. 123456

(8)

123456 BD

La répétition de la même valeur exemple (123456) dans les deux colonnes noétudiant équivaut à spécifier une jointure naturelle entre les deux relations.

Les conditions sont implicitement liées par QBE avec un connecteur logique ET. Un connecteur OU est exprimé en écrivant deux requêtes.

Exemple: noms et prénoms des étudiants nés en 1971 ou en 1970.

P. P. 1971

P. P. 1970

Zone des conditions:

Certaines requêtes comprennent des conditions difficiles à écrire directement dans les colonnes des relations.

C'est le cas, par exemple, des comparaisons de variables selon un opérateur autre que l'égalité. L'utilisateur peut alors, par appel d'une fonction spécifique, écrire cette condition dans une zone à part, appelée zone des conditions.

Exemple: numéros des étudiants ayant mieux réussi en BD à la seconde épreuve qu'à la première.

Conditions 8 < 10

P. BD 8 10

Résultat provenant de plusieurs relations:

Les requêtes dont le résultat est constitué de valeurs provenant de plusieurs relations, requièrent de l'utilisateur qu'il crée, par appel d'une fonction spécifique, une relation résultat spéciale dont il définit lui- même la structure.

(9)

Exemple: numéros, prénoms et notes en BD des étudiants de nom DUPONT.

DUPONT JEAN 123456

123456 BD 10 5

prénom noétudiant note1 note2

P. JEAN 123456 10 5

Cette dernière relation (sans nom) est la relation résultat créée par l'utilisateur. (L'utilisateur n'est pas requis de mettre des noms aux attributs de la relation résultat.). La commande P. indiquée dans l'entête de la ligne signifie que toute la ligne doit être affichée en résultat.

Quantificateurs: Toutes les variables qui ne font pas partie du résultat sont implicitement quantifiées par ∃.

Le quantificateur universel (∀) peut être simulé soit par des négations, soit par l'emploi du mot clé ALL qui permet de manipuler l'ensemble des valeurs prises par un attribut (voir ci-dessous).

Exemple: noms et prénoms des étudiants ayant brillamment réussi un cours.

P. P. 123456

123456 10 10

Exemple: noms et prénoms des étudiants ayant brillamment réussi tous leurs cours.

On peut écrire cette requête à l'aide d'une négation par note: il n'existe pas, pour cet étudiant, de tuple avec une note inférieure à 10.

P. P. 123456

¬ 123456 < 10

Définition: la négation (¬) notée en face d'un tuple d'une relation R signifie: il n'existe pas dans R de tuple satisfaisant les conditions indiquées.

On peut aussi employer le mot clé ALL qui définit un "multi-ensemble" (ensemble avec des doubles éventuels) de valeurs, auquel on peut donner un nom de variable en faisant suivre le mot clé "ALL." d'un nom exemple. La requête précédente s'écrit :

(10)

P. P. 123456

123456 ALL.C

123456 ALL.C 10 10

Dans cette requête la première ligne de Inscription signifie:

soit ALL.C une variable représentant l'ensemble des noms des cours où est inscrit l'étudiant de numéro 123456.

La seconde ligne signifie:

soit ALL.C une variable représentant l'ensemble des noms des cours où est inscrit l'étudiant de numéro 123456 et où il a obtenu 10 aux deux notes.

La requête est satisfaite (et affiche donc un nom et un prénom) pour tout étudiant pour lequel ces deux multi- ensembles sont égaux.

Doubles:

QBE supprime implicitement les doubles du résultat. Pour les conserver, il faut spécifier ALL.nomvariable dans la colonne correspondante.

Exemple: liste des noms des étudiants

P.ALL.DUPONT

Tri:

On peut aussi demander un résultat trié, en spécifiant l'ordre (AO: ascending order, DO: descending order) avec le nom de la variable.

Exemple: liste ordonnée des noms des étudiants

P.AO.DUPONT

(11)

Fermeture transitive:

Si une relation est cyclique, QBE permet la recherche par transitivité.

Exemple: la requête:

Prérequis nom cours nom cours prérequis

BD COURSX

COURSX P.COURSY

permet de retrouver les cours qui sont prérequis pour les cours prérequis par le cours BD.

Cette même requête peut s'écrire en utilisant le mot clé L (pour Level) qui, associé à un entier, spécifie le nombre de niveaux de transitivité à parcourir (2 dans cet exemple):

BD P.COURSY (2L)

La recherche de la fermeture transitive (tous les prérequis d'un cours à quelque niveau que ce soit) est spécifiée en remplaçant la constante entière par une variable exemple:

BD P.COURSY (2L)

Cette possibilité de calculer la fermeture transitive est particulière à QBE, qui est un des rares langages commercialisés à l'offrir.

Fonctions d'agrégation:

Les fonctions d'agrégation classiques (COUNT, SUM, AVG, MAX, MIN) peuvent être utilisées, associées à une variable précédée de ALL. Si les doubles ne doivent pas être pris en compte par la fonction, on spécifiera UNQ (unique) avant le mot clef ALL. L'opérateur UNQ transforme un multi-ensemble en un ensemble en supprimant les doubles.

Exemple : nombre d'étudiants par année de naissance

P.COUNT.ALL.DUPONT P.1960

Exemple : nombre d'étudiants ayant eu une note1 égale à 10

Inscription noétudiant nom cours note1 note2

P.COUNT.UNQ.ALL.123456 10

(12)

5.2. Mise à jour

QBE offre trois commandes pour la mise à jour des relations : I. (insert), U. (update), D. (delete), à spécifier sous le nom de la relation.

L'insertion d'un nouveau tuple se fait en donnant les valeurs qui composent le tuple :

I. MALRAUX ANDRE 1960 643215

Lors de la modification de la valeur d'un (ou plusieurs) attribut, il faut définir dans quels tuples elle doit avoir lieu en précisant la valeur de l'identifiant des tuples à modifier (la déclaration d'une relation en QBE comprend la définition de l'identifiant). Les attributs faisant partie de l'identifiant ne sont pas modifiables.

Exemple : entrer 10 pour la note2 de BD de l'étudiant numéro 3333 (la note1 n'est pas modifiée).

Dans ce cas, la valeur de l'identifiant est connue: 3333 + BD .

U. 3333 BD 10

Exemple : augmenter d'un demi-point toute note1 inférieure à 10 pour le cours BD.

Dans ce cas, la valeur de l'identifiant n'est pas entièrement connue. Elle doit être définie dans une (des) autre ligne non préfixée par la commande U.

123456 BD 6 < 10

U. 123456 BD 6 + 0.5

La suppression d'un ou plusieurs tuples d'une relation se fait en spécifiant le critère de sélection. Par exemple, la commande suivante:

D. BD

supprime tous les tuples d'Inscription concernant le cours BD.

De la même façon que pour la commande U., la définition du (des) tuples à modifier peut être faite à l'aide d'autres lignes non préfixées par D.

5.3. Evaluation d'une requête QBE

Le système crée une variable tuple pour chaque ligne de la requête qui porte sur une relation de la base (pas pour la relation résultat créée par l'utilisateur si elle existe).

Le système crée un programme avec des boucles d'itération emboîtées, une par variable tuple, la variable balayant toute la relation correspondante. A chaque pas de l'itération, le système teste si les valeurs des tuples référencés par les variables satisfont la requête. Si oui, les commandes indiquées dans la requête (P., U., D., …) sont exécutées.

Dans le cas de négation, l'algorithme est légèrement modifié:

Pour la variable correspondant à la ligne avec négation, le système crée une boucle d'itération spéciale. Cette boucle sera la plus interne et elle signifiera:

(13)

"quelque soit le tuple il ne doit pas satisfaire les conditions exprimées dans la ligne avec la négation."

En pratique, les SGBDs relationnels fournissant QBE ne suivent pas mot à mot ces algorithmes, mais d'autres, éventuellement plus efficaces, sémantiquement équivalents.

(14)

(15)

E x e r c i c e s - S é r i e 1 1

Soit le schéma relationnel suivant:

Employé (Nom, Prénom, DateNaissance, Adresse, N°Avs, Salaire, N°Dep, Supérieur) Supérieur référence Employé.N°Avs

N°Dep référence Département.N°Dep Département (NomD, N°Dep, Directeur)

Directeur référence Employé.N°Avs Projet (NomP, N°Pro, Lieu, N°Dep)

N°Dep référence Département.N°Dep Travaille (N°Avs, N°Pro, Heures)

N°Pro référence Projet.N°Pro N°AVS référence Employé.N°Avs Exprimer en calcul des tuples les requêtes suivantes : 1) Date de naissance et adresse de Juliette Rochat.

2) Nom et adresse des employés qui travaillent au département de recherche.

3) Nom et prénom des employés dont le supérieur est Juliette Rochat.

4) Nom des employés qui travaillent plus de 10 heures sur un projet à Genève.

5) Nom des projets sur lesquels travaillent Jean Muller et Annie Grandjean. Attention le "et" du français signifie ici que l’un ou l’autre, ou les deux, doivent travailler au projet.

6) Nom des projets sur lesquels travaillent à la fois Jean Muller et Annie Grandjean.

7) Nom et prénom des employés qui ne travaillent sur aucun projet.

8) Numéro des projets qui ont au moins un participant de chaque département.

9) Nom des employés qui ne travaillent pas sur un projet à Genève.

10) Nom des employés qui ne travaillent que sur des projets à Genève.

Traduire en français les requêtes suivantes:

11) e1, e2 ∈ Employé t1, t2 ∈ Travaille

{ e1.Nom, e1.Prénom / ∃e2, ∃t1, ∃t2 ( e2.Nom= "Rochat"∧

e2.Prénom="Juliette"∧ e2.N°Avs=t2.N°Avs ∧ e1.N°Avs=t1.N°Avs ∧ t1.N°Pro=t2.N°Pro ) }

12) e ∈ Employé p ∈ Projet t ∈ Travaille

{ e.Nom, e.Prénom / ∀p (p.N°Dep≠e.N°Dep ∨ ∃t (t.N°Avs=e.N°Avs ∧ t.N°Pro=p.N°Pro )) }