Le Langage SQL version Oracle

Mayssa TRABELSI
mayssa-trabelsi@outlook.com
 Chapitre 1 Introduction
Le langage SQL (Structered Query Language) est le langage standard de gestion des bases de
données relationnelles. Il permet de définir, manipuler et contrôler les données. Ainsi SQL est
constitué de trois sous langages :
1. LDD (Langage de Définition de Données) incluant les requêtes CREATE, ALTER,
DROP, RENAME, TRUNCATE. Le LDD permet de créer, de changer et d'éliminer une
structure de données Oracle.

2. LMD (langage de manipulation de données) incluant les requêtes SELECT, INSERT,

UPDATE, DELETE, MERGE. Le LMD permet de sélectionner, d'insérer, de modifier et
de supprimer des lignes à partir d'une table.

3. LCD (langage de contrôle de données) incluant les requêtes GRANT, REVOKE. Le LCD
permet de donner ou de priver les droits d'accès à une base de données Oracle ou à ces
structures.
SQL a été implémenté par IBM dans les années 70, et se base sur l'algèbre relationnelle de
Codd. Chaque SGBDR (DB2, Informix, Ingres, SQL SERVER...) présente sa propre version de
SQL. ORACLE possède sa propre version. Ceci dit, toutes les versions sont fondées sur le même
noyau.

1.1 Les tables

La table est l'objet principal d'une base de données car c'est là ou on stocke les données.
Oracle identifie une table par son nom. Elle peut avoir une ou plusieurs colonnes (champ,
attribut, mesure etc.). Une colonne est caractérisée par son nom et son type de données. La table
peut avoir zéro ou plusieurs lignes (enregistrements, objets, tuples etc.).

1.2 Les types de données

Oracle offre les types de données suivants :

 CHAR(n) : Chaîne de caractère fixe de longueur maximale n.

 VARCHAR2(n) : Chaîne de caractère variable de longueur maximale n.

 NUMBER(n,d) : Réel avec n le nombre de chiffres du réel, d le nombre de

décimaux. Exemple : NUMBER(5,2) inclut tous les nombres de -999.99 → 999.99

 DATE : Le type de données incluant la date et l'heure. Le format par défaut est le
