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)


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)


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)


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)


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)


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)



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)



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)



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)


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)


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


(…

Téléphone CHAR(10) UNIQUE

);

15

LDD (13/29)


Sur plusieurs colonnes


( 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)


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é.


(idPers PRIMARY KEY, …);

17

LDD (15/29)



Si la table a une clé compose de plusieurs colonnes, alors il est impossible d'indiquer PRIMARY KEY au niveau des colonnes.


(NomPers Varchar2(30) PRIMARY KEY,

PrénomPers Varchar2(30) PRIMARY KEY, …);

18

LDD (16/29)



On doit déclarer la clé à part, après la

déclaration des colonnes.


(NomPers Varchar2(30),

PrénomPers Varchar2(30),

PRIMARY KEY (NomPers, PrénomPers) );

19

LDD (17/29)


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)


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)


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)


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)


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)


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)


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)


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)


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)


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)


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)


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)


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)


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)


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)


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)


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)


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]


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)


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)


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)


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]


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)


Syntaxe:

SELECT colonne FROM table1

WHERE colonne opérateur (SELECT colonne

FROM table 2

WHERE condition);

54

LID (14/19)


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)


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)


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)


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


UNION

Syntaxe

SELECT col1, col2 FROM table1

WHERE ...

UNION


WHERE ...

62


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


INTERSECT

Syntaxe


WHERE ...

INTERSECT


WHERE ...

64


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


MINUS

Syntaxe


WHERE ...

MINUS


WHERE ...

66


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.

cours sql2

Documents