Poly 04 - Langages de Manipulation Relationnels

Chapitre 4
LANGAGES DE MANIPULATION
RELATIONNELS
Le modèle relationnel a été à l'origine proposé avec deux LMDs de base, l'algèbre relationnelle et
le calcul des tuples, équivalents en puissance et qui ont fixé l'ensemble des fonctions que tout LMD
relationnel doit offrir. A partir de ces deux langages, d'autres LMDs ont pu être définis, qui sont
plus conviviaux pour les utilisateurs. En plus des fonctions de l'algèbre ou du calcul, ces LMD
offrent généralement des possibilités de mise à jour de la base de données, et d'emploi, dans les
requêtes, d'expressions arithmétiques et de fonctions d'agrégation telles que cardinalité, somme,
minimum, maximum et moyenne. On dit d'un LMD qu'il est complet s'il offre au moins les mêmes
fonctions que l'algèbre ou le calcul relationnel.
L'intérêt de l'algèbre relationnelle est multiple:

- l'algèbre a identifié les opérateurs fondamentaux d'utilisation d'une base de données relationnelle;
- ces opérateurs ont défini les principales fonctions à optimiser dans les SGBD relationnels;
- l'algèbre a donné naissance à des LMDs pour les utilisateurs. C'est le cas de ISBL, qui a été
développé par IBM en habillant l'algèbre d'une syntaxe plus agréable.
Un autre type de LMD est constitué des langages issus du calcul des prédicats de la logique du
premier ordre. Deux adaptations de ce calcul au modèle relationnel ont été proposées, qui toutes
deux ont conduit à des langages utilisateurs:
- le calcul des tuples, qui a donné naissance au LMD QUEL du SGBD relationnel Ingres,
- le calcul des domaines qui a donné naissance à des LMD de type graphique dont QBE, proposé
par IBM.
Les langages de type prédicatif sont actuellement très prisés par les utilisateurs. Une requête
exprimée dans un tel langage, spécifie par des prédicats uniquement les caractéristiques du résultat
qu'elle veut obtenir (c'est-à-dire la définition du résultat désiré). Tandis que la même requête
exprimée dans un langage algébrique, spécifie un enchaînement d'opérations conduisant au résultat
désiré (c'est-à-dire comment construire le résultat à partir des relations de la base de données).
SQL qui est le LMD relationnel le plus répandu du fait que c'est la seule norme existante
pour les LMD relationnels, comporte des caractéristiques de type algébrique et d'autres de type
prédicatif.
Dans ce cours, nous étudierons successivement ces différents types de langages.
Bases de données avancées 2005-2006 1

Partie 1 : L’ALGEBRE RELATIONNELLE
1 Introduction
L’algèbre relationnelle est un ensemble d'opérateurs qui, à partir d'une ou deux relations existantes,
créent en résultat une nouvelle relation temporaire (c'est-à-dire qui a une durée de vie limitée,
généralement la relation est détruite à la fin du programme utilisateur ou de la transaction qui l'a
créée). La relation résultat a exactement les mêmes caractéristiques qu'une relation de la base de
données et peut donc être manipulée de nouveau par les opérateurs de l'algèbre.
Formellement l'algèbre comprend:
- cinq opérateurs de base: sélection, projection, union, différence et produit,
- un opérateur syntaxique, renommer, qui ne fait que modifier le schéma et pas les tuples.
A partir de ces opérateurs, d'autres opérateurs ont été proposés qui sont équivalents à la composition
de plusieurs opérateurs de base. Ces nouveaux opérateurs, appelés opérateurs déduits, sont des
raccourcis d'écriture, qui n'apportent aucune fonctionnalité nouvelle, mais qui sont pratiques pour
l'utilisateur lors de l'écriture des requêtes. Nous présentons dans ce chapitre les opérateurs déduits
les plus fréquents: intersection, jointure naturelle, thêta jointure et division.
Les opérateurs de l'algèbre peuvent être regroupés en deux classes:

- les opérateurs provenant de la théorie mathématique sur les ensembles (applicables car chaque
relation est définie comme un ensemble de tuples): union, intersection, différence, produit;
- les opérateurs définis spécialement pour les bases de données relationnelles: sélection,
projection, jointure, division et renommage.
2 Les opérateurs
2.1. Projection
Cet opérateur construit une relation résultat où n'apparaissent que certains attributs de la relation
opérande (en termes de tableau, cela revient à extraire certaines colonnes).
Définition : soit R (A1, A2, ...., An) une relation, et soit Ai1, Ai2, ....., Aij un sous-ensemble de ses
attributs, la projection de R sur Ai1, Ai2, ....., Aij, notée :
π [Ai1, Ai2, ....., Aij] R
crée une nouvelle relation, temporaire, de schéma (Ai1, Ai2, ....., Aij) et de population égale à
l'ensemble des tuples de R "tronqués à Ai1, Ai2, ....., Aij ", i.e. :
{t / ∃r (r∈ R ∧ t.Ai1 = r.Ai1 ∧ t.Ai2 = r.Ai2 ∧ .... ∧ t.Aij = r.Aij)}
Remarque: le résultat est un ensemble de tuples sans double, c'est-à-dire que si la projection crée
des tuples en double - cas d'une projection éliminant tous les identifiants de R - ces doubles sont
supprimés automatiquement.
Exemple : soit la relation

Personne nom prénom jour-nais mois-nais an-nais sexe
Dupont Jean 30 07 72 M
Talon Achille 20 11 75 M
Rochat Marie 13 05 72 F
Martin Régis 27 03 74 M
Picard Anne 10 10 76 F
Martin Jules 05 03 74 M
On construit l'ensemble des noms et prénoms des personnes avec l'opération:

NP := π [nom, prénom] Personne
On obtient : NP nom prénom
Dupont Jean
Talon Achille
Rochat Marie
Martin Régis
Picard Anne
Martin Jules
L'opération : NA := π [nom, an-nais] Personne

donnera en résultat : NA nom an-nais
Dupont 72
Talon 75
Rochat 72
Martin 74
Picard 76
soit une population de 5 tuples au lieu des 6 tuples de la relation Personne.
2.2. Sélection
Cet opérateur construit une relation résultat où n'apparaissent que certains tuples de la relation
opérande (en termes de tableau, cela revient à extraire certaines lignes). Les tuples retenus sont
ceux satisfaisant une condition explicite, appelée prédicat de sélection.
Définition: soit R (A1, A2, ...., An) une relation, la sélection de R selon un prédicat p, notée:
σ [p] R
crée une nouvelle relation, temporaire, de schéma identique à celui de R, et de population
l'ensemble des tuples de R pour lesquels le prédicat p est vrai.
Exemple: pour créer une relation Femmes contenant l'ensemble des personnes de sexe féminin, on
écrira:
Femmes := σ [sexe = 'F'] Personne
ce qui donne en résultat :

Femmes nom prénom jour-nais mois-nais an-nais sexe
Rochat Marie 13 05 72 F
Picard Anne 10 10 76 F

Le prédicat de sélection permet de comparer la valeur d'attributs de R à celle d'autres attributs de R
ou à des constantes. Sa forme est la suivante 1:
 ::= <condition> | <opérateur logique> | ¬ | "("")"
<opérateur logique> ::= ∧ | ∨
<condition> ::= nom-attribut <opérateur comparaison> valeur |
nom-attribut <opérateur comparaison> nom-attribut
<opérateur comparaison> ::= = | ≠ | ≤ | < | > | ≥
Remarquons que les opérateurs de comparaison ≤ , < , > et ≥ ne peuvent être appliqués qu'aux
attributs dont les domaines contiennent des valeurs ordonnées (valeurs numériques, dates, chaînes
de caractères). Les domaines de chaînes de caractères alphabétiques sont triés alphabétiquement,
tandis que les domaines de chaînes de caractères alphanumériques sont triés selon les codes
numériques des caractères. Si le domaine d'un attribut est un ensemble de valeurs non triées, les
seuls opérateurs de comparaison utilisables sont = et ≠ .
2.3 Expressions d'algèbre
Les opérateurs de l'algèbre peuvent être combinés dans des expressions pour exprimer des requêtes
non élémentaires.
Exemple : on obtient la liste des noms et prénoms des hommes nés avant 1975 par l’expression :
H := π [nom, prénom] σ [sexe = 'M' ∧ an-nais < 75] Personne
H nom prénom
Dupont Jean
Martin Régis
Martin Jules
Le même résultat pourrait être obtenu en écrivant deux opérations l'une après l'autre en créant une
relation intermédiaire (dans ce cas il faut nommer les relations intermédiaires):
H1 := σ [sexe = "M" ∧ an-nais < 75] Personne
H := π [nom, prénom] H1
2.4 Jointure (naturelle) de deux relations ayant au moins un attribut commun.
Définition : étant donné deux relations R(X, Y) et S(Y, Z), où X, Y, Z symbolisent soit un attribut,
soit un ensemble d'attributs, et où Y n'est pas vide, la jointure (naturelle) de R et S, notée :
R*S
crée une nouvelle relation temporaire, de schéma (X, Y, Z). La population de R * S est l'ensemble
des tuples <x, y, z> créés par composition d'un tuple <x, y> de R et d'un tuple <y, z> de S, tels que
les deux tuples ont la même valeur pour Y.
On remarque que la population de R * S comporte n tuples, n ∈ [0 : card(R) x card(S)], les valeurs

extrêmes étant obtenues dans les cas suivants:
- 0 : il n'existe pas de tuple de R et S qui ont même valeur pour Y,
- card(R) x card(S) : les tuples de R et de S ont tous la même valeur, y0, pour Y.
Pour les exemples de requêtes d'algèbre, nous utiliserons par la suite la base de données
relationnelle FormaPerm (du chapitre 3).
1 ∧ représente le connecteur logique "et"

∨ représente le connecteur logique "ou"
¬ représente l'opérateur logique de négation "non"
Exemples: on désire tous les renseignements sur les étudiants (nom, adresse, date de naissance,
numéros d'étudiant et de personne)
Etudiant * Personne
Noms des étudiants ayant réussi le cours d'algorithmique:

π [nom] ( Personne * Etudiant * σ [nomC = "algo"] Obtenu )
On obtient en résultat , d'après la base de données fournie en exemple: Walter, Bernard.
2.5 Renommer un ou des attributs d'une relation
L'opérateur renommer, noté α, permet de changer le nom d'un (ou plusieurs) attribut d'une relation
R:
α [nom_attr1: nouveau_nom_pour_attr1, … ] R
Cet opérateur est utile avant les jointures s'il y a un problème d'homonymie ou de synonymie, ou
avant les opérations ensemblistes (union, différence, intersection) qui requièrent que les attributs
correspondants aient le même nom.
2.6 La thêta-jointure de deux relations n'ayant aucun attribut commun
Définition : soient deux relations R (A1, A2, …, An) et T (B1, B2, …, Bp) n'ayant pas d'attribut de
même nom, la thêta jointure de R et T selon le prédicat p, notée :
R *[p] T
crée une nouvelle relation temporaire de schéma (A1, A2, …, An, B1, B2, …, Bp), et de population
égale à l'ensemble des tuples de R et de T concaténés qui satisfont le prédicat.
Le prédicat est de la même forme que le prédicat d'une sélection, sauf pour les conditions
élémentaires qui comparent un attribut de R à un attribut de T:
<condition>::= nom-attribut-de-R <opérateur de comparaison> nom-attribut-de-T
Exemple: liste des couples de numéros d'étudiants, tels que ces deux étudiants soient nés le même
jour
*/ on crée d'abord une autre relation Etudiant avec des attributs renommés/*
Etudiant2 := α [n°E : n°E2 , dateN : dateN2] π [n°E, dateN] Etudiant
π [n°E, n°E2] (Etudiant *[n°E < n°E2 ∧ dateN = dateN2] Etudiant2 )
On obtient en résultat, d'après la base de données fournie en exemple, une relation vide.
2.7 Union, Différence, Intersection de deux relations de même schéma
Définition: soient R et S deux relations de même schéma : R (A1, A2, …, An) , S (A1, A2, …, An).
Union : R ∪ S crée une relation temporaire de même schéma et de population égale à l'ensemble
des tuples de R et de ceux de S (avec élimination des doubles éventuellement créés).
Différence : R - S crée une relation temporaire de même schéma et de population égale à

l'ensemble des tuples de R moins ceux de S, c'est à dire : les tuples qui se trouvent dans R mais pas
dans S.
Intersection : R ∩ S crée une relation temporaire de même schéma et de population égale à

l'ensemble des tuples de R qui ont un tuple de même valeur dans S.
Exemples:
liste des numéros des personnes qui sont soit enseignant de BD soit étudiant en BD:
/* on crée deux relations temporaires: */
EnsBD := α [n°Ens : n°P] π [n°Ens] σ [nomC="BD"] Cours
On obtient en résultat d'après la base de données fournie en exemple: 2222.
EtudBD := π [n°P] Etudiant * σ [nomC="BD"] Inscrit
On obtient en résultat d'après la base de données fournie en exemple: 5555.
/* Le résultat recherché est: */
EnsBD ∪ EtudBD
On obtient en résultat: 2222, 5555.
liste des numéros des personnes qui n'ont rien à voir avec le cours de BD:
π[n°P] Personne - ( EnsBD ∪ EtudBD )
On obtient en résultat: 1111, 6666, 3333.
liste des numéros des personnes qui sont enseignants et étudiants simultanément (assistants-
doctorants,…) :
( π [n°P] Enseignant ) ∩ ( π [n°P] Etudiant )
On obtient un résultat vide.
2.8 Produit cartésien de deux relations n'ayant aucun attribut commun
Définition : Soient deux relations, R (A1, A2, …, An) et T (B1, B2, …, Bp), n'ayant pas d'attribut de
même nom, alors le produit de R par T, noté R × T, crée une relation temporaire de schéma (A1,
A2, …, An, B1, B2, …, Bp) et de population toutes les concaténations possibles de tuples de R et de
T.
Remarque: La différence entre les opérateurs de théta-jointure et de produit cartésien consiste dans
le fait que dans la thêta-jointure, seules les combinaisons des tuples qui satisfont le prédicat de
jointure apparaissent dans le résultat, tandis que dans le produit toutes les combinaisons de tuples
sont présentes.
Exemple: existe-t-il des personnes dont le nom est le même que celui d'un cours? Donner leurs
noms.
π[nom] σ[nom=nomC] ( Personne × Cours ) avec un produit et une sélection
ou
π[nom] ( Personne ∗[nom=nomC] Cours ) avec une thêta-jointure
Le résultat est une relation vide.
2.9 Division
Définition : Soient deux relations R (A1, …, An) et V (A1, …, Af) (f < n) telles que tous les
attributs de V sont aussi attributs de R, alors la division de R par V, notée :
R/V
crée une nouvelle relation temporaire de schéma (Af+1, Af+2, …, An), et de population égale aux
tuples de R, tronqués à [Af+1, Af+2, …, An], et qui existent dans R concaténés à tous les tuples de V,
c'est-à-dire:
{<af+1, af+2, ..., an> / ∀ <a1, a2, ... af>∈V, ∃ <a1, a2, ... af, af+1, af+2, ..., an>∈R}
Exemples : R (A, B, C) V (B, C) R/V (A)

1 1 1 1 1 1
1 2 0 2 0 3
1 2 1
1 3 0 V' (B, C) R / V' (A)
2 1 1 1 1 1
2 3 3 2
3 1 1 3
3 2 0
3 2 1 V" (B, C) R / V" (A)
3 5 /
Exemple : liste des étudiants qui peuvent s'inscrire au cours de système (c'est-à-dire qui ont réussi
tous les prérequis de ce cours)
- cours prérequis pour système :
ReqSyst := π [nomCprérequis] σ [nomC = "système"] Prérequis
Cette relation ReqSyst contient alors deux tuples: algo, C.
- numéros des étudiants qui peuvent s'inscrire au cours de système :
( π [nomC, n°E] Obtenu ) / ( α[nomCprérequis : nomC] ReqSyst )
On obtient en résultat un tuple: 22.
3 Comment écrire une requête compliquée ?
Exemple : noms des étudiants qui suivent un des cours de l'enseignant numéro 3333.
La méthode consiste à représenter visuellement la requête sur le schéma des relations. Elle
comprend les étapes suivantes :
1. identifier les relations utiles pour exprimer la requête. Dans l'exemple, ce sont :
Personne pour le nom de l'étudiant,
Cours pour les cours de l'enseignant numéro 3333,
Inscrit et Etudiant pour faire le lien entre ces deux premières relations.
2. recopier le schéma de ces relations, et indiquer sur ces schémas :

- les attributs qui font partie du résultat de la requête. Dans l'exemple: nom de Etudiant,
- les conditions portant sur les attributs. Dans l'exemple: dans Cours, n°Ens=3333,
- les liens entre les relations. Dans l'exemple: n°P de Personne = n°P de Etudiant,
n°E dans Etudiant = n°E dans Inscrit, nomC dans Inscrit = nomC dans Cours.
On obtient donc la figure :
3. traduire cette figure en expression d'algèbre :

- faire les sélections selon les conditions portant sur les attributs,
- faire les jointures (naturelle ou thêta) selon les liens entre relations (une jointure par lien),
- projeter sur les attributs qui font partie du résultat.
On obtient ainsi l'expression :

π[nom] (Personne * Etudiant * Inscrit * (σ [n°Ens =3333] Cours)
Cette méthode est valable pour la plupart des requêtes. Cependant, certains types de requêtes
nécessitent de compliquer la méthode. C'est le cas des requêtes où la même relation est utilisée
plusieurs fois avec des ensembles de tuples différents. Par exemple : liste des noms des étudiants
qui habitent dans la même ville que l'étudiant Jean Dupont. Ici la relation Etud doit être représentée
par son schéma deux fois, une fois pour Jean Dupont, une fois pour les étudiants recherchés. Enfin,
les requêtes qui comportent l'équivalent sémantique d'un "pour tout" ou d'un "aucun" se
représentent difficilement visuellement.
4 Les opérateurs déduits

Les opérateurs déduits présentés dans ce cours sont équivalents aux expressions suivantes qui ne
comportent que les opérateurs de base et renommer :
Intersection :
R ∩ S = R - (R - S) = S - (S - R) ou
R ∩ S = (R ∪ S) - ((R - S) ∪ (S - R))
Jointure naturelle :
Soient R (X,Y) et S (Y,Z)
R * S = π [X,Y,Z] σ [Y = Y'] ( R × α[Y : Y']S )
Thêta jointure :
Soient R (X,Y) et S (U,V)
R *[p] S = σ [p] ( R × S )
Division :
Soient R (X,Y) et S (Y)
R/S = π [X] R - π [X] ( ( ( π[X]R ) × S ) - R )
5. Complexité des opérateurs
Définition: la complexité d'un algorithme c'est l'ordre de grandeur du nombre d'instructions à

exécuter. Pratiquement on compte les itérations.
5.1 Sélection : σ [condition] R

Dans le cas le pire (pas de chemin d'accès selon la condition), cela implique de balayer la relation et
tester la condition sur chaque tuple : Complexité = card (R), Taille du résultat ∈ [0 : card (R)].
La relation résultat est en général plus petite que la relation initiale.
5.2 Projection : π [Ai, Ak…] R

Cela implique de balayer la relation et ne conserver que les valeurs des attributs Ai, …, Ak si c'est
une projection toute seule. En général, dans une expression, la projection se fait en même temps
que l'opérateur qui la précède.
Exemple : π[nom] σ [adr = "Lausanne"] Personne.
Les deux opérations, sélection et projection, sont exécutées en même temps par le SGBD.
Mais la projection peut aussi nécessiter de supprimer les valeurs doubles créées, par exemple par
un tri.
Complexité : 0 (ou celle d'un tri).
Taille du résultat ∈ [1 : card (R)].
Si la liste de projection inclut un identifiant de la relation, alors le résultat aura le même nombre de
tuples que la relation initiale.
5.3 Jointure (naturelle ou thêta)

Pour calculer R * S, on prend un tuple de R et on cherche le ou les tuples de S qui correspondent à
la jointure. Ce qui nécessite deux itérations emboîtées dans le cas le pire (pas de lien de jointure
préexistant, pas d'index ...)
L'algorithme est donc :
- balayer R et pour chaque tuple de R faire :
- balayer S et comparer chaque tuple de S avec celui de R.
Complexité = card (R) x card (S).
Taille du résultat ∈ [0 : card (R) x card (S)].
On remarque que dans le cas du produit cartésien (qui peut être vu comme une théta-jointure sans
condition) la taille du résultat est exactement égale à card (R) x card (S).
On a intérêt à faire "petites" jointures (i.e., qui portent sur des relations avec peu de tuples); sinon
on peut obtenir en résultat une relation énorme! Dans les expressions optimisées d'algèbre, les
sélections seront faites le plus tôt possible. Elles porteront autant que possible sur les relations de la
base de données (et pas sur les jointures).
Exemple : cours assurés par Muller :

expression non optimisée: σ[nom = "Muller"] ( Personne *[n°P = n°Ens] Cours )
expression optimisée: ( σ[nom = "Muller"] Personne ) *[n°P = n°Ens] Cours
L'optimisation des requêtes sera traitée plus en détail dans un chapitre ultérieur.
6 Propriétés des opérateurs

Dans ce paragraphe, nous donnons les propriétés principales des opérateurs. Ces propriétés sont
utiles pour l'optimisation des requêtes. Elles définissent pour chaque expression d'algèbre les
transformations qu'on peut lui appliquer pour obtenir d'autres expressions équivalentes (qui
donnent le même résultat). Parmi ces autres expressions équivalentes, certaines sont plus
rapides à exécuter, comme par exemple celles qui font le plus tôt possible les sélections qui
réduisent le nombre de tuples du résultat.
6.1 Cascades de projections
Soient deux ensembles d'attributs tels que: {Ai1, Ai2, ....., Aij} ⊆ {Ak1, Ak2, ....., Akl} ,
alors:
π [Ai1, Ai2, ....., Aij] (π [Ak1, Ak2, ....., Akl] R) = π [Ai1, Ai2, ....., Aij] R
6.2 Cascades de sélections
σ [p1] (σ [p2] R) = σ [p2] (σ [p1] R) = σ [p1 ∧ p2] R)
6.3 Propriétés des jointures et du produit
Commutativité:
Jointure naturelle:
R*S=S*R
Thêta-jointure:
R *[p] S = S *[p] R
Produit cartésien:
R×S=S×R
Associativité:
Jointure naturelle: si les relations R et S ont au moins un attribut commun, et si les relations R et T
ont au moins un attribut commun, alors:
(R * S) * T = S * (R * T)
Thêta-jointure: si les relations R, S et T n'ont aucun attribut commun, alors:
(R *[p1] S) *[p2] T = S *[p1] (R *[p2] T)
Produit cartésien: si les relations R, S et T n'ont aucun attribut commun, alors:
(R × S) × T = S × (R × T)
6.4 Propriétés des opérateurs ensemblistes
Les opérateurs d'union et d'intersection sont commutatifs et associatifs. Ces propriétés sont
directement dérivées de la théorie des ensembles. Par contre, l'opérateur de différence n'est ni
associatif ni commutatif.

Partie 2 : LES CALCULS RELATIONNELS
1. Introduction
Avec l’algèbre relationnelle, une requête est exprimée comme une séquence d’opérations à réaliser
sur des relations de la base de données. Par contre, l'objectif des langages prédicatifs (ou langages
de type calcul), qui sont 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 bases
de données relationnelles. Il en existe deux types : le calcul de tuples et le 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 est composée de deux parties : une partie déclarative et une expression
du calcul :
- La partie déclarative associe des variables aux relations de la BD qui sont utilisées dans la
requête:
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∈R1,
y∈R2, ..., z∈Ri, t∈Rj, ..., w∈Rn,
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 des
relations correspondantes aux variables libres R1 ×R2 × ... ×Ri, produit réduit aux tuples pour
lesquels la formule fx,y,...,z,t,…,w est vraie.
Exemples : soit une base de données avec les trois relations suivantes:
Etudiant (nom, prénom, année de naissance, n°étudiant)
Inscription (n°étudiant, nom cours, note1, note2)
Enseignant (nom, prénom, statut)
Requête : nom et prénom des étudiants nés après 1982

e ∈ Etudiant
{e.nom, e.prénom / e.année de naissance > 1982}
Requête : numéro, prénom et notes des étudiants de nom Dupont inscrits au cours BD
e ∈ Etudiant, i ∈ Inscription
{e.n°étudiant, e.prénom, i.note1, i.note2 / e.nom = 'Dupont'
∧ e.n°étudiant = i.n°étudiant ∧ i.nom cours = 'BD'}

Formules valides
Les formules valides sont construites à partir des quatre règles suivantes :
1/ 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);
2/ Si f, f1 et f2 sont des formules valides, alors
(f), ¬f, f1∧f2, f1∨f2 sont aussi des formules valides 1;
3/ Si fx est une formule valide où x est une variable libre, alors 2
∃x(fx) et ∀x(fx) sont des formules valides où x est une variable liée;
4/ Rien d'autre n'est une formule valide.
Définition: 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.n°étudiant = i.n°étudiant (condition du type x.A θ y.B, e et i sont des variables libres)
i.note1 = 6 ∨ i.note2 = 6 (formule du type f1 ∨ f2, i est une variable libre)
∃i (i.note1 = 6 ∧ i.note2 = 6) (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 à 6):
e∈Etudiant, i∈Inscription;
{e.nom,e.prénom / ∃i (e.n°étudiant = i.n°étudiant ∧ i.note1 = 6 ∧ i.note2 = 6)}
Pour connaître les étudiants qui ont brillamment réussi tous leurs cours, on utilisera l'expression:
{e.nom,e.prénom / ∀i (e.n°étudiant ≠ i.n°étudiant ∨ (i.note1 = 6 ∧ i.note2 = 6)) ∧
∃i (e.n°étudiant = i.n°é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): Q1x1,Q2x2,...,Qnxn (fx1,x2,...xn)
où Qi ∈ {∀,∃} et fx1,x2,...xn est une formule valide sans quantificateur.
L'ensemble ∨,∧,¬ est redondant, dans la mesure où:
f1∧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:
f1⇒f2 ≡ ¬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 .
1 Le symbole ¬ représente la négation (NOT); le symbole ∧ la conjonction (AND); le symbole ∨ la disjonction (OR).
2 ∃x signifie "il existe un x tel que"; ∀x signifie "quelque soit x"
On peut montrer que le calcul de tuples peut exprimer tous les opérateurs de l'algèbre et vice-versa.
Ces deux langages ont la même puissance d'expression.
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] 1
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
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 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
1 Les crochets [ ] signifient que la clause est facultative.

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 ([nomatt1 =] c1, [nomatt2 =] c2, ..., [nomattn =] cn)
[WHERE formule]
où c1, c2, ... , 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.
RETRIEVE INTO Résultat ( n°=e.n°étudiant, nom=e.nom )
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
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:
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.
Exemple: pour chaque cours, nombre d'étudiants inscrits qui ont eu un 10

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:v1, B:v2,...), où A,B,... sont des attributs de la relation R, et
v1,v2,... sont soit des constantes, soit des variables. Une condition d'appartenance R(A:v1,
B:v2, ..., E:vi) est vraie ssi dans la relation R il existe au moins un tuple ayant v1 comme
valeur pour l'attribut A, v2 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) ∧
∀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 (nomvariable1 θ nomvariable2) 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

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.
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
¬ 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 :

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
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
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 emboité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'agorithme 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:
"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.

