Chapitre IV Les Langages QUEL, QBE et SQL

Dans ce chapitre, nous abordons les divers langages relationnels autres que le langage algébrique. Nous
présenterons les langages prédicatifs à variable tuple avec QUEL comme représentatif. Puis nous présenterons les
langages prédictifs à variable domaine illustrés par QBE. et enfin, le langage SQL, considéré comme une
implémentation particulière du langage algébrique.

1 - Les langages prédicatifs

Ils sont basés sur le calcul des prédicats du 1er ordre (CP1). Soit L= (A, W) où A est un alphabet de symboles et
W un ensemble de formules bien formées construites en utilisant ces symbole.
A comporte: un ensemble de constantes, un ensemble de variables, un ensemble de prédicats avec arité, un
ensemble de fonctions avec arité, les connecteurs logiques : Þ, Ù, Ú, Ø, des symboles de ponctuation : ',' '(' ')' et
les quantificateurs " , $
Toute formule de W est construite à l'aide de A, de termes et de formules atomiques.
- Un Terme est défini récursivement:
(i) un symbole de constante est un terme
(ii) un symbole de variable est un terme
(iii) si f est un symbole de fonction d'arité n et que t1, t2, ....., tn sont des termes alors f(t1, t2, ....tn) est un
terme.
- Formule atomique:
Si P est un symbole de prédicat n-aire et que t1, t2, ......., tn sont des termes alors p(t1, t2, ........., tn) est
une formule atomique
- Une Formule bien formée se définit récursivement comme suit:
(i) une formule atomique est une formule bien formée
(ii) si F est une formule bien formée alors non F est une formule bien formée
(iii) si F1 et F2 sont des formules bien formées alors
F1 Ù F2 est une formule bien formée
F1 Ú F2 est une formule bien formée
F1 Þ F2 est une formule bien formée
(iv) si F est une formule bien formée, alors (F) est une formule bien formée
(v) si F est une formule bien formée alors "x F et $x F sont des formules bien formées
Remarque : On peut restreindre les connecteurs logiques à , Ù, Ú, Ø, sachant que (AÞB) Û (ØA Ú B)

2 - Le calcul relationnel de tuples

Il se déduit du CP1 en considérant les formules bien formées:
(i) que les variables sont associées à des tuples
(ii) que les prédicats sont ceux définissant les comparateurs logiques (ie =, <>, <, >, <=, >=). On associera, en
outre, un prédicat unaire à chaque relation et on confondra nom de relation et symbole de prédicat (par exemple,
produit(p) signifiera que p est un produit).
(iii) que les termes sont les constantes associées aux valeurs des domaines des attributs ou des fonctions de
projection d'une variable de relation sur un de ses attributs (exemple: p.libellé).