suivant : DD-MON-YY, par exemple : `04-0CT-04'.
 Chapitre 1 : Introduction 6

 LONG : Chaîne de caractère variable de taille maximale 2 Go.

 CLOB : Chaîne de caractère variable de taille maximale 4 Go.

 RAW(n) : Données binaires de longueur n.

 LONG RAW : Données binaires de longueur variable allant jusqu'à 2 Go.

 BLOB : Données binaires de longueur variable allant jusqu'à 4 Go.

 BFILE : Données binaires stockées dans un fichier externe allant jusqu'à 4 Go.

 ROWID : Chaîne hexadécimale représentant l'adresse unique d'une ligne dans une
table. C'est un type de données qu'on peut utiliser pour stocker les valeurs retournées
par le pseudo colonne ROWID.

 TIMESTAMP[(n)][WITH TIME ZONE] : Stocke la date et l'heure. L'heure est

stockée avec n fractions de secondes, n peut varier de 0 à 9, 6 est la valeur par défaut.
Exemple : '04-OCT-04 12.45.32.1654 AM', ici n=4. Si le mot clé WITH
TIME ZONE est spécifié alors l'heure est affichée avec la différence entre l'heure de la
zone locale et celle de Greenwich.

 INTERVAL YEAR[(y)] TO MONTH : Stocke une période de temps sous forme

d'années et de mois.

 INTERVAL DAY TO SECOND : Stocke une période de temps sous forme de jours
et de secondes.
Remarque
- Une colonne de type LONG ne peut pas être copiée lors de la création d'une table à l'aide
d'une requête SELECT.
- Une colonne de type LONG ne peut pas être incluse dans une clause GROUP BY ou
HAVING.
- Une table ne peut contenir qu'une seule colonne de type LONG.
- Une colonne de type LONG ne peut pas avoir de contrainte.
- Le type de données CLOB inclut LONG.
- Il n'y a pas de type de données booléen, ce dernier peut être simulé par NUMBER(1) ou
CHAR(1).
- Une colonne non renseignée porte la valeur NULL qui est différente de 0 pour les nombres
et de la chaîne vide pour les chaînes de caractères.
 Chapitre 2 La sélection simple
2.1 La sélection simple
La requête SELECT nous permet d'extraire des données à partir d'une base de données. La
clause SELECT est suivie d'une ou de plusieurs colonnes, ce sont les colonnes qu'on veut
extraire. La clause FROM est suivie par le nom de la table à partir de laquelle on veut afficher les
données.

Tous les exemples qui suivent se basent sur les tables EMP, DEPT et SALGRADE.
La requête R1 affiche toutes les colonnes de la table EMP :
REQ 1 :
SELECT * FROM EMP ;
Le symbole ‘*’ remplace toutes les colonnes de la table EMP.
REQ 2 :
SELECT EMPNO, ENAME, SAL FROM EMP ;
Cette opération est dite opération de projection sur EMP sur les colonnes EMPNO, ENAME et
SAL.
EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO
………..

………..

………..

………..

………..

………..

………..

………..

Figure 1 : Projection sur EMPNO, ENAME et SAL

2.1.1 La clause SELECT

En réalité la clause SELECT peut inclure des expressions autres que les colonnes. Elle peut
être suivie par :

 Des expressions arithmétiques.

 Des alias de colonnes.
 Des colonnes concaténées.
 Des littéraux (constantes).
REQ 3 :
Donner les noms et les salaires annuels de tous les employés ?
SELECT ENAME, SAL*12 FROM EMP ;
 Chapitre 2 : La sélection simple 8

Voici ce que nous affiche cette requête :

ENAME SAL*12
SMITH 9600
ALLEN 19200
WARD 15000
JONES 35700
MARTIN 15000
BLAKE 34200
CLARK 29400
SCOTT 36000
KING 60000
TURNER 18000
ADAMS 13200
JAMES 11400
FORD 36000
MILLER 15600
14 ligne(s) sélectionné(es).
REQ 4 :
L’entête de la 2ème colonne est sal*12, on peut modifier l’entête en lui affectant un alias :
SELECT ENAME, SAL*12 ANNSAL FROM EMP ;
L’alias et la colonne (ou l’expression) sont séparés d’un espace.

ENAME ANNSAL
SMITH 9600
ALLEN 19200
…

REQ 5 :
Afficher les codes et les noms concaténés de tous employés ?
SELECT EMPNO||ENAME EMPLOYEE FROM EMP ;

EMPLOYEE
7369SMITH
7499ALLEN
……….

REQ 6
SELECT EMPNO||„ „||ENAME EMPLOYEE, „works in‟, DEPTNO
FROM EMP ;

EMPLOYEE „works in‟ DEPTNO

7369 SMITH works in 20
7499 ALLEN works in 30
……..

………

………
 Chapitre 2 : La sélection simple 9

Nous avons introduit le littéral „ „ (espace) concaténé à EMPNO et ENAME, ainsi que le
littéral ‘works in’. Ces deux littéraux s’affichent pour chaque ligne.

2.1.2 Le traitement des valeurs NULL

Si une ligne donnée n’a pas de valeur pour une colonne donnée, alors cette case porte la valeur
NULL. Toute colonne, quelque soit son type de données, peut avoir la valeur NULL. Ceci dit,
certaines contraintes appliquées sur une colonne (PRIMARY KEY, NOT NULL…) l’empêchent
d’avoir la valeur NULL.
Cette valeur est traitée différemment des autres valeurs. En effet si NULL est impliquée dans :

 Une expression arithmétique, alors le résultat de toute l’expression est NULL.

 Une expression logique, alors le résultat de tout l’expression est FAUX.
REQ 7
Le revenu annuel d’un employé est SAL*12 auquel on ajoute la commission COMM. Afficher
les salaires annuels de tous les employés ?
SELECT ENAME, SAL*12 + COMM ANNSAL FROM EMP ;

ENAME ANNSAL
SMITH
ALLEN 19500
WARD 15500
JONES
MARTIN 16400
BLAKE
CLARK
SCOTT
KING
TURNER 18000
ADAMS
JAMES
FORD
MILLER
Quoique le salaire de SMITH est de 9600, le résultat affiché ci-dessus est NULL. La fonction
NVL(col,val) nous sera très utile dans ce cas, car cette fonction retourne val si la colonne
porte la valeur NULL.
REQ 8
La requête est :
SELECT ENAME, SAL*12+NVL(COMM,0) ANNSAL FROM EMP ;

2.1.3 Le mot clé DISTINCT

Ce mot clé est introduit après SELECT, il sert à éliminer les occurrences, ainsi pour afficher
les codes de départements (chacun une seule fois) :
 Chapitre 2 : La sélection simple 10

REQ 9
SELECT DISTINCT DEPTNO FROM EMP ;
DEPTNO
10
20
30
DISTINCT ne peut être introduite qu’une seule fois, juste après le SELECT, et concerne
toutes les colonnes qui la suivent. Le résultat est toute combinaison distincte de ces colonnes.
REQ 10
Afficher les jobs dans chaque département de manière distincte.
SELECT DISTINCT JOB, DEPTNO FROM EMP ;

2.1.4 La clause ORDER BY

Le résultat retourné d’une requête n’a pas d’ordre défini. La clause ORDER BY permet de
trier le résultat selon une ou plusieurs colonnes dans un ordre croissant ou décroissant. Cette
clause doit être la dernière dans la requête et peut être suivie d’une colonne, d’une expression ou
même d’un alias.
REQ 11
Afficher les employés triés par leurs DEPTNO dans l’ordre décroissant et par leurs JOB dans
l’ordre croissant.
SELECT * FROM EMP ORDER BY DEPTNO DESC, JOB ASC ;
Chaque groupe de lignes ayant le même DEPTNO est lui-même trié selon le JOB dans l’ordre
croissant.

2.1.5 La restriction de lignes

Supposons que nous voulons afficher les employés du département 20. La requête que nous
devons formuler doit retourner chaque ligne de la table EMP dont la colonne DEPTNO a pour
valeur 20. Cette opération relationnelle est dite opération de restriction (ou sélection), et se base sur la
clause WHERE.
EMPNO ENAME JOB MGR HIREDATE SAL COMM DEPTNO

Figure 2 : Opération de restriction

La clause WHERE est suivie d’une condition simple ou composée (combinaison de plusieurs
conditions). Chaque ligne satisfaisant cette condition est retournée.
 Chapitre 2 : La sélection simple 11

REQ 12
Afficher les employés du département 20.
SELECT * FROM EMP WHERE DEPTNO=20 ;
REQ 13
Afficher les employés dont la commission est inférieure au salaire.
SELECT * FROM EMP WHERE NVL(COMM,0)<SAL ;

2.1.6 Les opérateurs de comparaison

Les opérateurs de comparaison classiques sont utilisables pour comparer deux valeurs de
même type (<, <=, >, >=, <>, !=, =). Cependant Oracle offre quatre opérateurs de
comparaison qui lui sont spéciaux :

 BETWEEN v1 AND v2  col≥v1 AND col≤v2.

 IN (v1,v2,v3,…,vn)  col= v1 OR col=v2 OR...OR col=vn.

 LIKE pattern (les symboles % et _ sont utilisés pour spécifier un pattern, le %

remplace une sous chaîne y compris la chaîne vide, le _ remplace un seul caractère).

 IS NULL (l’opérateur = ne peut pas être utilisée pour comparer une colonne à
NULL, on utilise cet opérateur).

L’opérateur logique NOT peut être utilisé avec ces opérateurs  NOT BETWEEN…., NOT
IN….., NOT LIKE…., IS NOT NULL.
REQ 14
Donner les noms et les salaires des employés dont le salaire est entre 1000 et 2000 ?
SELECT ENAME, SAL FROM EMP WHERE SAL BETWEEN 1000 AND 2000 ;

REQ 15
Donner les employés dont le manager est 7902, 7566 ou 7788 ?
SELECT * FROM EMP WHERE MGR IN (7902, 7566, 7788) ;
REQ 16
Afficher les employés dont le nom commence par ‘S’ ?
SELECT * FROM EMP WHERE ENAME LIKE „S%‟ ;

REQ 17
Afficher les employés dont le nom est composé de 4 caractères ?
 Chapitre 2 : La sélection simple 12

SELECT * FROM EMP WHERE ENAME LIKE „_ _ _ _‟ ;

REQ 18
Afficher les employés qui n’ont pas de manager ?
SELECT * FROM EMP WHERE MGR IS NULL ;

2.1.7 Les opérateurs logiques

Les opérateurs logiques sont les trois suivants AND, OR et NOT. Il est inutile de vous rappeler
que AND est prioritaire au OR, tout comme les opérateurs * et / qui sont prioritaires au + et au -
.
REQ 19
Afficher tous les clerks dont le salaire est entre 1000 et 2000 ?
SELECT * FROM EMP WHERE SAL BETWEEN 1000 AND 2000 AND
JOB=‟CLERK‟;
REQ 20
Afficher tous les managers dont le salaire est supérieur à 1500 et tous les salesman ?
SELECT * FROM EMP WHERE SAL>1500 AND JOB=‟MANAGER‟ OR
JOB=‟SALESMAN‟;
REQ 21
Afficher tous les salesman et tous les managers dont le salaire est supérieur à 1500 ?
SELECT * FROM EMP WHERE SAL>1500 AND (JOB=‟MANAGER‟ OR
JOB=‟SALESMAN‟);
 Chapitre 3 Les fonctions
Une fonction accepte un ou plusieurs arguments (paramètre, qui peut être une colonne, une
expression, une constante ou le résultat d’une fonction) et retournent un seul résultat sous forme
de valeur. Il existe deux types de fonctions, les fonctions qui opèrent sur les lignes et les
fonctions qui opèrent sur des groupes de lignes.

3.1 Les fonctions de lignes

Ces fonctions concernent une seule ligne et retournent donc un seul résultat par ligne. Elles
peuvent être utilisées dans la clause SELECT, dans la clause WHERE ou encore dans la clause
ORDER BY.
Les fonctions de ligne sont classées par le type de données de leurs arguments principaux,
nous distinguons ainsi cinq types de fonctions de lignes :
1. Les fonctions de caractères
2. Les fonctions de nombres
3. Les fonctions de date
4. Les fonctions de conversion
5. Les fonctions générales (de tous types de données)

3.1.1 Les fonctions de caractères

Ces fonctions acceptent au moins un argument chaîne de caractères et retournent un seul
résultat qui est de type chaîne de caractères ou nombre.
LOWER(arg) : renvoie l’argument mais en minuscule.
REQ 22
SELECT LOWER(ENAME), LOWER(„SQL‟) FROM EMP ;
LOWER(ENAME) LOWER(„SQL‟)
smith sql
allen sql
ward sql
jones sql
…………

…………

UPPER(arg) : renvoie l’argument mais en majuscule.

INITCAP(arg) : met en majuscule la première lettre de chaque mot, les lettres restantes
 Chapitre 3 : Les fonctions 14

de chaque mot sont mises en minuscule.

CONCAT(arg1,arg2) : renvoie la concaténation des deux arguments. Elle est équivalente
à l’opérateur ||.

SUBSTR(arg,m[,n]) : retourne la sous chaîne de l’argument qui commence de la m ème

position et de longueur n. Si n est omise, alors la sous-chaîne renvoyée s’étend de la position m
jusqu’à la fin de l’argument. Si m est négative, alors l’extraction se fait à partir de la fin de
l’argument. Finalement, si n est relativement grande alors le traitement se fait comme si elle était
omise.

Ainsi SUBSTR(„ORACLE‟,2,4)„RACL‟
LENGTH(arg) : retourne la taille de l’argument en nombre de caractères.
INSTR(arg,cc[,m][,n]) : retourne la position de cc dans l’argument en commençant
par la position m et dont l’occurrence est n. Par défaut m et n sont mis à 1.

LPAD(arg,m[,cc]) : rembourre l’argument à gauche plusieurs fois par les caractères de

cc jusqu’à ce que la taille de la chaîne retournée soit de m. Par défaut, cc est égale à l’espace.

Ainsi LPAD(„SQL‟,8,„or‟)  „ororoSQL‟

RPAD(arg,m[,cc]) : rembourre l’argument à droite plusieurs fois par les caractères de cc
jusqu’à ce que la taille de la chaîne retournée soit de m. Par défaut, cc est égale à l’espace.

LTRIM (arg,cc) : renvoie l’argument dont elle élague chaque caractère de cc si ce

caractère se trouve à son extrémité gauche. Le résultat retourné ne doit contenir à sa gauche
aucun caractère de cc.

Ainsi LTRIM(„OPERATION‟,„ASOP‟)  „ERATION‟

RTRIM(arg,cc) : renvoie l’argument duquel elle élague chaque caractère de cc si ce
caractère se trouve à son extrémité droite. Le résultat retourné ne doit contenir à sa droite aucun
caractère de cc.

TRIM([LEADING|TRAILING|BOTH] cc FROM arg) : si LEADING est précisé

alors la fonction est équivalente à LTRIM, si TRAILING est précisé alors la fonction est
équivalente à RTRIM sinon avec BOTH, l’élagage se fait des deux cotés. BOTH est considéré
par défaut.
REPLACE (arg,cc1[,cc2]) : remplace la sous chaîne cc1 par la sous chaîne cc2 dans
l’argument. Si cc2 est omise alors toutes les occurrences de cc1 sont enlevées de l’argument.

Ainsi REPLACE(„SMITH‟,„MI‟,„ABC‟)  „SABCTH‟

REPLACE („SMITH‟, „AX‟, „ABC‟)  „SMITH‟

REPLACE („SMITH‟, „MI‟)  „STH‟

 Chapitre 3 : Les fonctions 15

REQ 23
Afficher le nombre d’occurrences du caractère ‘E’ dans chaque nom d’employé ?
SELECT LENGTH(ENAME)–LENGTH(REPLACE(ENAME,„E‟)) NBRE FROM
EMP ;

3.1.2 Les fonctions numériques

ROUND(arg,n) : arrondit l’argument à la précision n, c-à-d à n chiffres décimaux. Si n=0,
alors l’argument est arrondi sur les unités, sinon (cas où n<0) l’argument est arrondit sur le
|n|+1ème chiffre à gauche de la virgule.

Ainsi ROUND(46.8)  47
ROUND(46.862,1)  46.9

ROUND(46.862,2)  46.86
ROUND(46.862,-1)  50
ROUND(51.342,-2)  100

Il est à noter que ROUND(5.5)  6.

TRUNC(arg,n) : tronque l’argument à la précision n.
TRUNC(46.862,1)  46.8

TRUNC(46.862,2)  46.86
TRUNC(46.862,-1)  40
TRUNC(51.342,-2)  0
CEIL(arg) : retourne le plus petit entier supérieur à l’argument.

CEIL(99.9)  100
CEIL(-11.1)  -11.
FLOOR(arg) : retourne le plus grand entier inférieur à l’argument.

FLOOR(99.9)  99
FLOOR(-11.1)  -12.
POWER(arg,n) : col à la puissance n.
EXP(arg) : exponentielle de col.
SQRT(arg) : racine carré de col.
SIGN(arg) : -1 si col <0, 1 si col>0, 0 sinon.
ABS(arg) : valeur absolue de col.
 Chapitre 3 : Les fonctions 16

MOD(arg, n) : col modulo n.

LOG(m,arg) : logarithme de base m de col.
SIN(arg) : sinus de col.

COS(arg) : cosinus de col.

3.1.3 Les fonctions de date

Le format de date par défaut est : DD-MON-YY. Ceci dit, Oracle stocke une date suivant un
format numérique interne plus détaillé : siècle, année, mois, jour, heure, minute et seconde.
Le pseudo colonne SYSDATE retourne la date système (inclut aussi l’heure système). Pour
afficher l’heure système, on peut utiliser la table DUAL. Le propriétaire de cette table est
l’utilisateur SYS, mais tous les utilisateurs peuvent y accéder. Elle contient une seule colonne
DUMMY et une seule ligne ‘X’. DUAL est utile si on veut retourner une valeur une seule fois.
Ainsi, il est plus judicieux de l’utiliser pour tester une fonction ou pour retourner la valeur d’un
pseudo colonne. Par exemple, pour connaître la date système, on peut exécuter cette requête :
SELECT SYSDATE FROM DUAL ;
On peut faire des calculs arithmétiques sur les DATE :
DATE1 + n : ajoute ou soustrait n jours de DATE1 (selon le signe de n) et retourne la date
résultat.

DATE1 – DATE2 : retourne la différence entre les deux dates en nombre réel de jours. Le
résultat est souvent un nombre réel car l’opération de soustraction tient compte des heures des
deux dates.

DATE1 + n/24 : Ajoute n heures à la date.

Les fonctions de date sont les suivantes :

MONTHS_BETWEEN(date1,date2) : retourne en nombre réel la différence en mois

entre les deux dates.

ADD_MONTHS(date1,n) : retourne la date qui vient n mois après date1.

NEXT_DAY(date1,char/n) : char{‘Lundi’,’Mardi’,…,’Dimanche’}, n{1,2,…,7}. Elle

retourne le prochain jour char dans la semaine de date1.
LAST_DAY(date1) : retourne la date du dernier jour du mois de date1.
ROUND(date1[,fmt]) : retourne date1 arrondie selon le format fmt (les formats de date
font l’objet de l’annexe B). Par exemple, si fmt=’MM’, alors l’arrondissement est fait sur le mois,
le résultat retourné est la date du 1er jour du mois de date1 si DD≤15, et la date du 1er jour du
mois suivant sinon. Si fmt=’YY’, alors le résultat retourné est la date du 1 er jour de l’année de
date1 si MM≤6, et la date du 1er jour de l’année suivante sinon. Si fmt est omise, alors date1 est
arrondie au jour le plus proche. Lorsque fmt est omise, alors l’arrondissement est fait sur le jour, la
 Chapitre 3 : Les fonctions 17

fonction retourne la même date si l’heure est < à 12 :00, et la date du lendemain si l’heure est ≥ à
12 :00.
TRUNC(date1[,fmt]) : retourne date1 tronquée selon fmt.

3.1.4 Les fonctions de conversion

Ce sont les fonctions de conversion entre types de données. Le serveur Oracle peut convertir
implicitement, sans l’utilisation d’une fonction :
VARCHAR2/CHAR  NUMBER
VARCHAR2/CHAR  DATE
DATE  VARCHAR2/CHAR
NUMBER  VARCHAR2/CHAR

Ainsi, la concaténation des colonnes EMPNO et ENAME de la table EMP est possible sans
convertir la colonne EMPLNO qui est numérique ; la conversion est faite de manière automatique.
La conversion explicite est faite à travers un ensemble de fonctions de conversion :

TO_CHAR(Date1,„fmt‟) : convertit une date en chaîne de caractères et l’affiche dans le

format „fmt‟ indiqué.
REQ 24
SELECT TO_CHAR(SYSDATE,„DD/MM/YYYY‟) FROM DUAL;
Affiche : 22/10/2004
REQ 25
SELECT TO_CHAR(SYSDATE,„DAY‟) FROM DUAL;
Affiche : ‘FRIDAY’
TO_CHAR(NOMBRE,„fmt‟) : convertit un nombre en chaîne de caractère dans le format
spécifié.

Exemple : TO_CHAR(900,„$9.999‟) affiche „$900.000‟

TO_NUMBER(char,‟fmt‟) : convertit une chaîne de caractère en nombre.
Exemple TO_NUMBER(„$1500‟,‟$9999‟) : affiche 1500.

TO_DATE(char,‟fmt‟) : convertit char en date selon le format de date mentionnée.

Exemple TO_DATE(‟23/10/2004‟,„DD/MM/YYYY‟) retourne la date dans le format
lisible par Oracle, à savoir ‟23-OCT-04‟.

3.1.5 Les fonctions opérant sur tous les types de données

DECODE(arg,SEARCH1,val1,[SEARCH2,val2,…],default_arg)
 Chapitre 3 : Les fonctions 18

Cette fonction retourne vali si arg=SEARCHi, si aucune valeur SEARCHi ne correspond à

l’argument arg, alors default_arg sera retournée.
REQ 26
Afficher les salaires de tous les employés sauf les managers à qui on affichera ‘MMM’ et le
président à qui on affichera ‘PPP’ ?
SELECT ENAME, DECODE(JOB, „MANAGER‟, „MMM‟, „PRESIDENT‟,
„PPP‟, SAL) SALAIRE FROM EMP;
NVL(arg,val) : retourne val si l’argument est NULL sinon la valeur de l’argument.
GREATEST(arg1,arg2,…) : retourne l’argument la plus grande. S’il s’agit de DATE, alors
elle retourne la date la plus récente.

LEAST(arg1,arg2,…) : retourne la valeur la plus petite.

VSIZE(arg) : retourne en nombre de bytes (octets) la taille de la colonne ou de la valeur.

3.2 Les fonctions de groupe

Contrairement aux fonctions de lignes, les fonctions de groupe opèrent sur des groupes de
lignes et retournent un seul résultat par groupe.
AVG([DISTINCT|ALL] arg) : retourne la moyenne des arguments pour chaque groupe
tout en ignorant les valeurs NULL.
REQ 27
Afficher la moyenne des commissions des employés ?
SELECT AVG(COMM) MOYENNE FROM EMP ;

MOYENNE
550

REQ 28
Afficher la moyenne des salaires annuels des employés du département 20 ?
SELECT AVG(SAL*12+NVL(COMM,0)) MOYENNE FROM EMP
WHERE DEPTNO=20;

MOYENNE
26100
COUNT(*|[DISTINCT]|[ALL] arg) : retourne pour chaque groupe le nombre de
lignes où l’argument est différent de NULL. Pour retourner le nombre de lignes y compris les
lignes dupliquées et ayant des champs NULL, on utilise COUNT(*).
 Chapitre 3 : Les fonctions 19

REQ 29
Afficher le nombre de lignes de la table EMP ?
SELECT COUNT(*) “NB LIGNES” FROM EMP ;

NB LIGNES
14
REQ 30
Afficher le nombre de jobs dans l’netrprise?
SELECT COUNT(DISTINCT JOB) NB_JOB FROM EMP ;

NB_JOB
5
MAX([DISTINCT|ALL] arg) : retourne la valeur maximale de l’argument pour chaque
groupe.

REQ 31
Afficher le salaire maximum ?
SELECT MAX(SAL) SAL_MAX FROM EMP ;

SAL_MAX
5000

MIN([DISTINCT|ALL] arg) : retourne la valeur minimale de l’argument pour chaque

groupe.

REQ 32
Afficher le salaire minimum ?
SELECT MIN(SAL) SAL_MIN FROM EMP ;

SAL_MIN
800
SUM([DISTINCT]/[ALL] arg) : retourne la somme des valeurs de l’argument.
VARIANACE([DISTINCT]/[ALL] arg): retourne la variance des valeurs de
l’argument.
STDDEV([DISTINCT]/[ALL] arg) : retourne l’écart type (standard deviation) des
valeurs de l’argument.

Le mot clé DISTINCT oblige une fonction de groupe à ne considérer que les lignes
distinctes ; contrairement à ALL qui lui oblige à considérer les valeurs dupliquées. ALL est
 Chapitre 3 : Les fonctions 20

considérée par défaut.

Toutes les fonctions de groupe ignorent les valeurs NULL. Pour considérer cette valeur
spéciale, on peut utiliser la fonction NVL.

3.2.1 La clause GROUP BY

Jusqu’à maintenant nous avons traité la table comme étant un grand groupe de lignes. Parfois,
nous avons besoin de diviser la table en petits groupes. Ceci est faisable via la clause GROUP
BY. Cette clause est suivie d’une colonne. Les lignes qui sont incluses dans chaque groupe
résultant ont la même valeur pour cette colonne.
REQ 33
Afficher le nombre d’employés dans chaque département ?
SELECT DEPTNO, COUNT(*) NBR_EMP FROM EMP
GROUP BY DEPTNO ;

DEPTNO NBR_EMP
10 3
20 5
30 6
REQ 34
Afficher la moyenne des salaires par job dans le département 20 ?
SELECT JOB, AVG(SAL) FROM EMP
WHERE DEPTNO=20
GROUP BY JOB ;

JOB AVG(SAL)
ANALYST 3000
CLERK 950
MANAGER 2975
Remarque
Il est à noter qu’on ne peut mettre dans la clause SELECT que les fonctions de groupe et/ou
les colonnes qui suivent la clause GROUP BY.

3.2.2 Groupes dans des groupes

Parfois, nous avons besoin d’informations concernant des groupes à l’intérieur de groupes.
Pour ceci, il faudrait lister plus qu’une colonne dans la clause GROUP BY.
REQ 35
Afficher la moyenne de salaires des employés pour chaque job à l’intérieur de chaque
département ?
SELECT DEPTNO, JOB, AVG(SAL) FROM EMP
 Chapitre 3 : Les fonctions 21

GROUP BY DEPTNO, JOB ;

DEPTNO JOB AVG(SAL)

10 CLERK 1300
10 MANAGER 2450
10 PRESIDENT 5000
20 ANALYST 3000
20 CLERK 950
20 MANAGER 2975
30 CLERK 950
30 MANAGER 2850
30 SALESMAN 1400

3.2.3 La clause HAVING

Tout comme la clause WHERE qui sert à restreindre les lignes retournées, cette clause sert à
restreindre les groupes retournés. La clause HAVING est suivie d’une condition simple ou
composée qui concerne les colonnes qui suivent la clause GROUP BY, ou/et des fonctions de
groupe.
REQ 36
Afficher les moyennes de salaires de chaque département s’il inclut plus de 3 employés ?
SELECT DEPTNO, AVG(SAL) FROM EMP
GROUP BY DEPTNO
HAVING COUNT(*) > 3 ;
DEPTNO AVG(SAL)
20 2175
30 1566.66
REQ 37
Afficher la date d’embauche du dernier salarié recruté pour chaque unité de travail et par
département (une unité de travail regroupe tous les employés de même directeur). Exclure les
groupes dont le salaire minimum est inférieur à 1000. Exclure tous les employés dont le nom
commence par ‘S’ ?
SELECT MAX(HIREDATE) FROM EMP
WHERE ENAME NOT LIKE „C%‟
GROUP BY MGR, DEPTNO
HAVING MIN(SAL)>=1000;
 Chapitre 4 Le Langage de Définition de Données
Jusque là, nous avons réalisé toutes les interrogations possibles sur les données, sans pour
autant savoir comment gérer leurs structures. Dans ce chapitre, il s’agit de présenter les requêtes
de création, de modification et de suppression des tables dans une base de données Oracle.

7.1 Création d’une table – CREATE TABLE

C’est la requête CREATE TABLE qui sert à créer une table dans la norme SQL. Une table
étant définie par son nom et ses colonnes (une colonne étant définie par son nom et son type de
données), la syntaxe générale et simple de ce type de requête est la suivante :
CREATE TABLE table (colonne1 type1, colonne2 type2, …, colonnen typen) ;

Supposons que nous voulons créer la table personne dont les champs sont : id, nom, prénom et
date de naissance. La requête relative est la suivante :
CREATE TABLE personne (id NUMBER, nom VARCHAR2(15), prenom VARCHAR2(15),
date_naissance DATE) ;

A partir de ce moment, il est possible d’insérer des lignes dans la table personne (objet du
prochain chapitre).

7.2 Les contraintes

Une contrainte concerne une colonne de la table et peut être aperçue comme étant une
condition que doivent respecter les valeurs de cette colonne. Elle est spécifiée lors de la création
de la table et vient après le type de données de la colonne dans la requête :
[CONSTRAINT nom_contrainte] contrainte

Toute contrainte est définie par une table, une colonne, un type et un nom. L’utilisateur peut
affecter un nom à une contrainte, sinon Oracle lui affectera un nom par défaut. Les types de
contraintes sont les suivants :
1. Clé primaire

PRIMARY KEY une clé primaire d’une table est composée d’une ou plusieurs colonnes. Elle
est utilisée pour identifier chaque ligne de manière unique. La valeur d’une clé primaire composée
de plusieurs colonnes est dite clé primaire composée. Une clé primaire ne doit pas contenir de
valeurs NULL.
2. Clé unique
UNIQUE cette contrainte oblige la colonne de ne pas avoir deux valeurs identiques. Elle a
donc le même principe qu’une clé primaire à l’exception qu’elle peut avoir la valeur NULL. Cette
contrainte peut être appliquée à une ou à plusieurs colonnes (dans ce cas, chaque uplet doit être
unique).
 Chapitre 4 : Le Langage de Définition de Données 40

3. Clé étrangère
FOREIGN KEY … REFERENCES … elle représente une relation entre deux tables. Elle
concerne une ou plusieurs colonnes d’une table dite table fille, et dont les valeurs dépendent des
clés primaires ou uniques (et de leurs types données) d’une table dite table mère. On peut ajouter
l’option [ON DELETE CASCADE] pour que la suppression d’une ligne de la table mère
entraîne la suppression de toutes les lignes de la table fille qui en dépendent. Si cette option n’est
pas spécifiée ([ON DELETE RESTRICT] par défaut), la suppression des lignes de la table mère
est impossible si elles référencent des lignes dans la table fille. On peut aussi ajouter [ON
DELETE SET NULL] et dans ce cas, la suppression d’une ligne de la table mère entraîne la mise
à NULL des colonnes qui la référencent dans la table fille.
4. Contrainte de vérification
CHECK parfois la colonne d’une table doit satisfaire certaines conditions posées par
l’utilisateur. Les contraintes de vérification permettent généralement de restreindre le domaine
d’une colonne.
5. NOT NULL
NOT NULL si cette contrainte est appliquée à une colonne, alors cette colonne ne doit pas
contenir de valeurs NULL.
REQ 68
Créez la table EMP sachant que la table DEPT l’est déjà. Cette table contient une clé primaire
EMPNO, un nom qui doit être unique ENAME, un poste JOB, un salaire SAL qui doit dépasser
un salaire minimum conventionnel (SMIG) de 600, une date d’embauche HIREDATE qui ne
peut pas être NULL, un code d’employeur MGR qui réfère la colonne EMPNO et finalement un
numéro de département DEPTNO qui réfère la colonne DEPTNO de la table DEPT ?
CREATE TABLE EMP(EMPNO NUMBER CONSTRAINT PK1 PRIMARY KEY, ENAME
VARCHAR2(20) CONSTRAINT UN1 UNIQUE, JOB VARCHAR2(15), SAL NUMBER CONSTRAINT
CH1 CHECK(SAL>600), HIREDATE DATE DEFAULT ‟01-JAN-80‟ NOT NULL, MGR NUMBER
CONSTRAINT FK_EMP_EMP REFERENCES EMP(EMPNO), DEPTNO NUMBER REFERENCES
DEPT(DEPTNO) ON DELETE CASCADE) ;

Rappelons que dans la requête, chaque clause CONSTRAINT sert à donner un nom à la
contrainte en cours et qu’elle est facultative (la clause). En cas d’omission de cette clause, Oracle
affectera par défaut un nom à cette contrainte.
Remarquez aussi le mot clé DEFAULT suivi par une constante et défini sur la colonne
HIREDATE. Ce mot clé sert à affecter à une colonne une valeur par défaut si on insère une ligne
et qu’on ignore cette colonne.
Oracle SQL (et non pas SQL) permet aussi de créer une table et d’y insérer les lignes
résultantes d’une interrogation SELECT en une seule requête.
 Chapitre 4 : Le Langage de Définition de Données 41

REQ 69
Créez la table EMP1 dont les colonnes sont NUEMP, NOMEMP, NOMDEPT et EGRADE
et y insérer les lignes convenables à partir des tables EMP, DEPT et SALGRADE ?
CREATE TABLE EMP1(NUEMP NUMBER PRIMARY KEY, NOMEMP VARCHAR2(15), NOMDEPT
VARCHAR2(15), EGRADE VARCHAR2(15))
AS SELECT EMPNO, ENAME, DNAME, GRADE FROM EMP E, DEPT D, SALGRADE S
WHERE E.DEPTNO=D.DEPTNO AND E.SAL BETWEEN S.LOSAL AND S.HISAL;

Naturellement, on doit respecter l’égalité du nombre des colonnes et de leurs types de

données entre la définition de la table et la sélection de la requête SELECT. Il est possible
également que la définition d’une table soit directement extraite à partir de la requête SELECT.
REQ 70
Créez une table doublure de la table DEPT en structure et en données ?
CREATE TABLE DEPTDOUB AS SELECT * FROM DEPT;

Dans le cas, de création d’une table à clé primaire composée, cette contrainte est ajoutée à la
fin de la requête. De même pour la contrainte unique qui peut porter sur plusieurs tables :
REQ 71
Créez la table FPJ ?
CREATE TABLE FPJ(NF NUMBER REFERENCES F(NF), NP NUMBER REFERENCES P(NP),
NJ NUMBER REFERENCES J(NJ), QTE NUMBER, PRIMARY KEY(NF,NP,NJ));

7.3 Modification d’une table – ALTER TABLE

La modification d’une table consiste à ajouter, renommer, modifier ou supprimer une colonne,
ou à ajouter, modifier ou supprimer une contrainte. La requête de modification d’une table est
ALTER TABLE.

7.3.1 Renommer une table

Il est possible de renommer une table de deux manières, via la requête RENAME ou encore la
clause RENAME dans la requête ALTER TABLE.
REQ 72
Renommer de deux manières la table EMP pour EMPLOYE ?
RENAME EMP TO EMPLOYE;

ALTER TABLE EMP RENAME TO EMPLOYE;

7.3.2 Ajouter une colonne

L’ajout de colonne se fait via la clause ADD. Une colonne ajoutée est mise à NULL pour
toutes les lignes. Il en découle qu’on ne peut pas appliquer une contrainte sur cette colonne lui
 Chapitre 4 : Le Langage de Définition de Données 42

interdisant d’avoir une valeur NULL à moins qu’elle soit affectée à une valeur par défaut ou que
la table soit vide.
REQ 73
Ajouter les colonnes téléphone TEL et Adresse ADR. La colonne TEL ne doit pas avoir la
valeur NULL ?
ALTER TABLE EMP ADD (TEL NUMBER(8) DEFAULT „00000000‟ NOT NULL, ADR
VARCHAR2(30)) ;

7.3.3 Renommer une colonne

Il est possible de renommer une colonne via la clause RENAME COLUMN.
REQ 74
Renommer la colonne SAL pour SALARY dans la table EMP ?
ALTER TABLE EMP RENAME COLUMN SAL TO SALARY;

7.3.4 Modifier une colonne

Ça revient à modifier son type de données via la clause MODIFY COLUMN. Il est possible
d’augmenter la taille d’une colonne de type numérique ou chaîne de caractères et de la diminuer si
toutes les valeurs de la colonne le permettent. Il est aussi possible de changer le type de données
si la colonne en question ne contient que des valeurs NULL. On peut aussi changer du type
CHAR au type VARCHAR2 (et vice versa) si les champs sont NULL ou si on ne change pas la
taille. Finalement un changement de la valeur par défaut n’affecte que les insertions futures.
REQ 75
Modifier la taille de la colonne JOB à 30 caractères variables ?
ALTER TABLE EMP MODIFY (JOB VARCHAR2(30));

7.3.5 Supprimer une colonne

La clause DROP COLUMN dans la requête ALTER TABLE permet de supprimer une
colonne d’une table. Il est possible de supprimer des colonnes contenant des données à condition
qu’elle ne soit pas l’unique colonne de la table ou référencée dans une autre table. Si la colonne
est référencée par une colonne d’une autre table (fille), alors il faut ajouter l’option CASCADE
CONSTRAINTS pour éliminer aussi la contrainte FOREIGN KEY de la colonne étrangère.
REQ 76
Supprimer la colonne HIREDATE de la table EMP ?
ALTER TABLE EMP DROP COLUMN HIREDATE;
 Chapitre 4 : Le Langage de Définition de Données 43

7.3.6 Marquer une colonne

L’option SET UNUSED marque une ou plusieurs colonnes pour une suppression ultérieure.
En effet, la suppression d’une colonne (surtout pour des tables de grande taille) peut prendre un
temps considérable contrairement à son marquage. Grâce à cette opération, la colonne marquée
n’apparaît plus à l’utilisateur, une fois la base de données n’est plus interrogée fréquemment, on
peut supprimer les colonnes marquées via la clause DROP UNUSED COLUMNS.
REQ 77
Ecrire deux requêtes, la 1ère sert à marquer la colonne JOB pour la suppression, la 2ème sert à
éliminer toutes les colonnes marquées ?
ALTER TABLE EMP SET UNUSED (JOB);
ALTER TABLE EMP DROP UNUSED COLUMNS;

7.3.7 Ajouter une contrainte

On peut ajouter une contrainte à une table existante en utilisant la requête ALTER TABLE et
la clause ADD CONSTRAINT. Cette opération ne réussit que si les données qui existent déjà
dans la table respectent la contrainte qu’on veut ajouter.
REQ 78
Supposons que la table EMP n’est soumise à aucune contrainte. Ajoutez les contraintes
nécessaires ?
ALTER TABLE EMP ADD (CONSTRAINT PK1 PRIMARY KEY (EMPNO), CONSTRAINT
FK_EMP_DEPT FOREIGN KEY(DEPTNO) REFERENCES DEPT(DEPTNO)) ;

L’ajout d’une contrainte n’est possible que si les données qu’elle concerne, la respectent déjà.

7.3.8 Désactivation/Activation de contraintes

La désactivation d’une contrainte est possible via la clause DISABLE dans la requête ALTER
TABLE. Parfois, on a besoin de désactiver une contrainte qui nous gênerait lors de l’insertion
d’un grand nombre de lignes. Par exemple, lors de l’insertion d’un employé dans la table EMP, il
faut s’assurer que son employeur existe déjà dans la table (la colonne MGR doit avoir une valeur
qui existe déjà dans la colonne EMPNO). Pour ce, on pourrait désactiver la contrainte
FOREIGN KEY de la colonne MGR, insérer toutes les lignes et réactiver la contrainte.
La syntaxe de la clause DISABLE est la suivante :
DISABLE PRIMARY KEY | UNIQUE(col) | CONSTRAINT cte [CASCADE]
REQ 79
Désactiver la contrainte de clé étrangère concernant la colonne MGR ?
ALTER TABLE EMP DISABLE CONSTRAINT FK_EMP_EMP ;
 Chapitre 4 : Le Langage de Définition de Données 44

Notons ici l’importance de nommer une contrainte lors de sa création, car la clause DISABLE
ne réfère les contraintes FOREIGN KEY, NOT NULL et CHECK que par leurs noms (un nom
que l’utilisateur donne à la contrainte, ou assigné par défaut par Oracle).
La réactivation d’une contrainte se fait par la clause ENABLE. Il faut bien sûr que les données
respectent déjà cette contrainte sinon sa réactivation échouera. Par exemple, si on veut réactiver
la contrainte FK_EMP_EMP, il faut que la colonne MGR ne contienne aucune valeur
n’appartenant pas à la colonne EMPNO.
REQ 80
Réactiver la contrainte de clé étrangère sur la colonne MGR de la table EMP ?
ALTER TABLE EMP ENABLE CONSTRAINT FK_EMP_EMP ;

7.3.9 La suppression d’une contrainte

La clause DROP CONSTRAINT permet de supprimer une contrainte d’une table. Elle est
donc suivie par le nom de la contrainte (notons encore une fois l’importance du nom d’une
contrainte) et optionnellement par le mot clé CASCADE. Si ce mot clé est précisé, alors la
suppression d’une clé primaire d’une table mère, la suppression de la clé étrangère
correspondante dans la table fille est effectuée automatiquement.

7.4 Suppression d’une table – DROP TABLE

La suppression d’une table est effectuée par la requête DROP TABLE, celle-ci détruirait les
données et la structure de la table. Si votre table est une table mère, c-à-d que sa clé primaire est
référée par d’autres colonnes FOREIGN KEY qui sont dans une ou plusieurs tables filles, alors
la suppression est impossible. La solution est d’utiliser l’option CASCADE CONSTRAINTS ;
dans ce cas là, les contraintes FOREIGN KEY –posées sur les colonnes des tables filles- seront à
leurs tours supprimés.
REQ 81
Supprimer totalement la table DEPT ?
DROP TABLE DEPT CASCADE CONSTRAINTS;

7.5 Consultation des contraintes

Vous pouvez visualiser vos contraintes en les sélectionnant à partir de la vue
USER_CONSTRAINTS :
REQ 82
Afficher les contraintes de la table EMP dont l’utilisateur a assignées un nom ?
SELECT CONSTRAINT_NAME, CONSTRAINT_TYPE FROM USER_CONSTRAINTS
WHERE TABLE_NAME=‟EMP‟;
 Chapitre 4 : Le Langage de Définition de Données 45

Vous pouvez aussi consulter les noms de colonnes (COLUMN_NAME) et le nom de la

contrainte qui les concernent (CONSTRAINT_NAME) à partir de la vue
USER_CONS_COLUMNS.
 Chapitre 5 Le Langage de Manipulation de Données
Lorsqu’on veut insérer des données, les modifier ou les supprimer, nous devons exécuter des
requêtes du langage de manipulation de données. Ces opérations de mise à jour sont faites via
trois requêtes INSERT, UPDATE et DELETE.

8.1 Ajout de données – INSERT

L’ajout d’une ou de plusieurs lignes dans une table se fait par la requête INSERT. Si on veut
ajouter les données ligne par ligne, on peut alors utiliser la première variante de la requête
INSERT dont la forme générale est la suivante :
INSERT INTO nom_table[(col1,[ col2,…, coln])] VALUES (v1,[v2,…,vn]).

nom_table est le nom de la table dans laquelle on veut insérer notre ligne, il est suivi par la liste
des colonnes de la table, par le mot clé VLAUES et par la liste des valeurs qu’on veut insérer. Il
est possible d’insérer une partie d’une ligne (omettre les valeurs d’une ou de plusieurs colonnes)
mais à condition de respecter les contraintes de la table (on ne peut pas omettre la valeur d’une
colonne NOT NULL), dans ce cas les valeurs non communiquées auront NULL par défaut. Il
faut aussi respecter une certaine cohérence dans la requête INSERT entre la liste descriptive de la
table et la liste des valeurs à ajouter. Cette cohérence concerne le nombre et l’ordre des colonnes.
La liste descriptive peut être omise, et dans ce cas on doit respecter l’ordre des colonnes (défini
lors de la création de la table et qu’on peut consulter par la commande DESC nom_table) et saisir
les valeurs de toutes les colonnes de la table.
REQ 83
Insérer dans la table EMP le nouvel employé de matricule 7521, de nom ‘PATRICK’,
‘SALESMAN’, de manager 5000, de salaire 1250 et département 30 ?
INSERT INTO EMP (EMPNO,ENAME,JOB,HIREDATE,MGR,SAL,DEPTNO)
VALUES(7521,„PATRICK‟,‟SALESMAN‟,SYSDATE,5000,1250,30);

La deuxième alternative d’ajout de données permet d’insérer un ensemble de lignes par la

requête SELECT. Les lignes insérées sont le résultat de cette dernière.
INSERT INTO nom_table(col1,col2,…,coln)
SELECT arg1, arg2, …, argn FROM table…;
La requête SELECT peut utiliser la jointure, les sous-requêtes etc. l’important est de respecter
l’ordre, le nombre et les types de données des colonnes sélectionnées.
REQ 84
Insérer dans la table EMP2 (qui est vide et de même structure que EMP) tous les employés de
la table EMP ?
INSERT INTO EMP2
SELECT * FROM EMP;
 Chapitre 5 : Le Langage de Manipulation de Données 47

REQ 85
Dans la table FPJ, insérer le projet ‘J1’ qui a été alimenté par 5 pièces ‘P1’ par les fournisseurs
de ‘LONDRES’ ?
INSERT INTO FPJ
SELECT NF,‟J1‟,‟P1‟,5 FROM F
WHERE VILLE=‟LONDRES‟;

8.2 Modification de données – UPDATE

La modification des données se fait via la requête UPDATE. Cette requête met à jour une ou
plusieurs lignes de la table (la mise à jour peut concerner une ou plusieurs colonnes). La syntaxe
de cette requête est la suivante :
UPDATE nom_table
SET col1=arg1 [, col2=arg2, …, coln=argn]
[WHERE condition(s)]

Ici, la mise à jour concerne la table nom_table et plus particulièrement les lignes de cette table
qui satisfont la condition de la clause WHERE. Seules les colonnes de la clause SET sont
modifiées par cette requête. Un argument argi peut être un littéral (constante), une expression, une
fonction ou encore une sous-requête (le résultat d’une sous-requête). Il est à noter que la clause
WHERE est facultative, si elle est omise la mise à jour concerne alors toute les lignes de la table.
Il est possible aussi de mettre à jour plusieurs colonnes d’une table à partir d’une seule sous-
requête, la syntaxe correspondante est la suivante :
UPDATE nom_table
SET (col1,…,coln)=(SELECT arg1,…,argn FROM table)
[WHERE condition(s)]

REQ 86
Mettez à jour la colonne COMM dans la table EMP. Chaque valeur NULL doit être remplacée
par zéro ?
UPDATE EMP
SET COMM=0
WHERE COMM IS NULL;

REQ 87
Mettez à jour le salaire et le job des SALESMAN, ils ont eu une augmentation de 10% et leur
job est maintenant dit SALESPERSON ?
UPDATE EMP
SET SAL=SAL*1.1, JOB=‟SALESPERSON‟
WHERE JOB=‟SALESMAN‟ ;
 Chapitre 5 : Le Langage de Manipulation de Données 48

REQ 88
Affectez pour chaque employé du département 10 et 20 le salaire minimum de son
département ?
UPDATE EMP A
SET SAL=(SELECT MIN(SAL) FROM EMP B
WHERE B.DEPTNO=A.DEPTNO)
WHERE A.DEPTNO IN (10,20);

8.3 Suppression de données – DELETE

L’élimination de données se fait par lignes via la requête DELETE. La syntaxe de cette
requête est la suivante :
DELETE FROM nom_table
[WHERE condition(s)]

La clause WHERE est facultative, elle est utilisée pour spécifier quelles lignes veut-on
éliminer. Si la clause WHERE est omise, alors toutes les lignes de la table sont supprimées.
REQ 89
Supprimez toutes lignes de la table SALGRADE ?
DELETE FROM SALGRADE;

REQ 90
Supprimez les employés du département 30 ?
DELETE FROM EMP
WHERE DEPTNO=30;
 Annexe A

Les tables EMP, DEPT et SALGRADE sont utilisés dans les exemples du document.

La table EMP

La table DEPT

La table SALGRADE
 Annexe B
Ce tableau contient les éléments d’un format de Date, il peuvent être combinés pour donner
un format utilisable lors d’une conversion VARCHAR DATE ou DATE VARCHAR.

Eléments D’un Format De Date Signification

Siècle, exemple to_char(sysdate) retourne

CC
21.

YYYY ou YYY ou YY ou Y Année sur 4 chiffres, 3 chiffres, 2 ou 1 seul.

YEAR Année en toutes lettres.

Quart de l’année, par ex

Q
to_char(sysdate,’Q’) retourne 4.

MM Mois en chiffres (compris entre 1 et 12).

MONTH Mois en toutes lettres.

Abréviation du mois (en lettre

MON
évidemment).

WW ou W Semaine de l’année ou du mois.

DDD ou DD ou D Jour de l’année, du mois ou de la semaine.

DAY Jour en toutes lettres.

DY Abréviation du jour.

PM ou AM Indicateur méridien.

HH ou HH12 Heure du jour (de 0 à 12).

HH24 Heure du jour (de 0 à 23)

MI Minute.

SS Seconde.
 Annexe B 51

Remarques :
1. DAY et MONTH retournent le jour et le mois en toutes lettres, pour uniformiser leurs
tailles, la fonction to_char ajoute des espaces. Tous les DAY sont retournés sur 9 lettres, de
même pour les MONTHS.
Le préfixe fm peut être ajouté à MONTH ou DAY pour éliminer les espaces ajoutés
(‘DAYFM’ ou ‘MONTHFM’).
2. Trois suffixes peuvent être utilisés :
TH : retourne un nombre ordinal, exemple ‘DDTH’ nous donne ‘4TH’ si DD=04.
SP : retourne un nombre en toutes lettres, exemple ‘DDSP’ nous donne ‘FOUR si DD=04.
SPTH : retourne un nombre ordinal en toutes lettres, exemple ‘FOURTH’.
3. Les éléments d’un format de Date sont sensibles à la majuscule/minuscule et affectent
l’affichage des éléments correspondants. Pour un Sysdate=’09-nov-04’ :
To_Char(Sysdate, ‘DAY’) retourne ‘TUESDAY’ alors que To_Char(Sysdate, ‘Day’) retourne
‘Tuesday’.