cours SQL2
description
Transcript of cours SQL2
1
Conception des
Bases de Données
2
Chapitre 8
SQL
(Structured Query
Language)
3
LDD
Language de Définition des Données (1/29)
Permet la définition et la mise à jour du schéma
relationnel de la base de données (mode
administration).
Il est composé des ordres suivants :
CREATE TABLE
DROP TABLE
ALTER TABLE
CREATE INDEX
DROP INDEX
CREATE VIEW
DROP VIEW
4
LDD (2/29)
Création des tables
Syntaxe simple :
CREATE TABLE nom_table (
nom_colonne_1 type_colonne_1,
nom_colonne_2 type_colonne_2,
…
nom_colonne_n type_colonne_n
);
NB: l’emploi des majuscules et minuscules est indifférent sauf pour le nom des tables.
5
LDD (3/29)
Création des tables
Les principaux types de données utilisables :
Char(n) Chaîne de caractères de longueur fixe = n (n=255)
Varchar2(n) Chaîne de caractères de longueur variable
Number Entier ou réel
Number (p) Entier (d’au plus p chiffres)
Number(p,d) Décimal sur p positions en tout
(séparateur décimal Compris), dont d chiffres décimaux
Date le format dépend de la configuration d'Oracle. Le plus
souvent c'est jj/mm/aaaa
Long Chaîne longue ; restriction : par table, pas plus d’une
colonne de type long
6
LDD (4/29)
Création des tables
Autres propriétés
NOT NULL : Indique qu'on est obligé de
mettre une valeur dans la colonne
UNIQUE : Indique que les valeurs dans la
colonne doivent être toutes différentes
(comme pour les clés, sauf que ce n'est pas
une clé)
DEFAULT : Permet d'indiquer une valeur
par défaut à la création d'une nouvelle ligne
7
LDD (5/29)
Création des tables
Exemple1:
CREATE TABLE employe
( empno NUMBER(8) NOT NULL,
nom VARCHAR2(20),
fonction VARCHAR2 (10),
sal NUMBER (8,2),
code_service CHAR(3),
date_embauche DATE ) ;
8
LDD (6/29)
Création des tables
Exemple2:
CREATE TABLE compte
( num_cpte NUMBER(11) NOT NULL,
type_cpt VARCHAR2(5) DEFAULT "chèque",
solde NUMBER(10, 2) DEFAULT 0, … );
9
LDD (7/29)
Création des tables
Les contraintes d’intégrité (1/4)
Une contrainte d'intégrité est une règle qui permet d'assurer la validité (cohérence) des données stockées dans une base.
Le SGBD contrôle les contraintes d'intégrité à chaque modification dans les tables (saisies, modification ou suppression).
Les contraintes de colonne s'écrivent tout simplement après la colonne à laquelle elles se rapportent.
10
LDD (8/29)
Création des tables
Les contraintes d’intégrité (2/4)
Attention, on ne met pas de virgule entre la définition de la colonne et celle de la contrainte.
Les différentes contraintes que l'on peut définir sont :
non nullité (obligation) : NOT NULL La colonne ne peut pas contenir de valeurs NULL.
unicité : UNIQUE Toutes les valeurs de la (des) colonne(s) doivent être différentes ou NULL
11
LDD (9/29)
Création des tables
Les contraintes d’intégrité (3/4)
clé primaire : PRIMARY KEY Chaque ligne de la
table doit avoir une valeur différente pour la ou les colonnes qui font partie de la clé primaire. Les valeurs NULL sont rejetées.
primary key = unique + not null
valeur par défaut : DEFAULT : Permet de spécifier une valeur par défaut à la colonne (dans le cas où aucune valeur n'est explicitement donnée)
12
LDD (10/29)
Création des tables
Les contraintes d’intégrité (4/4)
intégrité de domaine : CHECK : Permet de spécifier les valeurs acceptables pour une colonne.
intégrité référentielle (clé étrangère) : FOREIGN KEY Cette colonne fait référence à une colonne clé d'une autre table.
13
LDD (11/29)
Création des tables
Exemple de contrainte d’obligation NOT NULL
Cette contrainte permet de rendre obligatoire la
saisie d'une colonne.
CREATE TABLE PERSONNE
(NomPers Varchar2(30) NOT NULL,
PrénomPers Varchar2(30) );
Il faut obligatoirement que le nom ait une
valeur.
14
LDD (12/29)
Création des tables
Exemple de Contrainte d'unicité : UNIQUE
Cette contrainte permet de contrôler que chaque ligne a
une valeur unique pour la colonne ou l'ensemble de colonnes uniques (pas de doublons)
Sur une seule colonne
CREATE TABLE PERSONNE
(…
Téléphone CHAR(10) UNIQUE
);
15
LDD (13/29)
Création des tables
Sur plusieurs colonnes
CREATE TABLE PERSONNE
( NomPers Varchar2(30) NOT NULL,
PrénomPers Varchar2(30),
UNIQUE (NomPers, PrénomPers) );
Une telle contrainte indique qu'on ne pourra pas
avoir deux personnes ayant le même nom et le
même prénom.
16
LDD (14/29)
Création des tables
Exemple de Contrainte de clé primaire (1/3)
La contrainte de clé primaire permet d'indiquer que la ou
les colonnes sont uniques et ne peuvent pas avoir de
valeur nulle. On peut dire que :
Si la table possède une clé composée d'une seule
colonne, alors il est possible de l'indiquer juste après la
colonne clé.
CREATE TABLE PERSONNE
(idPers PRIMARY KEY, …);
17
LDD (15/29)
Création des tables
Exemple de Contrainte de clé primaire (2/3)
Si la table a une clé compose de plusieurs colonnes, alors il est impossible d'indiquer PRIMARY KEY au niveau des colonnes.
CREATE TABLE PERSONNE
(NomPers Varchar2(30) PRIMARY KEY,
PrénomPers Varchar2(30) PRIMARY KEY, …);
18
LDD (16/29)
Création des tables
Exemple de Contrainte de clé primaire (3/3)
On doit déclarer la clé à part, après la
déclaration des colonnes.
CREATE TABLE PERSONNE
(NomPers Varchar2(30),
PrénomPers Varchar2(30),
PRIMARY KEY (NomPers, PrénomPers) );
19
LDD (17/29)
Création des tables
Exemple de contrainte DEFAULT CREATE TABLE PERSONNE
(idPers PRIMARY KEY,
NomPers Varchar2(30) NOT NULL,
PrénomPers Varchar2(30) DEFAULT 'prénom
inconnu',
DateNaiss Date DEFAULT CURRENT DATE); Ainsi, si on insère la personne 100, Ben Amor, alors les
valeurs de ses champs seront : 100, ‘Ben Amor', 'prénom inconnu', ‘10/12/11'
20
LDD (18/29)
Création des tables
Exemple de Contrainte de domaine : CHECK (1/2)
La définition des types de données pour chaque colonne définit déjà un domaine pour les valeurs. On peut encore restreindre les domaines grâce à la clause CHECK.
Attention, cette contrainte est très "coûteuse" en temps.
Syntaxe : après le mot clé CHECK, on indique entre parenthèses le critère à vérifier.
21
LDD (19/29)
Création des tables
Exemple de Contrainte de domaine : CHECK (1/2)
CREATE TABLE personne
( idpers Number PRIMARY KEY,
NomPers Varchar2(30) NOT NULL,
PrenomPers Varchar2(30) DEFAULT 'prénom inconnu',
age Number CHECK (age >= 0 AND age < 130),
etat_civil Varchar2(20) CHECK (etat_civil IN ('marié(e)',
célibataire', 'veuf(ve)', 'divorcé(e)') );
22
LDD (20/29)
Création des tables
REMARQUES
Il est possible de donner un nom à chaque contrainte (sinon le système en donne un par défaut).
Il suffit de faire précéder la contrainte par le mot-clé CONSTRAINT suivi de son nom.
23
LDD (21/29)
Création des tables
Exemple CREATE TABLE PERSONNE
( idpers Number CONSTRAINT clé_primaire PRIMARY
KEY, nom Varchar2(30) CONSTRAINT nom_existant
NOT NULL, prenom Varchar2(30) CONSTRAINT
prénom_par_défaut DEFAULT 'prénom inconnu',
age Number CONSTRAINT verify_age
CHECK (age >= 0 AND age < 130),
etat_civil Varchar2(20) CONSTRAINT
domaine_état_civil CHECK (etat_civil IN ('marié(e)',
célibataire', 'veuf(ve)', 'divorcé(e)'));
24
LDD (22/29)
Création des tables
Exemple de contrainte d’Intégrité référentielle : REFERENCES (1/3)
L'intégrité référentielle permet de vérifier la cohérence des liens entre tables, lors de l'ajout, de la suppression et de la modification de lignes.
Elle est utilisée lorsqu'on a une clé étrangère.
Elle permet d'assurer que toute valeur de clé étrangère correspond bien à une valeur de clé primaire de la table liée.
Soit le modèle relationnel suivant :
CLIENT (id_client, Nom_client, …)
FACTURE (code_fact, #id_client, …)
25
LDD (23/29)
Création des tables
Exemple de contrainte d’Intégrité référentielle : REFERENCES (2/3)
Traduction en SQL :
CREATE TABLE CLIENT
(id_client Number PRIMARY KEY,
Nom_client Varchar2(30) NOT NULL, … );
CREATE TABLE FACTURE
(code_fact Number PRIMARY KEY,
id_client Number REFERENCES CLIENT
(id_client) );
26
LDD (24/29)
Création des tables
Exemple de contrainte d’Intégrité référentielle :
REFERENCES (3/3)
On indique le mot clé REFERENCES après la clé
étrangère, puis le nom de la table qui est en relation
suivi entre parenthèse de la clé primaire de cette
table référencée.
27
LDD (25/29)
Création des tables
L'application de l'intégrité référentielle implique
plusieurs choses : on ne peut pas ajouter une facture avec un id_client qui n'existe
pas dans la table client (sinon un message d'erreur apparaît). Il
faut d'abord créer le client avant de créer sa facture.
on ne peut pas supprimer un client s'il existe des factures qui lui
correspondent. Il faut d'abord supprimer toutes les factures qui le
concernent avant de pouvoir le supprimer
on ne peut pas modifier l'id_client dans la table client s'il existe
des factures qui le concernent.
On peut modifier l'id_client de facture seulement si on choisit un
id_client qui existe dans la table client.
Cela revient à vérifier que toutes les factures
correspondent toujours à un client qui existe.
28
LDD (26/29)
Modification des tables
Ajout d’une ou plusieurs colonnes
ALTER TABLE nom_table
ADD (nom_colonne type_colonne);
On peut ajouter plusieurs colonnes en les
séparant par des virgules dans les parenthèses
du ADD
Exemple:
ALTER TABLE service
ADD (budget number(6) ) ;
29
LDD (27/29)
Modification des tables
Modification d’un type ou de toute autre
propriété d'une colonne
ALTER TABLE nom_table
MODIFY (nom_colonne
nouveau_type_et/ou_nouvelle_propriété);
Exemple:
ALTER TABLE employe
MODIFY (sal number(10,2), fonction
varchar2(30) ) ;
30
LDD (28/29)
Renommage des tables
RENAME TABLE nom_table TO
nouveau_nom_table;
Exemple :
RENAME employe to salarie;
31
LDD (29/29)
Suppression des tables
DROP TABLE nom_table;
Exemple
DROP table employe ;
DROP table salarie ;
32
LMD
Language de Manipulation des Données (1/9)
Insertion de lignes (INSERT INTO)
Syntaxe : Première forme :
On indique explicitement le nom des colonnes qu'on veut valoriser, et on indique les valeurs dans le même ordre.
INSERT INTO nom_table (nom_colonne1, nom_colonne2, …)
VALUES(valeur_colonne1, valeur_colonne2, …);
33
LMD (2/9)
Insertion de lignes (INSERT INTO)
Exemple INSERT INTO employe(NumEmp, NomEmp, sal, fonction,
code_service)
VALUES(12, 'Dupont', 1800, 'comptable', 2);
Remarque!! On n’est pas obligé de respecter l'ordre initial des colonnes, ni de toutes les indiquer. En effet les colonnes qui ont une valeur par défaut ou qui peuvent avoir une valeur nulle, si elles n'apparaissent pas, sont mises soit à NULL, soit à leur valeur par défaut.
34
LMD (3/9)
Insertion de lignes (INSERT INTO)
Deuxième forme : On n'indique pas les noms de
colonnes. Mais alors il faut absolument respecter l'ordre
dans lequel elles ont été créées et les valoriser toutes
(ou écrire explicitement NULL)
INSERT INTO nom_table
VALUES(valeur_colonne_1, valeur_colonne_2,…)
Exemple :
INSERT INTO employe VALUES(12, 'Dupont',
‘comptable', 1800, 2, NULL)
35
LMD (4/9)
Suppression de lignes (DELETE FROM)
DELETE permet de supprimer une ou plusieurs lignes, qui vérifie(nt) une condition.
Syntaxe
DELETE FROM nom_table
WHERE condition(s);
Exemple 1 : Suppression de tous les comptables du service 3
DELETE FROM employe
WHERE code_service = 3
AND function = 'comptable';
Exemple 2 : Suppression de l'employé numéro 10
DELETE FROM employe
WHERE NumEmp = 10;
36
LMD (5/9)
Modification de lignes (UPDATE … SET)
Permet de modifier la valeur d'une colonne pour une ou plusieurs lignes en particulier (qui vérifie(nt) un critère)
Syntaxe
UPDATE nom_table
SET nom_colonne = valeur
WHERE condition(s);
Exemple : Augmentation de 10% de tous les informaticiens
UPDATE employe
SET sal = sal * 1.1
WHERE function = 'informaticien';
37
LMD (6/9)
Modification de lignes (UPDATE … SET)
Pour modifier la valeur d'une colonne de la
même manière pour toutes les lignes, il suffit
de ne pas indiquer de condition.
Exemple : augmenter tous les employés de1%
UPDATE employe
SET sal = sal * 1.01;
38
LMD (7/9)
Modification de lignes (UPDATE … SET)
On peut aussi modifier plusieurs
colonnes en même temps, en séparant
les affectations par une virgule
UPDATE … SET nom_colonne_1 =
valeur_1, nom_colonne_2 = valeur_2,
…
Exemple :
UPDATE employe SET NumDept=1,
sal=2000 WHERE code_service=13;
39
LMD (8/9)
Modification de lignes (UPDATE … SET)
On peut utiliser le résultat d'une requête pour affecter de nouvelles valeurs
UPDATE nom_table
SET (colonne [, colonne ] ) = ( Requête )
[ WHERE condition ];
Dans cette deuxième forme, les parenthèses (clause SET) sont inutiles si une seule colonne est citée ;
40
LMD (9/9)
Modification de lignes (UPDATE … SET)
le nombre de colonnes retournées par la requête doit être égal au nombre de colonnes mentionnées dans SET.
La requête ne doit renvoyer qu’une seule ligne.
Exemple :
UPDATE emp SET (job, sal) = (SELECT job, sal
FROM emp
WHERE empno=1);
41
LID
Language d’interrogation des Données (1/19)
Projection (SELECT…FROM)
Syntaxe
SELECT [DISTINCT]
(<nomattribut1>, [<nomattribut2,…] ) | *
FROM <nom de table> ;
La clause DISTINCT permet d’éliminer les
doublons : si dans le résultat plusieurs lignes
sont identiques, une seule sera conservée.
Le symbole * permet d’obtenir tous les attributs
sans avoir à tous les citer.
42
LID (2/19)
Projection (SELECT…FROM)
Exemple1 : Liste des numéros et noms d’employés
SELECT NomEmp, Numemp FROM emp ;
Exemple2 : Liste de tous les employés
SELECT * FROM emp ;
Exemple3 : Liste des fonctions occupées dans l’entreprise
SELECT job FROM emp ;
43
LID (3/19)
Projection (SELECT…FROM)
Remarque : la requête renvoie plusieurs
lignes identiques.
Liste des fonctions occupées dans
l’entreprise (avec suppression des lignes
identiques)
SELECT distinct job FROM emp ;
44
LID (4/19)
Projection (SELECT…FROM)
La clause ORDER BY
Permet de trier les résultats suivant différentes
expressions (souvent des noms de colonnes) par ordre
croissant (ASC) ou décroissant (DESC).
L’option ASC est prise par défaut pour chacune des
expressions citées.
Exemple : Liste des employés par salaires décroissants
SELECT NomEmp, Sal
FROM emp
ORDER BY Sal DESC;
45
LID (5/19)
Sélection/Restriction (WHERE)
Syntaxe
SELECT [DISTINCT]
(<nomattribut1>, [<nomattribut2,…] ) | *
FROM <noms des tables>
WHERE <condition de recherche>
[ AND <condition de recherche> ];
Une condition de recherche est de la forme :
argument1 opérateur argument2
46
LID (6/19)
Sélection/Restriction (WHERE)
Exemple1 : Liste des employés appartenant au département 20
SELECT NomEmp, NumEmp FROM emp
WHERE deptno = 20 ;
Exemple2 : Liste des employés occupant la fonction de vendeur ou analyste
SELECT NomEmp, NumEmp FROM emp
WHERE job IN (‘ vendeur’, ‘ analyste’) ;
47
LID (7/19)
Sélection/Restriction (WHERE)
Exemple3 : Liste des employés
embauchés au mois de septembre 2010
SELECT NomEmp, NumEmp, DatEmb
FROM emp
WHERE DatEmb BETWEEN ‘01/09/10’
AND ‘30/09/10’ ;
48
LID (8/19)
Sélection/Restriction (WHERE)
Exemple 4 :Liste des employés dont le salaire est
compris entre 2000 et 3000
SELECT * FROM emp
WHERE sal between 2000 AND 3000 ;
Exemple 5 : Liste des employés dont le nom
commence par un J
SELECT * FROM emp
WHERE NomEmp LIKE "J%";
49
LID (9/19)
Jointure
Syntaxe
SELECT [DISTINCT]
(<nomattribut1>, [<nomattribut2,…] ) | *
FROM <noms des tables>
WHERE <condition de jointure>
[ AND <condition de recherche> ];
50
LID (10/19)
Jointure
Exemple : Liste des employés ainsi que le
nom de leur département
SELECT NomEmp, NomDept
FROM emp, dept
WHERE emp.NumDept = dept.NumDept;
51
LID (11/19)
Jointure
Remarque: Il est possible d’utiliser un
alias pour renommer les tables.
Exemple :
SELECT NomEmp, NomDept
FROM emp E, dept D
WHERE E.NumDept = D.NumDept;
52
LID (12/19)
Requêtes imbriquées (Sous-requêtes)
Une sous-requête ou requête imbriquée
est une requête incorporée dans la clause
WHERE ou HAVING d’une autre requête
permettant de limiter les données
retournées.
Le résultat retourné par la requête
imbriquée est utilisé dans la condition de
sélection de la requête principale.
53
LID (13/19)
Requêtes imbriquées (Sous-requêtes)
Syntaxe:
SELECT colonne FROM table1
WHERE colonne opérateur (SELECT colonne
FROM table 2
WHERE condition);
54
LID (14/19)
Requêtes imbriquées (Sous-requêtes)
Remarque1 : L’opérateur peut être :
- de comparaison (=,>,<,…) lorsque le résultat de la sous-requête est une valeur unique
- d’appartenance (IN, NOT IN, EXISTS, …) lorsque le résultat de la sous-requête est un ensemble
Remarque2 : Les parenthèses sont obligatoires
Remarque3 : La sous-requête doit déclarer le même nombre de colonnes que dans la clause WHERE
55
LID (15/19)
Requêtes imbriquées (Sous-requêtes)
Utilisation de l’opérateur EXISTS/NOT EXISTS
Cet opérateur permet de chercher la présence
d’une ligne répondant à certains critères dans
une table spécifique. Il vérifie si une sous-
requête retourne au moins une ligne
56
LID (16/19)
Requêtes imbriquées (Sous-requêtes)
Le prédicat EXISTS permet de tester l'existence ou
l'absence de données dans la sous-requête.
Si la sous-requête renvoie au moins une ligne, le
prédicat est vrai. Dans le cas contraire le prédicat à
valeur fausse.
La condition EXISTS est vraie si la requête imbriquée n’est
pas vide.
Exemple : Donner les noms des services ayant au
moins une personne embauchée après le 01/01/11.
SELECT NomServ FROM Service
WHERE EXISTS (SELECT * FROM Personne
WHERE Date_EmbP >’01/01/11’
AND NumServ = NumServP);
57
LID (17/19)
Requêtes imbriquées (Sous-requêtes)
L’opérateur NOT EXISTS permet
d’obtenir la division de deux relations.
Exemple : Q8 TD
58
LID (18/19)
Groupement (GROUP BY)
L’instruction GROUP BY sert à rassembler tous les enregistrements qui contiennent des données dans la ou les colonnes spécifiées et va permettre l’utilisation des fonctions d’agrégation sur une ou plusieurs colonnes
59
LID (19/ 19)
Groupement (GROUP BY)
Syntaxe :
SELECT col1, col2, …, fct d’agrégat (col n)
FROM nom_table
WHERE conditions avant groupement
GROUP BY col1, col2, …, coln
HAVING conditions de groupement;
60
Les opérateurs ensemblistes (1/7)
UNION
L'opérateur UNION combine le résultat de deux requêtes SQL en éliminant les lignes retournées par les deux requêtes (doublons). UNION agit sur toutes les colonnes.
L'opérateur UNION ALL retourne toutes les lignes sans éliminer les doublons.
61
Les opérateurs ensemblistes (2/7)
UNION
Syntaxe
SELECT col1, col2 FROM table1
WHERE ...
UNION
SELECT col1, col2 FROM table2
WHERE ...
62
Les opérateurs ensemblistes (3/7)
INTERSECT
L'opérateur INTERSECT retourne
uniquement le résultat communs aux deux
requêtes.
INTERSECT agit sur toutes les colonnes.
L'inversion des tables dans
une intersection ne change pas le résultat.
63
Les opérateurs ensemblistes (4/7)
INTERSECT
Syntaxe
SELECT col1, col2 FROM table1
WHERE ...
INTERSECT
SELECT col1, col2 FROM table2
WHERE ...
64
Les opérateurs ensemblistes (5/7)
MINUS
L'opérateur MINUS retourne les lignes de
la première requête qui ne se trouvent
pas dans la deuxième requête.
MINUS agit sur toutes les colonnes.
L'inversion des tables avec MINUS
change le résultat.
65
Les opérateurs ensemblistes (6/7)
MINUS
Syntaxe
SELECT col1, col2 FROM table1
WHERE ...
MINUS
SELECT col1, col2 FROM table2
WHERE ...
66
Les opérateurs ensemblistes (7/7)
Deux règles essentielles pour combiner
les ensembles de résultats de deux
requêtes :
Le nombre et l'ordre des colonnes doivent
être identiques dans toutes les requêtes.
Les types de données doivent être
compatibles.