1
Syntaxe de calcul de n-uplets
<rqte> ::= '{' <projection> ‘|’ <formule> '}'
<projection> ::= <symbole-variable> '.' <symbole d'attribut> |
<symbole-variable> '.' <symbole d'attribut> ',' <projection>
<formule> ::= <nom-relation> '(' <symbole-variable> ')' | 'Ø' <formule> | <formule> Ù <formule> |
<formule> Ú <formule> | <'"' <symbole-variable> <formule> | <'$' <symbole-variable> <formule> |
<expr-gauche> Q <expr-droite>
<expr-gauche> : : <symbole-variable> . <symbole d'attribut>
<expr-droite> : : <expr-gauche> | constante
Q ::= '<' | '>' | '=' | '<=' | '>= ' | '<>'
Exemples
Dans les exemples qui suivent, les requêtes seront exprimées sur la base dont le schéma comporte:
Produit (#prod, libellé, pu)
Dépôt (#dep, adr, volume)
Stock (#prod, #dep, qte)
on confondra nom de relation et prédicat ie produit(p) signifiera que p est un produit.

1- Libellé et prix unitaire de tous les produits (projection)

{ p.libellé, p.pu | produit(p)}
2- Nom et pu des produits stockés dans le dépôt 4 (Sélection, Jointure et Projection)
{ p.libellé, p.pu | produit (p) Ù stock(s) Ù s.#dep = 4 Ù s.#prod = p.#prod}
3- Adresses et numéros des dépôts ayant au moins un produit en rupture de stock (idem que 2)
{ d.adr, d.#dep | dépôt(d) Ù $s (stock(s) Ù d.#dep = s.#dep Ù s.qte <= 0}
4- Adresses et numéros des dépôts stockant tous les produits (Division)
{ d.adr, d.#dep | dépôt(d) Ù "p produit (p) Þ $s (stock(s) Ù p.#prod = s.#prod Ù d.#dep= s.#dep }

3 - Le langage QUEL
QUEL est dérivé du calcul relationnel des tuples, c'est le langage de manipulation du système INGRES, un des
premiers SGBD relationnels commercialisé sur PDP11 et VAX.
Le système a une architecture en "pipe" ie 4 processeurs distincts communiquent entre eux par des pipes (Canaux
de communication).
P1 : Interface utilisateur + gestion de l'espace de travail de l'utilisateur, acceptation des requêtes
P2 : Analyseur de requêtes
P3 : Traitement des requêtes. S'il s'agit d'une requête d'interrogation, les résultats sont extraits de la base et rendus
à l'utilisateur. S'il s'agit d'une requête de modification, il y a constitution d'un fichier contenant les nouvelles
valeurs des tuples à modifier en vue d'une mise à jour différée. Il est à noter que le système Ingres incorpore un
optimiseur de requêtes basé sur la décomposition d'une requête en sous-requêtes ne comportant qu'une seule
variable (One Variable Query Processor).
P4 : Processus assurant les mises à jour différées. P4 est le seul processus modifiant la base. Il gère également les
reprises en cas de panne.

2
 User P1 P2 P3 P4

Base de
données

La déclaration de variables (QUEL dissocie la déclaration de variables de l'expression de la requête)

RANGE OF {variable}* IS {nom-de-relation}*
Exemple
RANGE OF p IS produit RANGE OF p, s, d IS produit, stock, dépôt
La recherche d'informations
RETRIEVE [INTO nom de relation résultat] liste d'attributs [WHERE qualification]
Exemples
1- Libellé et pu de tous les produits RANGE OF p IS produit
RETRIEVE p.libellé p.pu
2- Nom et pu des produits stockés dans le dépôt 4 RANGE OF p, s IS produit, stock
RETRIEVE p.libellé, p.pu
WHERE ((s.#dep = 4) AND (s.#prod = p.#prod))
La modification d'informations
APPEND : ajout de tuple
REPLACE : modification
DELETE : suppression
La manipulation des schémas de relations
CREATEDB : définition d'un schéma de base de données
CREATE : ajout de relation
DESTROY : suppression de relation
DESTROYDB : suppression de schéma de base de données

4 - Le calcul relationnel de domaines

Il est basé sur le CP1. Cependant, les variables sont associées aux domaines des attributs. De ce fait, on associe à
chaque relation n-aire un prédicat de même arité et, comme précédemment, nous confondrons nom de relation et
symbole de prédicat. Par ailleurs, par commodité d'écriture, nous utiliserons le symbole '-' à la place des arguments
des prédicats non concernés par la requête.
Syntaxe du calcul relationnel de domaines
<requête> ::= '{' <projection> ‘|’ <formule> '}'
<projection> ::= <symbole-de-variable> | <projection> ',' <symbole-de-variable>
<formule> ::= <nom-relation> '(' domaines ')' | 'Ø' <formule> | <formule> Ú <formule> | <formule> Ù
<formule> |
'"' <symbole-variable> <formule> | '$' <symbole-variable> <formule> | <symbole-de-variable> Q
<oper-droit>
<domaines> ::= <symbole-de-variable-ou-constante>| <domaines> ',' <symbole-de-variable-ou-constante>
<symbole-de-variable-ou-constante> ::= <symbole-de-variable> | <symbole-de-constante>
3
<oper-droit> ::= <symbole-de-variable-ou-constante>
<symbole-de-variable> ::= identificateur | '-' Q ::= '<' | '>' | '<=' | '>=' | '<>' | '= '
Exemples
1- Libellé et pu de tous les produits
{ x, y | produit (-, x, y)}
2- Nom et pu des produits stockés dans le dépôt 4
{ x, y | produit ( z, x, y) Ù stock ( 4, z, - ) }
3- Adresses et numéros des dépôts ayant au moins un produit en rupture de stock
{ x, y | dépôt ( x, y, - ) Ù $z (stock ( x, -, z) Ù z <= 0 }
Pour une meilleure lisibilité des formules, nous nous permettons de ne pas nous conformer à l'arité des prédicats
associés aux relations en désignant explicitement les seuls attributs effectivement utilisés dans la formule. Ces
attributs seront associés à des variables, des constantes ou des expressions de constantes. Pour cela, nous
changeons la règle concernant les domaines.
<domaines> : : <symbole-attribut> ':' <var-ou-const> | <domaines> ',' <symbole-attribut> ':' <var-ou-const>
symbole-attribut Î { symboles des attributs de la relation <nom-relation>}
Exemples
1- Libellé et pu de tous les produits
{ x, y | produit(libellé: x, pu: y )}
2- Nom et pu des produits stockés dans le dépôt 4
{ x, y | produit (#prod: z, libellé: x, pu: y) Ù stock (#dep : 4, #prod : z ) }
3- Adresses et numéros des dépôts ayant au moins un produit en rupture de stock
{ x, y | dépôt (#dep: x, adr: y) Ù z (stock (#dep: x, qte: z) Ù z <= 0)}

5 - Le langage QBE
QBE (Query By Example) peut être vu comme une implantation du calcul relationnel des domaines. Il est basé sur
une visualisation graphique des relations visant à aider l'utilisateur dans la formulation des requêtes. Celles-ci sont
exprimées par le biais de commandes de visualisation de schémas de relations. Les tableaux servent alors de cadre
au contenu des relations (squelette de relation). Cette approche a été adoptée par quelques SGBD commerciaux.
Ainsi, l'outil VQL (Visual Query Language) du système Sybase et SQL*Forms du système Oracle offrent des
capacités similaires.

Aspect graphique des relations

Nom de relation nom d'attribut 1 ... nom d'attribut N
commande valeur valeur

Exemples
1- Libellé et pu de tous les produits
Produit #Produit Libellé Pu
P. P.
P. désigne Print

4
2- Nom et pu des produits stockés dans le dépôt 4
Produit #prod Libellé Pu Stock #Dep #Prod Qte
-p P. P. 4 -p
3- Adresses et numéros des dépôts ayant au moins un produit en rupture de stock
Dépôt #Dep Adr Cap Stock #Dep #Prod Qte
P. -d P. -d -x <= 0

6 - Le Langage SQL
Square (proposé par Boyce en 1975) --> SEQUEL (Chamberlin 1976) --> SQL (Structured Query Language).

A - Interrogation en SQL
A.1- Projection SELECT Liste de Projection
FROM Nom de relation
La liste de projection est soit une liste de noms d'attributs soit le caractère '*' qui signifie tous les attributs de la
relation. Les attributs peuvent être désignés par une notation pointée de le forme <Nom relation . nom attributs> où
la désignation de la relation est soit un nom de relation soit un alias de nom de relation (voir plus loin).
Exemple Numéro et pu de tous les produits SELECT #prod, pu
FROM Produit
Notons que le résultat n'est pas une relation dans le sens où il peut exister des tuples identiques. Pour éliminer les
doubles il faut le spécifier par la clause DISTINCT. SELECT DISTINCT #prod, pu
FROM Produit

A.2- Sélection SELECT *

FROM Nom de relation
WHERE Qualification
La qualification est une expression conditionnelle pouvant comporter les opérateurs de comparaison =, !=, >, >,
>=, <= pour constituer des expressions atomiques. Ces dernière peuvent être reliées par les connecteurs And, Or, et
Not (Voir plus loin).
Exemple Sélectionner les produits dont le prix unitaire est <= à 250 SELECT *
FROM Produit
WHERE Pu<= 250
A.3- Composition de la sélection et de la projection SELECT Liste de projection
FROM Nom de relation
WHERE Qualification
Exemple Sélectionner le numéro et le libellé des produits SELECT #prod, Libellé
dont le prix est compris entre 250 et 750 FROM Produit
WHERE Pu>= 250 AND Pu
<=750
A.4- Produit cartésien (C'est une jointure sans qualification)
SELECT *
FROM Nom de relation1, Nom de relation2 [, ...]

5
A.5- Jointure SELECT *
FROM Nom de relation1, Nom de relation2 [, ...]
WHERE Qualification de jointure
Exemple (Equi-jointure) SELECT *
FROM Produit, Stock
WHERE Produit.#prod = stock.#prod
A.6- Imbrication de SELECT (utilisation de l'opérateur ensembliste d'inclusion : IN)
Exemple Tous les produits de la relation Stock SELECT *
présents dans la relation Produit FROM Stock
WHERE #prod IN ( SELECT #Prod
FROM Produit )
A.7- Composition Jointure, Sélection et Projection
Exemples a- #Prod et Libellé de tous les produits SELECT Libellé, #Prod
en rupture de Stock FROM Produit
WHERE #prod IN ( SELECT #Prod
FROM Produit
WHERE Qté <= 0 )
Ceci peut s'exprimer de façon plus simple : SELECT produit.#Prod, Produit.Libellé
FROM Produit, Stock
WHERE (Produit.#Prod = Stock.#Prod) AND (Stock.Qté <= 0 )
b- Trouver les produits en rupture de stock et l'adresse des dépôts en rupture de stock pour ces même produits
SELECT p.#Prod, p.libellé, d.#Dep, d.Adr
FROM Produit p, Dépôt d
WHERE d.#prod IN ( SELECT #Prod
FROM Stock
WHERE (Qté <= 0) AND (Stock.#Dep = d. #dep) )
Ou plus simplement
SELECT p.#Prod, p.libellé, d.#Dep, d.Adr
WHERE Qté <= 0 )FROM Produit p, Stock s, Dépôt d
WHERE p.#Prod = s.#Prod AND d.#Dep = S.#Dep AND s.Qté <=0

A.7- Expression de l'union, de l'intersection et de la différence

Elle s'exprime par : <Clause Select> <Opération><Clause Select>
<Opération> ::= 'UNION' | 'INTERSECT' | 'MINUS'
Exemple Sélectionner le numéro des produits SELECT #prod, Libellé
dont le prix est compris entre 250 et 750 FROM Produit
WHERE Pu <=750
INTERSECT
SELECT #prod, Libellé
FROM Produit
WHERE Pu>=250
B- La mise à jour dans SQL (UPDATE, INSERT, DELETE)
6
B.1- INSERT INTO Nom de relation VALUES (<tuple>) Exemple INSERT INTO Stock VALUES (5, 1244,
560)
B.2- UPDATE Nom de relation
SET Attribut1=Nouvelle Valeur1, Attribut2=Nouvelle Valeur2 [, ...] WHERE Qualification
Exemple Mettre à zéro la quantité du produit 1244 dans tous les dépôts
UPDATE Stock SET Qté = 0 WHERE #Prod = 1244
B.3- DELETE Stock WHERE 4 IN (SELECT #Dep FROM Stock)
C- Ordonnancement des résultats
ORDER BY <Nom attribut> [<Ordre>][,<Nom attribut>[Ordre] ...] <Order> ::= ASC | DESC
Exemple SELECT #Dep, #Prod, Qte FROM Stock WHERE Qte > 0 ORDER BY #Prod ASC, Qte DESC

D- Les fonctions d'agrégation

Les fonctions agrégats peuvent être utilisées dans la clause SELECT, si elle ne rend pas des résultats individuels
i.e. un ensemble de valeurs en plus de la valeur rendues par la fonction agrégat. Par contre en peut utiliser une
fonction agrégat dans une sous-requête (SELECT imbriqué) puis sélectionner des résultats individuels dans la
requête englobante (l'inverse est également possible). Hormis COUNT(*), toutes les fonctions ignorent les valeurs
nulles. Par ailleurs, ALL est toujours l'option par défaut.
- Cardinalité : COUNT (<Expression>|*) | COUNT([DISTINCT | ALL] <Expression>)
- Somme : SUM([DISTINCT | ALL] <Expression>)
- Moyenne : AVG([DISTINCT | ALL] <Expression>)
- Maximum : MAX([DISTINCT | ALL] <Expression>)
- Minimum : MIN([DISTINCT | ALL] <Expression>)
- Variance : VARIANCE([DISTINCT | ALL] <Expression>)
Exemples
- Quels sont les produit ayant le prix unitaire le plus élevé : SELECT #Prod, MAX(Pu) FROM Produit
Cette requête est incorrecte, car il; peut exister un ensemble de #Prod alors qu'il n'y a qu'un seul prix maximum.
La requête correcte est la suivante :
SELECT #Prod, Pu FROM Produit WHERE Pu IN ( SELECT MAX(Pu) FROM
Produit )
- Nombre des produits en rupture de stock : SELECT COUNT(*) FROM Stock WHERE Qte <=0
- Moyenne des prix des produit stockés dans le dépôt numéro 4 :
SELECT AVG(Pu) FROM Dépôt, Stock, Produit
WHERE Dépôt.#Dep = Stock.#Dep AND Stock.#Prod = Produit.#Prod AND Dépôt.#Dep = 4
- Trouver le dépôt ayant la plus grande capacité de stockage :
SELECT #Dep, Adr FROM Dépôt WHERE Volume IN (SELECT MAX (Volume) FROM Dépôt)

E- Groupement des résultats

Il se fait par la clause GROUP BY. Il consiste a partitionner la relation résultat en groupes de tuples tels que
chaque tuple d'un groupe ait la même valeur pour le ou les attributs sur lesquels est effectué le groupement.

GROUP BY <Liste attributs> [ HAVING <Condition> ]

Exemple

7
Somme des quantités en stock de chaque produit :
SELECT #Prod, SUM(Qte) FROM Stock GROUP BY #Prod
La relation est partitionnée en sous-relations (ou groupes) où chaque élément d'un groupe a le même #Prod puis la
somme est effectuée sur les quantités de chaque groupe. Si la requête comporte une clause WHERE, celle-ci est
évaluée AVANT le groupement. En outre, si le résultat de la requête doit être ordonné, la clause ORDER BY doit
apparaître après le GROUP BY.
Exemple
Somme des quantités en stock de chaque produit en excluant le dépôt 4 et en triant sur #Prod :
SELECT #Prod, SUM(Qte) FROM Stock WHERE #Dep != 4 GROUP BY #Prod ORDER BY #Prod
La clause Having permet de restreindre les groupes aux seuls groupes qui vérifient la condition qui suit HAVING.
En d'autres termes, Having est pour les groupes ce que WHERE est pour les tuples. L'expression suivant Having
doit être monovaluée.
Exemple
Trouver les produit stockés dans plus de deux dépôts :
SELECT #Prod FROM Stock GROUP BY #Prod HAVING COUNT (*) >2
Trouver les dépôts ayant plus de trois produits en rupture de stock :
SELECT #Prod, Adr FROM Dépôt d
WHERE d.#Dep IN ( SELECT s.#Dep FROM Stock s
WHERE Qte <= 0 GROUP BY #Dep HAVING COUNT(*) > 3 )

F- Le quantificateur existentiel Exists & Not exists

Exemple 1 Trouver les adresses des dépôts où est stocké le produit numéro 35
Première solution : SELECT d.#Dep, d.Adr FROM Dépôt d, Stock s WHERE s.#Prod = 35 AND s.#Dep =
d.#Dep
Deuxième solution : SELECT d.#Dep, d.Adr FROM Dépôt d
WHERE d.#Dep IN ( SELECT s.#Dep FROM Stock s WHERE s.#Prod = 35)
Troisième solution : Elle est tirée de l'expression prédicative de la requête
Res = { d.#Dep, d.Adr | Dépôt(d) Ù $s( Stock(s) Ù s.#Prod = 35 Ù s.#Dep = d.#Dep) }
Traduction en SQL SELECT d.#Dep, d.Adr FROM Dépôt d
WHERE EXISTS ( SELECT * FROM Stock s WHERE s.#Prod = 35 AND s.#Dep = d.#Dep)

Exemple 2 Quels sont les dépôts où n'est pas stocké le produit 35

Première solution : Res = {dépôts} - {Dépôts où est stocké le produit 35}
SELECT d.#Dep, d.Adr FROM Dépôt d
MINUS SELECT d1.#Dep, d1.Adr FROM Dépôt d1
WHERE d1.#Dep IN ( SELECT s.#Dep FROM Stock s WHERE s.#Prod = 35)
Deuxième solution : Res = { d.#Dep, d.Adr | Dépôt(d) Ù Ø$s( Stock(s) Ù s.#Prod = 35 Ù s.#Dep = d.#Dep) }
Traduction en SQL :
SELECT d.#Dep, d.Adr FROM Dépôt d
WHERE NOT EXISTS ( SELECT * FROM Stock s WHERE s.#Prod = 35 AND s.#Dep = d.#Dep)

G- Le quantificateur universel
8
Il est possible d'exprimer des requêtes comportant des quantificateurs universels en utilisant le quantificateur
existentiel, en se basant sur les théorèmes suivants :
1 - "xp(x) Û Ø($x Øp(x)) 2 - "x$y p(x,y) Û Ø$x(Ø$y p(x,y)) 3 - p Þ q Û Øp Ú q
On déduit le théorème suivant :
"x(p Þ q) Û Ø$xØ(p Þ q) càd "x(p Þ q) Û Ø$xØ(Øp Ú q) ou encore "x(p Þ q) Û Ø$x(p Ù Øq)

Exemple Numéro et Adresses des dépôts où il y a tous les produits connus

Res = { d.#Dep, d.Adr | Dépôt(d) "p Produit(p) ($s Stock(s) Ù s.#Prod = p.#Prod Ù s.#Dep = d.#Dep)}
En utilisant les théorèmes précédents, on élimine le quantificateur universel.
Res = { d.#Dep, d.Adr | Dépôt(d) Ø($p Produit(p)Ø($s Stock(s) Ù s.#Prod = p.#Prod Ù s.#Dep = d.#Dep))}
La traduction en SQL est directe :
SELECT d.#Dep, d.Adr FROM Dépôt d
WHERE NOT EXISTS ( SELECT * FROM Produit p
WHERE NOT EXISTS ( SELECT * FROM Stock s
WHERE s.#Prod = p.#Prod AND s.#Dep=d.#Dep))

H- Manipulation des Vues

Une vue est une relation dont la valeur est calculée à chaque invocation. Elle est définie par une requête qui utilise
des relations ou des vues existantes (la requête ne comporte pas de clause ORDER BY).
Syntaxe : CREATE VIEW <Nom Vue> AS <Requête>
Exemple
Une vue comportant les produit chers : CREATE VIEW Produit-Chers AS SELECT * FROM Produit
WHERE Pu > 3000
Une vue ne comportant que les #Prod et Libellé (renommés en Numéro et Nom) des produit chers :
CREATE VIEW Produit-Chers (Numéro, Nom) AS SELECT #Prod, Libellé FROM Produit
WHERE Pu > 3000
En interrogation, une vue est utilisée comme toute autre relation. La seule différence réside dans la non persistance
des tuples de la vue. La requête étant évaluée à chaque besoin.
En mise à jour, toute modification des relations ayant servi à la définition de la vue sont répercutées sur la vue. Par
contre, la mise à jour d'une base de données à travers une vue n'a pas de solution générale, chaque système autorise
certaines opérations et interdit d'autres. La destruction de la vue se fait par : DROP VIEW <Nom Vue>.

I- Manipulation des schémas de relations

La commande CREATE TABLE permet de définir un schéma de relation. L'instanciation de relation peut se faire
de diverses façons.
1- Insertion de tuple par la commande INSERT.
2- Chargement en bloc à l'aide d'un utilitaire d'instanciation accompagnant le SGBD.
3- Chargement dynamique par le résultat d'une requête.

Syntaxe : CREATE TABLE [<Nom Utilisateur>.]<Nom de Relation>

9
 (<Définition Attribut>[<Contrainte>] [ ,<Définition Attribut>[<Contrainte>] ] )
AS <Requête>
<Définition Attribut> ::= <Nom Attribut><Type>[DEFAULT<Expression>]
<Contrainte> ::= UNIQUE | NOT NULL| etc
La commande CREATE TABLE permet de façon optionnelle de spécifier l'espace de rangement des tuples de la
relation ainsi que les Clusters associés (Voir plus loin).La valeur de l'expression qui suit DEFAULT est assignée à
l'attribut si celui-ci n'a pas de valeur associée lors d'une insertion de tuple. La contrainte permet de spécifier les
contraintes d'intégrité associées à l'attribut.

Exemple
CREATE TABLE Personne ( Numéro VARCHAR(13) UNIQUE NOT NULL,
Nom VARCHAR(20) NOT NULL,
Depart NUMBER NOT NULL,
ADR VARCHAR(30),
DateNaissance DATE,
Salaire NUMBER(6,2) DEFAULT 0,0 )
CREATE TABLE Departement ( NuméroDepart NUMBER NOT NULL,
Nom VARCHAR(20) NOT NULL,
Responsable VARCHAR(13) UNIQUE,
FOREIGN KEY Responsable REFERENCES Personne,
PRIMARY KEY (NuméroDepart) )
La suppression d'une relation (schéma et instances) se fait par
DROP TABLE [<Nom Utilisateur>.]<Nom de Relation>
La commande ALTER TABLE permet de modifier le schéma d'une relation en y ajoutant des attributs, des
contraintes, en modifiant la définition d'un attribut, en supprimant des contraintes, ... . La variété des modifications
dépend du système utilisé.
Syntaxe ALTER TABLE [<Nom Utilisateur>.]<Nom de Relation>
[ADD (<Définition Attribut>[<Contrainte>] [ ,<Définition Attribut>[<Contrainte>] ] )]
[MODIFY (<Définition Attribut> [ ,<Définition Attribut>] ) ]
[DROP CONSTRAINT <Contrainte>]

J- Création d'un base de données

La commande CREATE DATABASE permet de créer une base de données de spécifier son nom, son
emplacement, les espaces associés (données, journal, ...), leurs tailles etc. Cependant cette opération peut ne pas
être obligatoire, auquel cas la base ne comportera pas de nom et ses relations seront rangées dans un espace
commun du SGBD. Les paramètres spécifiés d'une base de données peuvent être modifiés par ALTER
DATABASE et sa destruction peut être faite par DROP DATABASE.

K- Renommage des objets dans les requêtes

10
Un alias de relation est un identificateur qui pourra être utilisé dans la désignation des attributs.
[<Nom-Utilisateur>.]<Nom de relation ou de vue>[<Alias de relation>]
Exemple SELECT * FROM Produit p, OUAHID.Dépôt d WHERE p.#Prod = d.#Prod
Un alias d'attribut sert à renommer une colonne de la relation résultat. Il ne peut être utilisé dans la clause WHERE
de la requête.
Syntaxe <Nom Attribut> [Alias Attribut] Ou
[<désignation de relation ou alias de relation>.]<Nom Attribut> [Alias Attribut]

L- Les expressions et les opérateurs

Une expression est une combinaison de valeurs, d'opérateurs et de fonctions rendant une valeur comme résultat.
Les expressions peuvent apparaître partout où une valeur est utilisable : Dans la liste de projection d'un SELECT,
dans les conditions des clauses WHERE et HAVING, dans les clauses ORDER BY, CONNECT BY et START
WITH, dans la clause VALUES de l'instruction INSERT et dans la clause SET de l'instruction UPDATE.
Il existe six groupe d'opérateurs qui s'utilisent comme suit : <Opérande> <Opérateur> <Opérande>
1- Opérateurs unaires : +,-
2- Opérateurs arithmétiques binaires : +, -, *, / Exemple SELECT 2*X+1 ... WHERE Y < -Z+W
3- Opérateur des chaînes de caractères : || (Concaténation)
Exemple SELECT 'Son Nom est' || nom FROM Personne
4- Opérateurs de comparaison : =, !=, <,>,<=,>=, ANY, ALL, [NOT] EXISTS, , [NOT] LIKE, IS [NOT] NULL,
[NOT] BETWEEN <Valeur1>AND <Valeur2>, [NOT] IN (<Liste Valeurs> | Requête), [NOT] LIKE <Modèle>

Exemples SELECT ... FROM ... WHERE nom LIKE 'B%A' (% signifie tout chaîne de caractères non
nulle, - signifie n'importe quel caractère).
Trouver les personnes dont le salaire est égale au salaire de n'importe quelle personne du département 4
SELECT * FROM Personne WHERE Salaire = ANY
(SELECT Salaire FROM Personne WHERE Depart = 4)
SELECT ... FROM ... WHERE (Salaire,ancienneté) >= ALL ( (1000,5), (12000,6) )
5- Les opérateurs logiques : NOT, AND, OR
Compte tenu de la notion de valeur inconnue (NULL), les tables de vérités traditionnelles sont étendues comme
suit :

A B A OR B A AND B
VRAI VRAI VRAI VRAI
VRAI FAUX VRAI FAUX
VRAI NULL VRAI NULL
FAUX FAUX FAUX FAUX
FAUX NULL NULL FAUX
NULL NULL NULL NULL

6- Les opérateurs ensemblistes : UNION, INTERSECT, MINUS, [NOT] IN

11