Poly 04 - Langages de Manipulation Relationnels

Transféré par

Droits d'auteur :

Formats disponibles

Poly 04 - Langages de Manipulation Relationnels

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Poly 04 - Langages de Manipulation Relationnels

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 4

L'intérêt de l'algèbre relationnelle est multiple:

Dans ce cours, nous étudierons successivement ces différents types de langages.

Bases de données avancées 2005-2006 1

Les opérateurs de l'algèbre peuvent être regroupés en deux classes:

Exemple : soit la relation

On construit l'ensemble des noms et prénoms des personnes avec l'opération:

L'opération : NA := π [nom, an-nais] Personne

soit une population de 5 tuples au lieu des 6 tuples de la relation Personne.

ce qui donne en résultat :

Bases de données avancées 2005-2006 3

2.3 Expressions d'algèbre

2.4 Jointure (naturelle) de deux relations ayant au moins un attribut commun.

On remarque que la population de R * S comporte n tuples, n ∈ [0 : card(R) x card(S)], les valeurs

1 ∧ représente le connecteur logique "et"

Noms des étudiants ayant réussi le cours d'algorithmique:

2.5 Renommer un ou des attributs d'une relation

2.6 La thêta-jointure de deux relations n'ayant aucun attribut commun

2.7 Union, Différence, Intersection de deux relations de même schéma

