Académique Documents
Professionnel Documents
Culture Documents
BDD Chap7 PDF
BDD Chap7 PDF
BDD Chap7 PDF
Langage SQL
I. Introduction
SQL (Structured Query Language, ou langage de requêtes structurées) est l'interface externe la plus
répandue pour gérer une base de données. C'est un langage déclaratif dans le sens où il suffit d'exprimer ce
que l'on veut obtenir, sans devoir expliquer la méthode pour y parvenir. Ainsi, les opérations directement
utilisables par les usagers sont en général celles des langages dits assertionnels.
Ces langages, bâtis sur l'algèbre relationnelle, permettent de manipuler des bases de données relationnelles.
Nous pouvons citer à titre d'exemple :
- QUEL (QUEry Language) par Zook en 1977
- QBE (Query By Example) par Zloof en 1977
- SQL (Structured Query Language) par IBM
Aujourd'hui, le langage SQL est normalisé et constitue le standard d'accès aux bases de données
relationnelles. Les autres interfaces par menus, fenêtres, grilles ou de programmation type langage de 3ème
ou 4ème génération (L3G et L4G) sont le plus souvent offertes au-dessus du langage SQL. Celui-ci
constitue donc le point d'entrée des SGBD relationnels. Il a été normalisé à quatre reprises (ISO et ANSI
sont des organismes chargés de la normalisation) :
- 1986 : SQL 86 - ANSI*
- 1989 : - ISO* et ANSI
- 1992 : SQL 2 - ISO et ANSI
- 1999 : SQL 3 - ISO
Chacun de ces sous-langages propose ses mots-clés propres. Voici les principales primitives que nous
verrons au cours de ce chapitre :
LDD LMD LCD
CREATE SELECT GRANT
ALTER INSERT REVOKE
DROP UPDATE COMMIT
DELETE ROLLBACK
1. Création de table
La création de table se fait grâce au mot-clé CREATE TABLE.
Chaque table est définie par :
- son nom
- sa liste d'attributs
- sa liste de contraintes sur table
Chaque attribut est défini par :
- son type
- sa valeur par défaut
- sa liste des contraintes sur attribut
Le type des attributs est à choisir parmi un ensemble fini de types. Les principaux types possibles sont
selon les standards:
- VARCHAR2(n) : chaîne de caractères de longueur variable (maximum n)
- CHAR(n) : chaîne de caractères de longueur fixe (n caractères)
- NUMBER : nombre entier (40 chiffres au maximum)
- NUMBER(n,m) : nombre entier de longueur totale n avec m décimales
- INTEGER : entier
- FLOAT : réel
- DATE : date (DD-MON-YY est le format par défaut)
- ...
Syntaxe de définition d'une table en SQL
8. Si les attributs de FOREIGN KEY correspondent à une clé candidate dans une autre
relation, la clause REFERENCES doit mentionner le nom de cette relation ainsi que la liste
des attributs composant la clé candidate.
9. Les clauses PRIMARY KEY, UNIQUE et NOT NULL sont redondantes lorsqu'il n'y a
qu'une clé par relation. L'une ou l'autre des clauses suffit à la spécifier. Selon la clause
utilisée, il faut assurer la cohérence de la définition des contraintes référentielles en utilisant
respectivement la règle 7 ou la règle 8.
10. Il faut enfin noter que l'ordre des CREATE TABLE peut être très important par rapport aux
contraintes : les tables référencées doivent apparaître avant les tables référençantes.
b. Exemple
CONSTRAINT C3
PRIMARY KEY (numImmatriculation, numPersonne),
CONSTRAINT C4
FOREIGN KEY (numImmatriculation)
REFERENCES VOITURE(Immatriculation),
CONSTRAINT C5
FOREIGN KEY (numPersonne)
REFERENCES Personne(NuméroSS)
);
On peut également créer une table appelée ma_table par récupération d'une partie seulement de la
structure et du contenu de ACHAT. On renomme dans l'exemple ci-dessous les colonnes
numImmatriculation et nomPersonne en num et nom :
| [
MODIFY
(attribut1 type1
[DEFAULT valeur_par_défaut] [contraintes sur attribut1],
...,
attributN typeN
[DEFAULT valeur_par_défaut] [contraintes sur attributN]);
]
a. Règles
Dans une table ayant déjà des tuples, l'ajout d'un attribut implique la mise à NULL de toute la
colonne correspondant à cet attribut. Ceci implique que la clause NOT NULL ne doit pas être
spécifiée pour cet attribut dans sa définition.
La suppression d'un attribut doit obéir aux quelques règles suivantes :
- On ne peut supprimer un attribut-clé ou faisant partie de la clé.
- La suppression d'une clé étrangère mono-attribut (une référence à la clé d'une autre table)
entraîne automatiquement la suppression de la contrainte référentielle correspondante
(puisque cette contrainte est définie en même temps que l'attribut).
- La suppression d'une clé étrangère multi-attribut doit être précédée de la suppression de la
contrainte référentielle correspondante (puisque cette dernière est déclarée à part). Sans cette
suppression de la contrainte, toute mise à jour ultérieure de ces attributs peut entraîner une
anomalie dans le contrôle de l'intégrité référentielle.
La modification d'un attribut doit respecter les règles suivantes :
- Si le nom d'une clé change, il faut propager cette modification sur toutes les tables qui
référencent cette clé.
- Toute modification d'une contrainte sur attribut doit respecter les règles de cohérence des
contraintes 1 à 9 spécifiées dans la leçon relative à la création de table.
Base de données 42
La suppression de contrainte est une relaxation de contrainte qui rend les futures requêtes plus
permissives qu'elles ne l'étaient avant. Cette suppression ne met pas particulièrement en péril
l'intégrité de la base.
- Toute suppression de contrainte doit conserver les règles sur contraintes 1 à 9 spécifiées
dans la leçon relative à la création de table.
La suppression de contrainte nécessite que cette contrainte possède un nom.
b. Exemple
On désire ajouter les attributs Type et Puissance à la table VOITURE. Voici l'instruction SQL
permettant d'ajouter ces attributs.
a. Règles
L'opération de suppression de table peut se faire moyennant certaines précautions :
- Avant de supprimer une table, il faut supprimer toutes les références à cette table dans les
autres tables (ou utiliser le CASCADE CONSTRAINTS).
- Avant de supprimer une table, il faut avoir redéfini ou supprimé toutes les vues impliquant
cette table (nous reviendrons un peu plus loin sur la définition des vues).
La suppression d'une table implique de redéfinir ou supprimer toutes les requêtes impliquant la
table supprimée.
b. Exemple
On désire supprimer la table VOITURE. Voici l'instruction SQL permettant d'effectuer cette
requête :
RENAME nom_table
TO nouvelle_table;
DESC[RIBE] nom_table;
1. SELECT
L'affichage des données d'une ou plusieurs tables se fait grâce au mot-clé SELECT.
Syntaxe de la primitive SELECT en SQL
Les mots-clés DISTINCT et ALL permettent respectivement d'éliminer ou de conserver les doublons
après une projection mise en œuvre par l'ordre SELECT suivi d'une liste d'attributs.
La clause FROM désigne les relations concernées par la requête. Chaque nom de relation peut être
suivi d'un alias (variables synonymes pour chaque relation). Cet alias permet parfois des économies
d'écritures, mais il permet surtout de lever des ambiguïtés sur les noms d'attributs (plusieurs relations
qui possèdent le même nom d'attribut). Des exemples de définition d'alias sont proposés dans la partie
présentant des exercices corrigés.
La clause WHERE, optionnelle, spécifie les critères de sélection. La condition logique de niveau tuple
est une expression logique spécifiant les prédicats de restriction ou de jointure à satisfaire par la
réponse. On peut également insérer dans la clause WHERE, une nouvelle instruction SELECT
(requête imbriquée) ce qui permet de travailler sur un ensemble de tuples restreints par cette sélection.
Lorsque ces critères portent sur des fonctions de groupe, on utilise la clause HAVING.
La clause GROUP BY partitionne la relation en groupes. La liste des attributs spécifiés dans cette
clause indique le critère de groupement.
La clause ORDER BY permet de trier les résultats obtenus selon un tri ascendant (ASC) ou
descendant (DESC). On veillera à choisir des colonnes de tri présent dans les attributs du SELECT.
Cette instruction SQL permet d'afficher tous les tuples de la table VOITURE :
Immatriculation Marque Couleur Puissance Prix
4578QS59 Renault Noire 7 20 000
1952LM62 Rover Bleue 5 28 000
3664PN75 Citroën Rouge 6 30 000
3671KH60 Peugeot Verte 6 10 000
4691TR95 Renault Jaune 7 35 000
Remarque : le symbole * dans la clause SELECT signifie qu'on désire récupérer TOUS les
champs de la table.
Cette instruction SQL permet d'afficher le contenu du champ Marque des tuples de la table
VOITURE :
Marque
Renault
Rover
Citroën
Peugeot
Renault
Remarque : la requête ne porte que sur un seul champ, cela équivaut à une projection de la table
VOITURE sur ce champ. On peut ajouter autant d’attributs que l’on désire afficher.
Cette instruction SQL permet d'afficher le contenu du champ Marque des tuples de la table
VOITURE, sans répétition de Marque, c'est-à-dire sans doublon de Marque :
Marque
Renault
Rover
Citroën
Peugeot
b. Les prédicats
Une condition est appelée prédicat en SQL. Un prédicat permet de comparer 2 expressions de
valeurs :
- la première expression contenant des spécifications de colonnes est appelée terme ;
- la seconde expression contenant seulement des spécifications de constantes est appelée
constante.
Il existe une grande diversité de prédicats en SQL, on trouve en effet :
1. un prédicat de comparaison permettant de comparer un terme à une constante à l'aide des
opérateurs suivants :
- = : égal
- <> ou != : différent
- > : plus grand que
- >= : plus grand ou égal
- < : plus petit que
- <= : plus petit ou égal
Ces opérateurs sont valables pour les types NUMBER (NUMBER est un terme englobant les
types INTEGER et FLOAT désignant les nombres, ce type n'est cependant pas disponible
pour tous les SGBD), CHAR, VARCHAR, DATE et valent NULL si un des termes de la
comparaison est NULL.
2. un prédicat d'intervalle BETWEEN permettant de tester si la valeur d'un terme est comprise
entre la valeur de 2 constantes ;
3. un prédicat de comparaison de texte noté LIKE permettant de tester si un terme de type
chaîne de caractères contient une ou plusieurs sous-chaînes (ce prédicat est donc réservé aux
types CHAR et VARCHAR). Le caractère % remplace une chaîne de caractères quelconque
y compris la chaîne vide, le caractère _ remplace n'importe quel caractère unique ;
4. un prédicat de test de nullité qui permet de tester si un terme a une valeur convenue NULL,
signifiant que sa valeur est inconnue ou que le champ n'a pas été renseigné. Pour tester la
nullité, on utilise IS NULL, et la non nullité par IS NOT NULL ;
5. un prédicat d'appartenance noté IN qui permet de tester si la valeur d'un terme appartient à
une liste de valeurs constantes.
c. La clause WHERE
La clause WHERE spécifie une condition de sélection. Une condition de sélection définit un
critère qui, appliqué à un tuple, est vrai, faux ou inconnu (mettant en cause un attribut de valeur
NULL). Cette condition peut inclure des opérateurs booléens (AND, OR, NOT), des conditions
élémentaires et des parenthèses.
Les tableaux ci-après donnent les tables de vérité permettant de calculer les valeurs de vérité d'une
condition de sélection. Seuls les tuples satisfaisant la condition de sélection sont pris en compte
par la requête.
AND Vrai Faux Inconnu
Vrai Vrai Faux Inconnu
Faux Faux Faux Faux
Inconnu Inconnu Faux Inconnu
Base de données 46
Cette instruction SQL permet d’affiche les tuples de la table VOITURE dont la Puissance est
inférieure ou égale à 6 chevaux et dont le prix est supérieur ou égal à 20 000 € :
Immatriculation Marque Couleur Puissance Prix
1952LM62 Rover Bleue 5 28 000
3664PN75 Citroën Rouge 6 30 000
AND : permet de vérifier TOUTES les conditions simultanément.
Cette instruction SQL permet d’affiche les tuples de la table VOITURE dont la Puissance est
inférieure ou égale à 6 chevaux ou dont le prix est supérieur ou égal à 20 000 € :
Immatriculation Marque Couleur Puissance Prix
4578QS59 Renault Noire 7 20 000
1952LM62 Rover Bleue 5 28 000
3664PN75 Citroën Rouge 6 30 000
3671KH60 Peugeot Verte 6 10 000
4691TR95 Renault Jaune 7 35 000
OR : permet de vérifier AU MOINS UNE des conditions.
Cette instruction SQL permet d’affiche les tuples de la table VOITURE dont la Puissance n’est
égale à 6 chevaux :
Immatriculation Marque Couleur Puissance Prix
4578QS59 Renault Noire 7 20 000
1952LM62 Rover Bleue 5 28 000
4691TR95 Renault Jaune 7 35 000
NOT : permet de donner la négation de la condition.
Remarque :
Les opérateurs logiques peuvent être combinés entre eux. Cependant, il faut veiller à respecter un
ordre de priorité. Ainsi, on trouve, du plus prioritaire au moins prioritaire :
- NOT
- AND
- OR
L'emploi de parenthèses est possible pour changer l'ordre d’évaluation ou rendre la lecture plus
facile.
Base de données 47
Prédicats divers :
Cette instruction SQL permet d’afficher les tuples de la table VOITURE dont le Prix est compris
entre 25 000€ et 40 000€ :
Immatriculation Marque Couleur Puissance Prix
1952LM62 Rover Bleue 5 28 000
3664PN75 Citroën Rouge 6 30 000
4691TR95 Renault Jaune 7 35 000
BETWEEN min AND max : permet de récupérer les données dont les valeurs sont comprises
entre min et max (bornes incluses).
Cette instruction SQL permet d’afficher tous les tuples de la table VOITURE dont le Marque
commence par ‘Ren’, dont la couleur est soit noire, bleue ou jaune, et dont le prix n’est pas
inconnu (donc connu) :
Immatriculation Marque Couleur Puissance Prix
4578QS59 Renault Noire 7 20 000
4691TR95 Renault Jaune 7 35 000
Cette requête permet d'afficher le prix maximal parmi les tuples de la table VOITURE.
MAX(Prix)
35 000
Base de données 48
La fonction COUNT
La fonction COUNT comptabilise le nombre de lignes pour lesquelles l'expression est non
NULL. Une * est souvent utilisée avec COUNT pour indiquer le nombre de lignes. Si on ne veut
pas compter plusieurs fois les valeurs identiques d'une même colonne, il faut utiliser le mot-clé
DISTINCT suivi du nom de la colonne (sauf s'il s'agit d'un attribut clé de la relation).
Cette requête permet d'afficher le nombre de tuples vérifiant la condition "Puissance supérieure à
6 chevaux" de la table VOITURE, en ne comptant qu'une seule fois la marque même si elle vérifie
de nouveau la condition (3 tuples comptés, on ne compte qu'une fois la Renault).
COUNT(Marque)
1
Cette requête permet d'afficher le nombre de tuples vérifiant la condition "Puissance supérieure à
6 chevaux" de la table VOITURE, en comptant toutes les lignes (4 tuples comptés).
COUNT(Marque)
2
La fonction SUM
La fonction SUM effectue, pour un ensemble de tuples, la somme des valeurs d'un attribut.
Cette fonction est uniquement utilisable pour le type NUMBER.
Cette requête permet de calculer la somme des prix des VOITURES ayant une Puissance de 6
chevaux.
SUM(Prix)
45 000
La fonction AVG
La fonction AVG calcule, pour un ensemble de tuples, la moyenne arithmétique des valeurs d'un
attribut. Cette fonction est uniquement utilisable pour le type NUMBER. Elle vérifie la formule
suivante : AVG = Somme des valeurs non NULL / nombre de valeurs non NULL.
Cette requête permet de calculer le prix moyen des VOITURES ayant une Puissance de 6
chevaux.
AVG(Prix)
20 000
La fonction VARIANCE
La fonction VARIANCE calcule, pour un ensemble de tuples, la variance des valeurs d'un
attribut. Cette fonction est uniquement utilisable pour le type NUMBER. Elle vérifie la formule
suivante : VARIANCE = Somme des carrés de la différence entre attribut de valeur non NULL et
la moyenne arithétique / nombre d’attributs de valeur non NULL.
Base de données 49
Cette requête permet de calculer la variance des prix des VOITURES ayant une Puissance de 6
chevaux.
VARIANCE(Prix)
100 000 000
La fonction STDDEV
La fonction STDDEV calcule, pour un ensemble de tuples, l’écart type des valeurs d'un attribut.
Cette fonction est uniquement utilisable pour le type NUMBER. Elle vérifie la formule suivante :
STDDEV = racine carrée de la variance.
Cette requête permet de calculer l’écart type des prix des VOITURES ayant une Puissance de 6
chevaux.
STDDEV(Prix)
10 000
f. La clause GROUP BY
La clause GROUP BY permet de partitionner la relation résultat selon les valeurs d'un ou de
plusieurs attributs. Les seuls noms de colonnes (en dehors des fonctions statistiques) qui peuvent
apparaître dans le SELECT sont celles qui figurent dans le GROUP BY.
Cette commande permet de créer des partitions selon la Puissance dans la table VOITURE. On
aura donc, pour notre exemple, 3 partitions correspondant aux puissances 5, 6 et 7 chevaux. La
somme des Prix s'affichera pour chacune de ces partitions.
Puissance SUM(Prix)
5 28 000
6 40 000
7 55 000
g. La clause HAVING
La clause HAVING définit les conditions que les groupes doivent respecter pour être retenus, elle
sélectionne les partitions désirées. Elle ne peut comprendre que des conditions dont le premier
terme est une fonction statistique. La clause HAVING est aux groupes (GROUP BY) ce que la
clause WHERE est aux lignes (SELECT).
Cette commande permet de créer des partitions selon la Puissance dans la table VOITURE.
Elle calculera le prix maximum sur ces partitions. La clause HAVING limite l'affichage aux
partitions contenant au moins 2 éléments (tuples) : COUNT(*)>1 . On aura donc, pour notre
exemple, 2 partitions correspondant aux puissances 6 et 7 chevaux (la partition relative à la
Puissance de 5 chevaux n'a pas été retenue car elle ne contient pas assez d'éléments pour satisfaire
la condition énoncée dans la clause HAVING).
Puissance MAX(Prix)
6 30 000
7 35 000
h. La clause ORDER BY
La clause ORDER BY permet de trier les tuples du résultat final. La clause ORDER BY permet
d'ordonner la relation résultat sur un ou plusieurs attributs, l'ordre pouvant être croissant (grâce au
mot-clé ASC) ou décroissant (grâce au mot-clé DESC), ASC étant l'ordre par défaut.
Remarque : Dans une requête SQL, la clause ORDER BY se situe juste après une clause
WHERE ou après une clause GROUP BY.
Ces 2 requêtes (avec ASC ou sans ASC) sont identiques et permettent d'afficher l'ensemble des
tuples de la table VOITURE triés sur l'attribut Puissance selon un ordre croissant.
Immatriculation Marque Couleur Puissance Prix
1952LM62 Rover Bleue 5 28 000
3664PN75 Citroën Rouge 6 30 000
3671KH60 Peugeot Verte 6 10 000
4578QS59 Renault Noire 7 20 000
4691TR95 Renault Jaune 7 35 000
La clause ORDER BY permet également un tri sur plusieurs attributs : le tri sera effectué
prioritairement sur le premier attribut, puis sur le second et ainsi de suite.
Cette requête permet d'afficher l'ensemble des tuples de la table VOITURE triés sur l'attribut
Puissance selon un ordre décroissant puis sur l'attribut Couleur (ordre alphabétique) selon un
ordre croissant .
Immatriculation Marque Couleur Puissance Prix
4691TR95 Renault Jaune 7 35 000
4578QS59 Renault Noire 7 20 000
3664PN75 Citroën Rouge 6 30 000
3671KH60 Peugeot Verte 6 10 000
1952LM62 Rover Bleue 5 28 000
Cette requête permet d'afficher l'ensemble des tuples de la table VOITURE dont la Puissance est
égale à 5 ou à 7 chevaux.
Immatriculation Marque Couleur Puissance Prix
1952LM62 Rover Bleue 5 28 000
4578QS59 Renault Noire 7 20 000
4691TR95 Renault Jaune 7 35 000
j. La jointure
Le procédé de la jointure en SQL est celui énoncé dans le chapitre Algèbre Relationnelle. La
jointure est formulée dans la clause WHERE
Syntaxe de la primitive SELECT en SQL
SELECT <attributs>
FROM <liste_de_noms_de_relations>
WHERE <expression de jointure>;
Cas de l'équijointure
Cette requête permet de faire la jointure entre la table VOITURE et la table ACHAT ; cette jointure
porte sur le numéro d'immatriculation. Cette requête renverra donc tous les tuples de la table
VOITURE et de la table ACHAT qui ont même numéro d'immatriculation (on n’a pas affiché
numImmatriculation).
Immatriculation numPersonne dateAchat Marque Couleur Puissance Prix
4578QS59 1591259 12/12/2001 Renault Noire 7 20 000
1952LM62 2630662 08/11/1998 Rover Bleue 5 28 000
4691TR95 1120606 05/09/1997 Renault Jaune 7 35 000
Pour les autres types de jointure (non équijointure, autojointure, jointure externe), le principe est
identique, seule l'expression de jointure diffère.
SELECT <attributs>
FROM relation1 NATURAL JOIN relation2;
Cas de la thêta-jointure
SELECT <attributs>
FROM relation1 JOIN relation2 ON
relation1.attrbut1 = relation2.attribut2;
Base de données 52
Cas de la clause AS (c'est-à-dire deux relations identiques qui ont le même attribut)
SELECT <attributs>
FROM relation R1, relation R2
WHERE R1.attribut = R2.attribut;
SELECT *
FROM VOITURE
WHERE Prix > (SELECT AVG(Prix)
FROM VOITURE);
Cette requête permet d'afficher tous les tuples de la table VOITURE dont le prix est supérieur à la
moyenne des prix de tous les tuples de cette même table :
Immatriculation Marque Couleur Puissance Prix
1952LM62 Rover Bleue 5 28 000
3664PN75 Citroën Rouge 6 30 000
4691TR95 Renault Jaune 7 35 000
Remarque : Toute requête de jointure peut se mettre sous forme de requête imbriquée. Mais
l'inverse n'est pas vrai comme l'illustre l'exemple proposé ci-dessus.
Dans une requête imbriquée, il est possible d’ajouter un quantificateur. Il permet de faire une
comparaison entre une ligne et toutes les lignes d’une table retournée par un select imbriqué. Le
ALL correspond à ∀ et le SOME (ou ANY) à ∃.
SELECT *
FROM COMMANDE
WHERE dateCommande > ALL(SELECT dateLivraison
FROM LIVRAISON);
Cette requête permet d'afficher tous les tuples de la table COMMANDE dont la date de commande
est passée après la dernière livraison.
SELECT *
FROM COMMANDE
WHERE dateCommande < SOME(SELECT dateLivraison
FROM LIVRAISON);
Cette requête permet d'afficher tous les tuples de la table COMMANDE dont la date de commande
est passée avant la dernière livraison.
l. Les alias
Les alias concourent à améliorer la lisibilité et la concision d'une requête. Il existe deux types
d'alias : les alias de tables et les alias de champs. Ils peuvent également s'appliquer à une fonction
d'agrégation retournant des données sous forme de colonnes.
La clause AS, affectant un alias à une table ou une colonne, peut être remplacée par un simple
espace blanc.
Les alias de champs peuvent être des chaînes de caractères composées de mots et d'espaces.
Dans ce cas, il faut placer l'alias entre simple guillemet.
Lors de l'affichage des lignes résultantes, les alias de champs se substitueront aux noms de
colonnes. De cette manière, il devient possible d'attribuer des noms de colonnes plus explicites
pour les utilisateurs de la base de données.
Les alias sont particulièrement utiles dans le cadre des jointures et des requêtes imbriquées.
Dans les deux cas, il devient possible de faire appel à des champs de noms identiques en les
distinguant par des préfixes qui sont les alias de table.
Cas de la jointure
2. INSERT
L'opération d'insertion se fait grâce au mot-clé INSERT. Elle permet d'ajouter un ou plusieurs tuples à
une relation.
Syntaxe de la primitive INSERT en SQL
Exemples :
Cette commande permet d'insérer le tuple ('2759QF78', 'BMW', 'Grise', 8, 45 000) dans la table
VOITURE :
Immatriculation Marque Couleur Puissance Prix
4578QS59 Renault Noire 7 20 000
1952LM62 Rover Bleue 5 28 000
3664PN75 Citroën Rouge 6 30 000
3671KH60 Peugeot Verte 6 10 000
4691TR95 Renault Jaune 7 35 000
2759QF78 BMW Grise 8 45 000
Les domaines des valeurs insérées doivent correspondre aux types déclarés.
Cette commande permet d'insérer un nouveau tuple ayant les valeurs '1379FG09' pour
l'Immatriculation, une couleur 'Rouge', et un Prix de 29 500€ dans la table VOITURE.
Immatriculation Marque Couleur Puissance Prix
4578QS59 Renault Noire 7 20 000
1952LM62 Rover Bleue 5 28 000
3664PN75 Citroën Rouge 6 30 000
3671KH60 Peugeot Verte 6 10 000
4691TR95 Renault Jaune 7 35 000
2759QF78 BMW Grise 8 45 000
1379FG09 NULL Rouge NULL 29 500
Les champs autres champs de ce tuple prendront la valeur NULL (ils ne devront pas avoir été déclarés
NOT NULL).
Cette commande permet de créer des tuples dans la table VOITURE_ACHETEES (qui aura été créée
préalablement) initialisés avec les numéros d'immatriculation présents dans la table ACHAT. Les autres
attributs étant initialisés à NULL.
Immatriculation
4578QS59
1952LM62
4691TR95
3. UPDATE
La commande UPDATE permet de mettre à jour un ou plusieurs tuples d'une relation.
Base de données 55
UPDATE <nom_table>
SET <attribut1> = <expression1>, <attribut2> = <expression2>, …
[WHERE <condition>];
La clause WHERE est optionnelle ; cependant sans le WHERE, la mise à jour affectera TOUS les
tuples de la relation.
Exemples :
UPDATE VOITURE
SET Prix = Prix x 1.10;
Cette commande permet d'augmenter le Prix de vente de 10% (on multiplie par le coefficient 1.10) de
tous les tuples de la table VOITURE :
Immatriculation Marque Couleur Puissance Prix
4578QS59 Renault Noire 7 22 000
1952LM62 Rover Bleue 5 30 800
3664PN75 Citroën Rouge 6 33 000
3671KH60 Peugeot Verte 6 11 000
4691TR95 Renault Jaune 7 38 500
2759QF78 BMW Grise 8 49 500
1379FG09 NULL Rouge NULL 32 450
Ceci permet de modifier rapidement une colonne pour la globalité d’une table.
UPDATE VOITURE
SET Prix = Prix x 1.10
WHERE Marque = ‘Renault’;
Cette commande permet d'augmenter le Prix de vente de 10% uniquement sur les voitures de Marque
Renault dans la table VOITURE.
Immatriculation Marque Couleur Puissance Prix
4578QS59 Renault Noire 7 22 000
1952LM62 Rover Bleue 5 28 000
3664PN75 Citroën Rouge 6 30 000
3671KH60 Peugeot Verte 6 10 000
4691TR95 Renault Jaune 7 38 500
2759QF78 BMW Grise 8 45 000
1379FG09 NULL Rouge NULL 29 500
Ceci permet de modifier rapidement une colonne pour une partie de la table.
UPDATE VOITURE
SET Prix = Prix x 1.10
WHERE Marque = ‘Renault’
AND Prix > SELECT AVG(Prix) FROM VOITURE);
Cette commande permet d'augmenter le Prix de vente de 10% uniquement sur les voitures de Marque
Renault dont le prix est supérieur au prix moyen de toutes les voitures de la table VOITURE.
Base de données 56
4. DELETE
La suppression de tuples se fait grâce à la commande DELETE. La suppression peut concerner tous
les tuples d'une relation ou un sous-ensemble de tuples qui vérifie une condition de sélection. Il faut
noter que DELETE opère sur le contenu d'une relation, c'est-à-dire que le schéma d'une relation
persiste après suppression de tous les tuples de la relation.
Syntaxe de la primitive DELETE en SQL
La clause WHERE est optionnelle ; cependant sans le WHERE, la mise à jour affectera TOUS les
tuples de la relation.
Exemples :
Cette commande permet de supprimer tous les tuples de la table VOITURE. Le schéma de la table
persiste cependant.
Immatriculation Marque Couleur Puissance Prix
Ceci permet de supprimer rapidement tous les tuples d’une table.
Cette commande permet de supprimer toutes les voitures de Marque Renault de la table VOITURE.
Immatriculation Marque Couleur Puissance Prix
1952LM62 Rover Bleue 5 28 000
3664PN75 Citroën Rouge 6 30 000
3671KH60 Peugeot Verte 6 10 000
2759QF78 BMW Grise 8 45 000
1379FG09 NULL Rouge NULL 29 500
Ceci permet de modifier rapidement une partie des tuples de la table.
Cette commande permet de supprimer toutes les voitures de Marque Renault dont le prix est supérieur
au prix moyen de toutes les voitures de la table VOITURE.
Base de données 57
1. La commande GRANT
La commande GRANT permet d'autoriser un accès aux données de la base soit total, soit à des degrés
limités. Ainsi, il est possible, par exemple, d'autoriser la consultation de certaines tables sans
possibilité de les modifier.
Cette instruction SQL permet à l'administrateur de la base de donner à Martin tous les droits sur la
table VOITURE, il lui accorde également l'autorisation de transférer ces privilèges.
Cette commande permet de passer des droits de consultation et de mise à jour de la table
VOITURE et de la table ACHAT à l'utilisateur Smith.
Cette commande permet de passer l'ensemble des droits d'accès aux utilisateurs Smith,
Vandenbrouck et Dubois uniquement sur les colonnes Immatriculation et Prix de la table
VOITURE.
GRANT INSERT
ON PERSONNE
TO PUBLIC;
Cette commande attribue le droit d'insérer de nouveaux enregistrements dans la table PERSONNE
à tous ceux qui, dans la société, disposent d'une identification pour se connecter sur la BD.
2. La commande REVOKE
La commande REVOKE permet de retirer l'accès, c'est la commande inverse de GRANT.
Base de données 59
Exemples :
Cette commande supprime les droits de consultation et de mise à jour de la table VOITURE et de la
table ACHAT qui avait été accordés à l'utilisateur Smith.
Cette commande retire tous les privilèges accordés sur la table VOITURE à Martin.
3. Le contrôle d'intégrité
Les commandes COMMIT et ROLLBACK constituent des contrôles (cf. le chapitre sur les
transactions) nécessaires à la préservation de l'intégrité de la base.
Des systèmes multi-utilisateurs disponibles dans le commerce emploient des contrôles supplémentaires
comme par exemple la commande LOCK pour empêcher les valeurs de changer pendant qu'un
utilisateur examine ou travaille sur ces valeurs (nous étudierons plus en détails ces notions dans le
chapitre sur les transactions).
4. La commande COMMIT
La commande COMMIT permet à l'utilisateur de fixer le moment où les modifications en cours
affecteront la base de données. Dans ce cadre, on utilise le concept de transaction.
La transaction est une suite d'opérations telle que chaque opération de cette suite est nécessaire pour
atteindre un résultat unitaire.
C'est la raison pour laquelle SQL propose à l'utilisateur de n'enregistrer les modifications dans la base
qu'au moment où la transaction est achevée grâce à la commande COMMIT.
Une transaction (ou une partie de transaction) qui n'a pas encore été enregistrée définitivement n'est
visible que pour l'utilisateur qui l'introduit. Elle n'affecte pas la base tant que l'instruction n'est pas
exécutée.
Avant l'exécution de l'instruction COMMIT, il est possible de restaurer la base par ROLLBACK,
c'est-à-dire d'éliminer les modifications récentes. Après l'enregistrement définitif d'une transaction par
COMMIT, il n'est plus possible de restaurer l'état antérieur par ROLLBACK. S'il apparaît après coup
qu'une transaction doive être modifiée ou corrigée, on ne pourra effecteur cette modification qu'au
moyen d'une autre instruction SQL comme UPDATE ou DELETE.
5. La commande ROLLBACK
La commande ROLLBACK permet à l'utilisateur de ne pas valider les dernières modifications en
cours dans la base de données.
Par exemple, si au cours du déroulement d'une transaction, l'utilisateur fait une erreur ou si, pour une
certaine raison, une transaction ne peut pas être achevée, l'utilisateur peut supprimer les modifications
Base de données 60
afin d'éviter des incohérences dans la base grâce à la commande ROLLBACK. Cette commande
élimine tous les changements depuis la dernière validation.
Dans le cas d'une défaillance du système, l'intégrité de la base peut être préservée par une option
ROLLBACK automatique qui élimine les transactions inachevées et empêche donc qu'elles soient
introduites dans la base.
6. La commande SAVEPOINT
Une transaction étant une séquence de séquence de commandes SQL considérée comme unitaire,
indivisible, il peut être nécessaire de pouvoir revenir en arrière, à n’importe quel endroit dans la
transaction courante.
Pour cela, il suffit de réaliser des points de sauvegarde grâce à la commande SAVEPOINT <nom> à
l’intérieur d’une transaction pour situer un point éventuel de retour vers l’état de la base de données.
Le retour en arrière s’effectue grâce à la commande ROLLBACK WORK TO SAVEPOINT <nom>.
Exemples :
SELECT *
FROM VOITURES_CHERES;
On peut accéder grâce à cette vue à toutes les voitures dont le Prix est supérieur à 15 000 €.
1. Création du séquence
Syntaxe de la commande CREATE SEQUENCE en SQL
Cette commande SQL permet de créer une séquence SEQUENCE_VOITURE commençant à la valeur
5 avec un pas d’incrémentation de 3. La séquence obtenue est alors : 5, 8, 11, 14, 17, 20, …
Cette commande SQL permet de créer une séquence SEQUENCE_VOITURE commençant à la valeur
5 avec un pas d’incrémentation de 3, avec pour valeur maximale 30. La séquence obtenue est alors : 5,
8, 11, 14, 17, 20, 23, 26, 29.
Cette commande SQL (avec ou sans l’option NOMAXVALUE NOMINVALUE) permet de créer une
séquence SEQUENCE_VOITURE commençant à la valeur 5 avec un pas d’incrémentation de 3 sans
limite. La séquence obtenue est alors : 5, 8, 11, 14, 17, 20, …
Cette commande SQL permet de créer une séquence SEQUENCE_VOITURE commençant à la valeur
1 avec un pas d’incrémentation de 1, avec pour valeur maximale 10 et pour valeur minimale -10. La
séquence est cyclique, si bien que l’on a la séquence : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -10, -9, -8, -7, -6, …
Cette commande SQL permet de créer une séquence SEQUENCE_VOITURE en stockant les 100
premières valeurs dans la mémoire cache. Par défaut, la valeur est 20.
Base de données 63
2. Interroger la séquence
L'interrogation d'une séquence se fait par l'utilisation des "pseudo-colonnes" CURRVAL et
NEXTVAL. On parle de pseudo-colonne car cela se manipule un peu comme une colonne de table,
mais ce n'est pas une colonne de table.
- La pseudo-colonne CURRVAL retourne la valeur courante de la séquence.
- La pseudo-colonne NEXTVAL incrémente la séquence et retourne la nouvelle valeur.
Lors de la première utilisation d’un séquence, il faut utiliser NEXTVAL pour l’initialiser. Ensuite,
CURRVAL permet d’obtenir la valeur courante de la séquence.
Exemple :
Cet exemple ne gère pas le contrôle d'unicité de la valeur que l'on va insérer, mais si le champ n'est
alimenté QUE par l'utilisation de la séquence qui lui est dédiée, et si cette séquence n'est pas
paramétrée pour reboucler, il n'y a pas de raison qu'une erreur de clé en double surgisse...
Base de données 64
1. L'intro de l'intro
PL/SQL est un langage qui intègre SQL et permet de programmer de manière procédurale.
Globalement, avec PL/SQL on aura à notre disposition un vrai langage de programmation moins
intuitif mais aussi plus puissant que le SQL. Les 2 langages sont éminemment complémentaires.
Les principaux avantages / inconvénients sont les suivants :
- ne dispense pas de connaître le SQL ;
- permet le traitement par bloc de SQL et donc optimise le trafic réseau ;
- l'utilisation de variable de stockage et de type simple et structuré dynamique (%TYPE,
%ROWTYPE, …) ;
- des traitements plus complexes, notamment pour la gestion des cas particuliers et des erreurs
(traitement des exceptions) ;
- un paramétrage et la création d'ordres SQL dynamiques.
Le PL/SQL peut être utilisé sous 3 formes :
- un bloc de code, exécuté comme une commande SQL, via un interpréteur standard
- un fichier de commande PL/SQL
- un programme stocké (procédure, fonction, package ou trigger)
BEGIN
NULL;
END;
Le bloc précédent est le plus petit bloc PL/SQL au monde. Le bloc ne peut pas être vide et doit
contenir au moins une instruction…
Syntaxe de bloc en PL/SQL (avec des exceptions)
Afin de pouvoir utiliser une exception, il faut tout d’abord déclarer une variable d’exception dans la
partie DECLARE (ex : DECLARE erreur EXCEPTION;).
Ensuite, dans la partie entre le BEGIN et le END, pour appeler une exception et stopper le bloc
PL/SQL, on utilise la commande RAISE nom_exception (ex : RAISE erreur;). Cette commande
stoppe le bloc PL/SQL et va dans la partie EXCEPTION.
Dans cette partie, pour afficher un message d’erreur, on utilise la commande suivante :
WHEN nom_exception THEN
RAISE_APPLICATION_ERROR ( numero_erreur , message );
− numero_erreur : représente le numéro de l’erreur utilisateur. Ce numéro doit être compris entre
–20000 et –20999.
− message : chaîne de caractères d’une longueur maximale de 2048 octets qui contient le message
associé à l’erreur.
Les exceptions prédéfinies sont :
− NO_DATA_FOUND : cas où l’on n’a aucune donnée à la sortie d’un SELECT.
− TO_MANY_ROWS : cas où l’on a trop de données à la sortie d’un SELECT.
− VALUE_ERROR : cas où l’on a une erreur de valeur.
− ZERO_DIVIDE : cas d’une division par zéro.
− INVALIDE_NUMBER : cas d’un nombre invalide.
4. Procédure PL/SQL
Une procédure est simplement un programme PL/SQL nommé, compilé et stocké dans la base.
Syntaxe de procédure en PL/SQL (avec des exceptions)
Ce code est une commande SQL, qui crée la procédure PL/SQL, et donc compile et stocke dans la base
le bloc PL/SQL compris entre le BEGIN et le END, en le référençant par ‘nom_de_procédure’. Et
pour exécuter cette procédure de manière autonome, on utilise la commande : ‘EXECUTE
nom_de_procédure’. Les paramètres d’entrée doivent être déclarés (nom et type).
Cette commande permet de créer une procédure nommée Client, dont les paramètres d’entrée sont des
chaînes de caractères nom et ville. La procédure permet d’insérer un nouveau tuple dans la table
CLIENTS de valeurs SEQUENCE_NUM_CLIENT.NEXTVAL (pour créer automatiquement une
nouvelle valeur de clé primaire), nom et ville.
5. Fonctions PL/SQL
Une fonction est une procédure retournant une valeur.
Base de données 66
Ce code est une commande SQL, qui crée la fonction PL/SQL, et donc compile et stocke dans la base
le bloc PL/SQL compris entre le BEGIN et le END, en le référençant par ‘nom_de_fonction’. La
valeur retournée en sortie correspond à la variable_de_sortie dont le type est type_de_sortie. Les
paramètres d’entrée doivent être déclarés (nom et type).
Cette commande permet de créer une fonction nommée solde, dont le paramètre d’entrée est le numéro
de client. La fonction permet de retourner en sortie, dans la variable réelle le_solde, le solde du compte
du client identifié par numero. Pour appeler cette fonction et utiliser son résultat au sein d’un ordre
SQL, il suffit d’exécuter la commande suivante : ‘SELECT solde(1000) FROM DUAL’.
6. Trigger
Les déclencheurs (Triggers) sont des procédures stockées appartenant à une table précise et
s'exécutant lorsqu'une action spécifique se produit sur la table concernée. Le déclenchement d'une telle
procédure s'effectue subséquemment à une instruction de manipulation de données (DML) comme
INSERT, DELETE ou UPDATE. Il existe donc trois types de déclencheurs : sur insertion, sur mise à
jour et sur suppression.
Une table peut comporter plusieurs déclencheurs d'un type donné, à condition que chacun possède
un nom différent. Cependant, un déclencheur donné ne peut être assigné qu'à une seule et unique table
tout en s'appliquant à la fois, à l'insertion, la mise à jour et la suppression d'enregistrements sur la table
en question. Une table ne peut posséder qu'un seul déclencheur INSTEAD OF d'un type donné.
Les déclencheurs se produisent soit après (AFTER), soit avant (BEFORE) soit à la place
(INSTEAD OF) d'une action DML :
- Un déclencheur sur INSERT s'exécute à chaque opération d'insertion lancée par l'utilisateur ou
par un programme. Lors d'une insertion, l'enregistrement est inséré à la fois dans la table cible
est dans une table temporaire dénommée inserted. Une telle table peut permettre de vérifier la
cohérence des enregistrements.
- Un déclencheur sur DELETE s'exécute à chaque opération de suppression lancée par l'utilisateur
ou un programme. Lors d'une suppression, l'enregistrement est supprimé physiquement de la
table cible et l'insère dans une table temporaire dénommée deleted. Cela peut permettre de
récupérer l'enregistrement supprimé.
- Un déclencheur sur UPDATE s'exécute à chaque opération de mise à jour lancée par l'utilisateur
ou par un programme. Lors d'une mise à jour, l'ancien enregistrement est supprimé et inséré
dans la table temporaire deleted, tandis que le nouveau est inséré à la fois dans la table cible
et dans la table inserted.
Base de données 67
Tous les déclencheurs (ALL) ou certains peuvent être activés (ENABLE) ou désactivés (DISABLE)
au moyen de l'instruction ALTER TABLE.
Cette commande SQL permet de créer deux tables puis crée un déclencheur qui insère un champ log à
l'intérieur de DELETE_LOG, pour chaque ligne supprimée dans la table TABLE_1.
Cette commande SQL permet de créer deux tables TABLE_1 et TABLE_2 puis crée un déclencheur qui
insère un enregistrement à l'intérieur de TABLE_2 lorsqu’une opération d'insertion s'est accomplie dans
TABLE_1. Le déclencheur vérifie si le nouvel enregistrement possède un premier composant inférieur
ou égal à 10 et si c'est le cas, inverse les enregistrements à l'intérieur de TABLE_2.
Les variables spéciales NEW et OLD sont disponibles pour se référer respectivement à des nouveaux
ou d'anciens enregistrements. Les deux points (:) précédent NEW et OLD dans VALUES sont dans ce
cas obligatoires, par contre dans la clause conditionnelle WHEN, ils doivent être omis.
CREATE TABLE EMP ( EmpNo NUMBER, Enom CHAR(20), Job CHAR(20), Sal NUMBER );
CREATE TABLE SALGRADE ( jobclass CHAR(20), minSal NUMBER, maxSal NUMBER );
Cette commande SQL permet de créer deux tables EMP (employés) et SALGRADE (grades de
salaires), puis crée un déclencheur pour vérifier, avant une insertion ou modification de sal et job dans
la table EMP, que le nouveau salaire soit valide (c'est-à-dire que le nouveau salaire ne soit pas inférieur
à minSal et ne soit pas supérieur à maxSal) pour le nouvel emploi.
Base de données 69
X. CURSEURS
Les curseurs sont des pointeurs sur une zone mémoire pour les données extraites de la base. Il existe des
curseurs implicites et explicites. Oracle ouvre toujours un curseur implicite pour traiter une instruction
SQL, celui-ci ne se rapporte qu’à la dernière instruction SQL exécutée et il se nomme « SQL ». Le curseur
contient des attributs (%NOTFOUND, %FOUND, %ROWCOUNT) qui fournissent des informations sur
l’exécution des instructions INSERT, UPDATE, DELETE, SELECT INTO. Un curseur implicite pour
une instruction SELECT INTO ne peut gérer qu’une seule ligne. Le curseur explicite quant à lui place le
résultat d’une requête multi-lignes dans un tampon mémoire et libère les lignes les unes après les autres lors
du traitement.
Le curseur se définit dans la partie déclarative du bloc PL/SQL (la requête n’est pas exécutée à ce moment-
là). Dans cette déclaration, il est possible de donner une clause FOR UPDATE OF nom_colonne(s) qui
permet de verrouiller les lignes sélectionnées (aucun autre utilisateur ne peut mettre à jour tant que le verrou
n’est pas retiré). La commande OPEN nom_curseur exécute la requête et place le curseur en mémoire, elle
ne retourne aucun résultat. L’instruction FETCH nom_curseur INTO variable extrait la ligne courante du
curseur, la place dans une variable et fait avancer le curseur à la ligne suivante. Pour parcourir toutes les
lignes du curseur, il faut utiliser une boucle LOOP. La clause CURRENT OF nom_curseur est utilisée
dans le WHERE d’une commande UPDATE pour modifier la ligne courante (si un FOR UPDATE a été
utilisé préalablement). L’arrêt de la boucle est obtenu grâce à nom_curseur%NOTFOUND qui retourne
false s’il ne reste plus de lignes. Pour libérer l’espace mémoire, il faut fermer explicitement le curseur en
utilisant CLOSE nom_curseur.
Un curseur peut accepter des paramètres en entrée, ils servent à passer des informations au curseur et sont
généralement utilisés dans un WHERE pour limiter la requête. Les paramètres ont un type associé qui ne
peut pas avoir d’indication de longueur. Ils sont passés lors de la commande OPEN.
Syntaxe de la commande DECLARE CURSOR en SQL
Il est également possible de passer des paramètres à un curseur. Suite au DECLARE, on trouve la
déclaration des variables utiles au curseur en les définissant par nom table.attribut%TYPE.
La commande SQL crée un curseur dont les paramètres d’entrée sont le nom et le salaire d’un employé. La
structure de sélection permet de récupérer la liste des employés (numéro, nom, métier) et de leur salaire.
Dans la structure BEGIN…END, on retrouve l’opération d’ouverture du curseur suivi de la commande
FETCH…INTO… qui permet d’extraire les différentes lignes des tuples renvoyé par la structure de
sélection afin de les sauvegarder dans les variables employe et salaire définies dans la déclaration du
Base de données 70
curseur. L'attribut Oracle %NOTFOUND retourne FALSE si la dernière instruction FETCH renvoie un
enregistrement ou TRUE en cas d'échec. Suite à la fin de son utilisation, le curseur peut être fermé afin de
ne plus consommer de ressources.
1. Fonctions arithmétiques
- ABS(nb) : Renvoie la valeur absolue de nb.
- CEIL(nb) : Renvoie le plus petit entier supérieur ou égal à nb.
- COS(n) : Renvoie le cosinus de n, n étant un angle exprimé en radians.
- COSH(n) : Renvoie le cosinus hyperbolique de n.
- EXP(n) : Renvoie e puissance n.
- FLOOR(nb) : Renvoie le plus grand entier inférieur ou égal à nb.
- LN(n) : Renvoie le logarithme népérien de n qui doit être un entier strictement positif.
- LOG(m,n) : Renvoie le logarithme en base m de n. m doit être un entier strictement supérieur à 1,
et n un entier strictement positif.
- MOD(m,n) : Renvoie le reste de la division entière de m par n, si n vaut 0 alors renvoie m.
Attention, utilisée avec au moins un de ses arguments négatifs, cette fonction donne des résultats
qui peuvent être différents d'un modulo classique. Cette fonction ne donne pas toujours un résultat
dont le signe du diviseur.
- POWER(m,n) : Renvoie m puissance n, m et n peuvent être des nombres quelconques entiers ou
réels mais si m est négatif n doit être un entier.
- ROUND(n[,m]) : Si m est positif, renvoie n arrondi (et non pas tronqué) à m chiffres après la
virgule. Si m est négatif, renvoie n arrondi à m chiffres avant la virgule. m doit être un entier et il
vaut 0 par défaut.
- SIGN(nb) : Renvoie -1 si nb est négatif, 0 si nb est nul, 1 si nb est positif.
- SIN(n) : Renvoie le sinus de n, n étant un angle exprimé en radians.
- SINH(n) : Renvoie le sinus hyperbolique de n.
- SQRT(nb) : Renvoie la racine carrée de nb qui doit être un entier positif ou nul.
- TAN(n) : Renvoie la tangente de n, n étant un angle exprimé en radians.
- TANH(n) : Renvoie la tangente hyperbolique de n.
- TRUNC(n[,m]) : Si m est positif, renvoie n arrondi tronqué à m chiffres après la virgule. Si m est
négatif, renvoie n tronqué à m chiffres avant la virgule. m doit être un entier et il vaut 0 par défaut.
Cette instruction SQL permet d’afficher le nom et le salaire journalier, arrondi à l’entier le plus
proche, de chaque employé de la table EMP.
Cette instruction SQL permet d’afficher le nom des employés de la table EMP en majuscule.
SELECT NEXT_DAY(embauche,’MONDAY’)
FROM EMP;
Base de données 72
Cette instruction SQL permet d’afficher la date du lundi suivant l’embauche de chaque employé
de la table EMP.
SELECT ROUND(embauche,’Y’)
FROM EMP;
Cette instruction SQL permet d’afficher la date d’embauche de chaque employé de la table EMP
arrondie à l’année.
SELECT ROUND(SYSDATE-embauche)
FROM EMP;
Cette instruction SQL permet d’afficher le nombre de jours depuis l’embauche de chaque
employé de la table EMP.
4. Fonctions de conversion
- ASCII(chaîne) : Renvoie le nombre correspondant au code ascii du premier caractère de chaine.
- CHR(nombre) : Renvoie le caractère dont nombre est le code ascii.
- TO_CHAR(nombre,format) : Renvoie la chaîne de caractères en obtenue en convertissant nombre
en fonction de format. Format est une chaîne de caractères pouvant contenir les caractères
suivants :
o 9 : représente un chiffre (non représenté si non significatif)
o 0 : représente un chiffre (représenté même si non significatif)
o . : point décimal apparent
o V : définit la position du point décimal non apparent
o , : une virgule apparaîtra à cet endroit
o $ : un $ précédera le premier chiffre significatif
o B : le nombre sera représenté par des blancs s'il vaut 0
o EEEE : le nombre sera représenté avec un exposant (le spécifier avant MI ou PR)
o MI : le signe négatif sera à droite
o PR : un nombre négatif sera entre <>
- TO_CHAR(date,format) : Renvoie conversion d'une date en chaîne de caractères. Le format
indique quelle partie de la date doit apparaître, c'est une combinaison des codes suivants :
Les formats suivants permettent d'obtenir des dates en lettres (en anglais) :
o syear ou year : année en toutes lettres
o month : nom du mois
o mon : nom du mois abrégé sur 3 lettres
o day : nom du jour
o dy : nom du jour abrégé sur 3 lettres
o am ou pm : indication am ou pm
o bc ou ad : indication avant ou après Jésus Christ
Les suffixes suivants modifient la présentation du nombre auquel ils sont accolés :
o th : ajout du suffixe ordinat st, nd, rd, th
o sp : nombre en toutes lettres
Tout caractère spécial inséré dans le format sera reproduit tel quel dans la chaîne de caractères
résultat.
- TO_DATE(chaîne,format) : Permet de convertir une chaîne de caractères en donnée de type date.
Le format est identique à celui de la fonction TO_CHAR.
- TO_NUMBER(chaîne) : Convertit chaîne en sa valeur numérique.
Remarque : On peut également insérer dans le format une chaîne de caractères quelconque, à condition
de la placer entre guillemets "".
Cette instruction SQL permet d’afficher les dates d’embauche de chaque employé de la table
EMP sous le format jour/mois/année heure:minute:seconde.
SELECT nom
FROM EMP
WHERE SOUNDEX(nom)=SOUNDEX(‘DUPONT’);
Cette instruction SQL permet d’afficher la liste de tous les employés de la table EMP dont le nom
ressemble à ‘DUPONT’.
SELECT LTRIM(nom,‘LE’)
FROM EMP;
Cette instruction SQL permet d’afficher la liste de tous les employés de la table EMP en ayant
supprimé tous les ‘L’ et les ‘E’ en tête des noms.
SELECT TRANSLATE(nom,‘AM’,‘**’)
FROM EMP;
Cette instruction SQL permet d’afficher la liste de tous les employés de la table EMP en ayant
remplacé les ‘A’ et les ‘M’ par des ‘*’ dans les noms.
SELECT TO_CHAR(salaire,‘<MATH>99900.00’)
FROM EMP;
Cette instruction SQL permet d’afficher les salaires de chaque employé de la table EMP avec un
$ en tête et au moins trois chiffres (dont deux décimales).
Base de données 74
5. Autres fonctions
- GREATEST(expr1,expr2,…) : Renvoie la plus grande des valeurs expr1, expr2,.... Toutes les
expressions sont converties au format de expr1 avant comparaison.
- LEAST(expr1,expr2,…) : Renvoie la plus petite des valeurs expr1, expr2,.... Toutes les
expressions sont converties au format de expr1 avant comparaison.
- NVL(expr1,expr2) : Prend la valeur expr1, sauf si expr1 est NULL auquel cas NVL prend la
valeur expr2.
Une valeur NULL en SQL est une valeur non définie. Lorsque l'un des termes d'une expression a
la valeur NULL, l'expression entière prend la valeur NULL. D'autre part, un prédicat comportant
une comparaison avec une expression ayant la valeur NULL prendra toujours la valeur faux. La
fonction NVL permet de remplacer une valeur NULL par une valeur significative.
- DECODE(crit,val_1,res_1[,val_2,res_2…],def) : Cette fonction permet de choisir une valeur
parmi une liste d'expressions, en fonction de la valeur prise par une expression servant de critère
de sélection.
Le résultat récupéré est :
o res_1 si l'expression crit a la valeur val_1
o res_2 si l'expression crit a la valeur val_2
o def (la valeur par défaut) si l'expression crit n'est égale à aucune des expressions val_1,
val_2,...,.
Les expressions résultats res_1, res_2, ..., def peuvent être de types différents : caractère et
numérique, ou caractère et date (le résultat est du type de la première expression rencontré dans le
DECODE). La fonction DECODE permet également de mélanger dans une colonne résultat des
informations venant de plusieurs colonnes d'une même table.
Cette instruction SQL permet d’afficher le salaire, la commission et le total des gains de chaque
employé de la table EMP.
Cette instruction SQL permet d’afficher la liste des employés de la table EMP avec pour chacun
d'eux sa catégorie (président = 1, directeur = 2, autre = 3).
SELECT DECODE(Detpno,10,fonction,nom)
FROM EMP;
Cette instruction SQL permet d’afficher la liste des employés de la table EMP en les identifiant
par leur fonction dans le département 10 et par leur nom dans les autres départements.