Différence : R - S crée une relation temporaire de même schéma et de population égale à

Intersection : R ∩ S crée une relation temporaire de même schéma et de population égale à

2.8 Produit cartésien de deux relations n'ayant aucun attribut commun

Exemples : R (A, B, C) V (B, C) R/V (A)

3 Comment écrire une requête compliquée ?

2. recopier le schéma de ces relations, et indiquer sur ces schémas :

On obtient donc la figure :

3. traduire cette figure en expression d'algèbre :

On obtient ainsi l'expression :

4 Les opérateurs déduits

5. Complexité des opérateurs

Définition: la complexité d'un algorithme c'est l'ordre de grandeur du nombre d'instructions à

5.1 Sélection : σ [condition] R

5.2 Projection : π [Ai, Ak…] R

5.3 Jointure (naturelle ou thêta)

Exemple : cours assurés par Muller :

6 Propriétés des opérateurs

6.1 Cascades de projections

6.2 Cascades de sélections

σ [p1] (σ [p2] R) = σ [p2] (σ [p1] R) = σ [p1 ∧ p2] R)

6.3 Propriétés des jointures et du produit

6.4 Propriétés des opérateurs ensemblistes

Bases de données avancées 2005-2006 10

Requête : nom et prénom des étudiants nés après 1982

Bases de données avancées 2005-2006 11

Exemples de formules valides:

Rappels sur la logique du premier ordre

3. QUEL (langage défini en 1975 pour le système INGRES)

Une requête d'interrogation s'écrit en QUEL comme suit :

RANGE OF nomvariable,... IS nomrelation

En calcul de tuples, cela s'écrit :

En QUEL, cela s'écrit :

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

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

3.2 Mise à jour

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

RETRIEVE r.nom /* on obtient le résultat désiré */

3.3 Autres possibilités

QUEL offre également une commande de tri :

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

Pour chaque cours, nombre d'étudiants inscrits