Programmer en réseau à l’aide d’un langage orienté objet

TP Delphi Interbase

 Création d'une base de données :

Soit le modèle conceptuel des données suivant :

EMPLOYES
DEPARTEMENTS
NUM_EMP SMALLINT
1,N 1,1
NOM_EMP VARCHAR(20),
CODE_DEP CHAR(4) , Appartient
PRENOM_EMP VARCHAR(20),
DES_DEP VARCHAR(20), DATE_NAIS DATE
SITUATION_FAMILIALE CHAR(1),
SALAIRE DOUBLE PRECISION,
ADRESSE VARCHAR (40),

 Etapes à suivre pour la création de la Base de Données « Personnel » :

1. La Création du dossier « Gestion Personne l » et sous dossier « DB» (D:\Gestion Personnel\BD),
2. Le Lancement d’IBConsole,
3. La Connexion à un serveur donné,
4. La Création de la Base de Données, nom du fichier (D:\Gestion Personnel\BD\Personnel.gdb),
taille de la page (4096 octets), jeu de caractères par défaut (ISO8859_1), le dialecte (3) et
l’alias (Personnel),
5. La Création des tables (EMPLOYES) et (DEPARTEMENTS),

Remarque : Avant de créer la table employés, on va créer une intégrité du domaine sur le champ
Situation_Familiale et une autre sur le champ Salaire.

Le Lancement d’Interactif SQL (ISQL),

La Création de l’intégrité du domaine SF et TYPE_SALAIRE :
Domaine SF :
CREATE DOMAIN "SF"
AS CHAR(1)
CHECK (VALUE IN ('C', 'M', 'D', 'V'));

Domaine TYPE_SALAIRE :
CREATE DOMAIN "TYPE_SALAIRE"
AS DOUBLE PRECISION
DEFAULT 8000
CHECK (VALUE>=8000 AND VALUE<=30000);

La Création des tables EMPLOYES et DEPARTEMENTS :

Table des Employés :
CREATE TABLE EMPLOYES
(NUM_EMP SMALLINT NOT NULL,
NOM_EMP VARCHAR(20),
PRENOM_EMP VARCHAR(20),
DATE_NAIS DATE,
SITUATION_FAMILIALE SF,
SALAIRE TYPE_SALAIRE,
ADRESSE VARCHAR(100),
PRIMARY KEY (NUM_EMP));
1
Réalisé par : M.L. Belaïd Email : alias.bml@gmail.com
Programmer en réseau à l’aide d’un langage orienté objet

Table des Départements :

CREATE TABLE DEPARTEMENTSS
(CODE_DEP CHAR(4) NOT NULL,
DES_DEP VARCHAR(20),
PRIMARY KEY (CODE_DEP));

6. La Modification de la structure d'une table :

Ajout d'un champ :
ALTER TABLE EMPLOYES
ADD CODE_DEP CHAR(4) NOT NULL;

Ajout d'une clé étrangère :

ALTER TABLE EMPLOYES
ADD FOREIGN KEY (CODE_DEP)
REFERENCES DEPARTEMENTSS (CODE_DEP) ON DELETE CASCADE ON UPDATE CASCADE;

7. Insertion d'enregistrements dans les tables :

Table des Départements :
INSERT INTO DEPARTEMENTS
VALUES ('INFO', 'INFORMATIQUE') ; 

INSERT INTO DEPARTEMENTS

VALUES ('ELEC', 'ELECTRONIQUE') ;

INSERT INTO DEPARTEMENTS

VALUES ('STAT', 'STATISTIQUES') ;

INSERT INTO DEPARTEMENTS

VALUES ('ADMI', 'ADMINISTRATION') ;

INSERT INTO DEPARTEMENTS

VALUES ('FINE', 'FINANCES') ;

Table des Employés :

INSERT INTO EMPLOYES
VALUES (12, 'HADDAD', 'MOURAD', 'M', 25000, '03 RUE DES FRERES DJILLALI BIRKHADEM 16520 ALGER', 'ELEC')

INSERT INTO EMPLOYES

VALUES (19, 'DAHMANI', 'MOUNIA', 'M', 15000, '25 RUE DES TURELLES HYDRA 16120 ALGER', 'INFO')

L’utilisation de l'objet default (salaire) :

INSERT INTO EMPLOYES (NUM_EMP, NOM_EMP, PRENOM_EMP, SITUATION_FAMILIALE, ADRESSE, CODE_DEP)
VALUES (21, 'MAHMOUDI', 'MOUNIR', 'C', '01 BOULEVART COLONEL AMIROUCHE ARZEW 31210 ORAN', 'STAT')

Insertion de valeurs Nulles :

INSERT INTO EMPLOYES (NUM_EMP, NOM_EMP, PRENOM_EMP, SITUATION_FAMILIALE, SALAIRE,
ADRESSE, CODE_DEP)
VALUES (29, 'MADANI', 'ASMAA', 'C', 22000, NULL, 'INFO')

Suppression d'enregistrements :
DELETE FROM <nom de la table>
WHERE <conditions de suppression>

2
Réalisé par : M.L. Belaïd Email : alias.bml@gmail.com
Programmer en réseau à l’aide d’un langage orienté objet

 Mise à Jour des Données :

Ajouter la somme 200 dans le salaire pour tous les employés sans conditions :
UPDATE EMPLOYES
SET SALAIRE=SALAIRE+200
Faire : SELECT * FROM EMPLOYES; pour vérifier la mise à jour des enregistrements

Changer la Situation Familiale pour le salarié dont le numéro est 1 car il est maintenant Marié :
UPDATE EMPLOYES
SET SITUATION_FAMILIALE='M'
WHERE NUM_EMP=21
Toujours faire : SELECT * FROM EMPLOYES ; pour vérifier la mise à jour sur l'enregistrement 

Ajouter une prime de 600 DA pour les employés mariés et divorcés :

UPDATE EMPLOYES
SET SALAIRE=SALAIRE+600
WHERE SITUATION_FAMILIALE IN ('M', 'D')
Toujours faire : SELECT * FROM EMPLOYES ; pour vérifier la mise à jour sur les enregistrements

 Extraction de Données :

SELECT *
FROM EMPLOYES

SELECT NOM_EMP, PRENOM_EMP

FROM EMPLOYES

Avec Condition:
SELECT * FROM EMPLOYES
WHERE NUM_EMP=1

SELECT * FROM EMPLOYES

WHERE CODE_DEP='INFO'

SELECT * FROM EMPLOYES

WHERE CODE_DEP IN ('INFO', 'ELEC')

SELECT * FROM EMPLOYES

WHERE NUM_EMP>5

Extraction de données avec Tri des enregistrements (par défaut le tri est croissant) :
SELECT * FROM EMPLOYES
ORDER BY NOM_EMP

Sélection avec Tri Décroissant :

SELECT * FROM EMPLOYES
ORDER BY SALAIRE DESC

 Utilisation des fonctions d'agrégations :

1. COUNT : Retourne le nombre d'enregistrements sans conditions.

SELECT COUNT (NUM_EMP)
FROM EMPLOYES

3
Réalisé par : M.L. Belaïd Email : alias.bml@gmail.com
Programmer en réseau à l’aide d’un langage orienté objet

Avec conditions:
SELECT COUNT (NUM_EMP)
FROM EMPLOYES
WHERE SALAIRE >20000

2. AVG : Retourne la moyenne des valeurs sans conditions.

SELECT AVG (SALAIRE)
FROM EMPLOYES

Avec conditions:
SELECT AVG (SALAIRE)
FROM EMPLOYES
WHERE CODE_DEP IN ('INFO', 'ELEC')

3. SUM : Retourne la somme des valeurs.

SELECT SUM (SALAIRE)
FROM EMPLOYES

4. MAX et MIN : Retourne respectivement le maximum et le minimum des valeurs.

SELECT MAX(SALAIRE)
FROM EMPLOYES

 L’utilisation de groupe des fonctions d'agrégation :

SELECT MIN(SALAIRE), AVG(SALAIRE)

FROM EMPLOYES

 Le regroupement des données avec l’utilisation de la clause GROUP BY :

Cette requête permet d'avoir la moyenne des salaires pour les employés ayant la même situation
familiale :
SELECT SITUATION_FAMILIALE, AVG(SALAIRE)
FROM EMPLOYES
GROUP BY SITUATION_FAMILIALE

La requête suivante donne la somme des salaires pour les employés affectés au même
département :
SELECT CODE_DEP, SUM (SALAIRE)
FROM EMPLOYES
GROUP BY CODE_DEP

Remarque : Uniquement le champ mentionné dans la clause GROUP BY apparait dans la clause
SELECT (ne pas inclure les autres champs de la table) mais vous pouvez inclure des fonctions
d'agrégation au niveau de la clause SELECT.

 L’association de la clause HAVING a la clause GROUP BY :

La requête suivante permet d'avoir la moyenne des salaires pour les employés ayant la même
situation familiale et qui est supérieure à 14000.

4
Réalisé par : M.L. Belaïd Email : alias.bml@gmail.com
Programmer en réseau à l’aide d’un langage orienté objet

SELECT SITUATION_FAMILIALE, AVG(SALAIRE)

FROM EMPLOYES
GROUP BY SITUATION_FAMILIALE
HAVING AVG(SALAIRE)>14000

 L’utilisation des jointures sous InterBase :

1. La Jointure Interne : Une jointure interne permet d'afficher les champs spécifiés dans la clause
SELECT des deux tables satisfaisant la ou les conditions de jointure, à condition que ces deux
tables aient un champ en commun.

Exemple : je veux afficher tous les noms et prénoms de la table EMPLOYES avec la désignation du
département au quel ils sont affectés, sachant que le champ désignation département est un
champ de la table DEPARTEMENTS.
SELECT EMPLOYES.NOM_EMP, EMPLOYES.PRENOM_EMP, DEPARTEMENTS.DES_DEP
FROM EMPLOYES INNER JOIN DEPARTEMENTS
ON EMPLOYES.CODE_DEP=DEPARTEMENTS.CODE_DEP

2. La Jointure Externe Gauche : Une jointure externe gauche permet d'afficher tous les champs de
la table gauche puis tous les champs spécifiés dans la clause SELECT des deux tables satisfaisant
la ou les conditions de jointure.

Syntaxe : LEFT OUTER JOIN

3. La jointure Externe Droite : Une jointure externe droite permet d'afficher tous les champs de la
table droite puis tous les champs spécifiés dans la clause SELECT des deux tables satisfaisant la
ou les conditions de jointure.
Syntaxe : RIGHT OUTER JOIN

Exemple : L'exemple suivant affiche tous les noms et prénoms de la table EMPLOYES avec la
désignation du département au quel ils sont affectés plus les départements qui ne possèdent pas
encore d'employés.
SELECT EMPLOYES.NOM_EMP, EMPLOYES.PRENOM_EMP, DEPARTEMENTS.DES_DEP
FROM EMPLOYES RIGHT OUTER JOIN DEPARTEMENTS
ON EMPLOYES.CODE_DEP=DEPARTEMENTS.CODE_DEP

 Gestion de la Sécurité sous InterBase :

1. Création de comptes User : Après s'être connecté au serveur InterBase avec l'outil Server
Manager, et à la base de données via Server Manager, cliquez sur User Security une boite de
dialogue apparait vous permettant de créer des comptes User, de supprimer et de modifier des
comptes existants.

2. Gestion des permissions sur les comptes User : A tout moment vous pouvez affecter ou retirer
une permission à un compte use.
Exemple : Soient les comptes user suivants : POSTE1, POSTE2, POSTE3, POSTE4

GRANT SELECT, DELETE ON EMPLOYES TO POSTE1, POSTE4

5
Réalisé par : M.L. Belaïd Email : alias.bml@gmail.com
Programmer en réseau à l’aide d’un langage orienté objet

GRANT : Elle permet d'affecter une permission, l'exemple ci dessus permet d'affecter les
permissions de lecture et de suppression sur la table EMPLOYES de la base de données en cours
pour les comptes POSTE1 et POSTE4.
Remarque : Lors de la création des comptes user aucune permission n'est accorder aux comptes,
il faut que l'administrateur accorde d'abord les permissions aux comptes.

REVOKE : Elle permet de retirer une permission donnée à un compte.

Exemple : REVOKE SELECT ON EMPLOYES TO POSTE4

3. Gestion des permissions sur des Rôles : Un rôle est tout simplement un regroupement de
comptes user ayant les mêmes permissions, au lieu d'affecter les permissions à chacun des user
on les regroupe au sein du même rôle puis on affecte des permissions à ces rôles.

Création de Rôle :
CREATE ROLE <nom du rôle>
Exemple CREATE ROLE IFPUSER

Remarque : GRANT IFPUSER TO POSTE2, POSTE3 permet d'affecter les comptes user POSTE2 et
POSTE3 au rôle ROLUSER On affecte les permissions aux rôles de la même manière qu'avec les
comptes user.

 Les Procédures Stockées : Une procédure stockée est code SQL s'exécutant sur le serveur
InterBase, il permet de réduire le trafic du réseau pur les Users.

1. Exemple d'une procédure stockée sous Interbase : La procédure suivante permet de modifier le
salaire d'un employé à partir de son numéro, ainsi si son salaire est >=20000 il aura une
augmentation d'un montant A et si son salaire est <20000 il aura une augmentation d'un
montant B.
SET TERM ^;
CREATE PROCEDURE MODIFSAL (ID SMALLINT, A DOUBLE PRECISION, B DOUBLE PRECISION)
AS
DECLARE VARIABLE Sale DOUBLE PRECISION;
BEGIN
Sale=0;
SELECT SALAIRE
FROM EMPLOYES
WHERE (NUM_EMP=:ID)
INTO Sale;

IF (Sale<20000) THEN
UPDATE EMPLOYES
SET SALAIRE=SALAIRE+:A
WHERE (NUM_EMP=:ID);
ELSE
UPDATE EMPLOYES
SET SALAIRE=SALAIRE+:B
WHERE (NUM_EMP=:ID);
END^
SET TERM ;

6
Réalisé par : M.L. Belaïd Email : alias.bml@gmail.com
Programmer en réseau à l’aide d’un langage orienté objet

TP N° 02

Partie 1 :
Soit le modèle conceptuel des données suivant :

Module Stagiaire
NumMod Noter NumStag
NomMod 1,N E1 1,N NomStag
E2 GenreStag
Syn DateNaiss

1,1 1,1
Specialite
1,N CodeSP 1,N
Comporte Inscrit
Des_SP

1. Donner le modèle physique de données ?

2. Donner le script ISQL de création des Tables de la base de données (BDD_GEST_SCOL) sachant
que :
 L’attribut GenreStag ne comporte que deux valeurs (H) ou (F).
 La note E1 et E1 doit être comprise entre [0 et 20] et la note de la synthèse (SYN) entre
[0 et 40]
 Le numéro module et un attribut séquentiel (auto incrément).
 Les propriétés de type varchar ne doivent pas être NULL
 Les notes (E1, E2, SYN) et la date de naissance peuvent être NULL.
3. Donner les instruction en ISQl pour ajouter les propriétés Coefficient (Coef) et note éliminatoire
(NoteE) à la table Module, tel que le Coefficient doit être compris entre 1 et 5, et la note
éliminatoire doive être comprise entre 5 et 8.

Partie 2 : Les requêtes SQL :

Ecrire les instructions ISQL qui rependent aux requêtes suivantes :
1. Afficher la liste des stagiaires (NumStag, NomStag, GenreStag, DateNaiss, CodeSP).
2. Afficher la liste des stagiaires (NumStag, NomStag, GenreStag, Des_SP).
3. Afficher le nombre de stagiaires inscrits.
4. Afficher le nombre de stagiaires inscrit par spécialité.
5. Afficher pour le stagiaire N° 10 la liste des notes (Nom Module, coefficient du module, Emd1, Emd2,
Synthèse, Moy_Mod = (E1+E2+Syn)/4 et Moy_Mod_Coef=(E1+E2+SYN)/4*Coef.
6. Afficher les stagiaires qui sont nés en 1990.
7. Ecrire une transaction pour insérer le module « Implémentation SQL Server » avec coefficient 5 et
note éliminatoire 8.

Partie 3 : Les Procédure Stockées :

1. qui affiche le nombre de stagiaires inscris.
2. qui affiche le nombre de stagiaires inscris dans une spécialité donnée en paramètre.
3. qui affiche pour un stagiaire (NumStag) donné en paramètre, la liste des notes (NomMod, Coef, E1,
E2, SYN, Moy_Mod =(E1+E2+SYN)/4 et Moy_Mod_Coef=(E1+E2+SYN)/4*Coef.

7
Réalisé par : M.L. Belaïd Email : alias.bml@gmail.com
Programmer en réseau à l’aide d’un langage orienté objet

Solution :
Partie 1 :
/*Création domain Genre */
CREATE DOMAIN Genre AS CHAR(1)
CHECK (VALUE IN ('H', 'F'));

/*Création domain EMD */

CREATE DOMAIN EMD AS DECIMAL (5,2)
DEFAULT 0
CHECK (VALUE>=0 AND VALUE<=20);

/*Création domain SYN */

CREATE DOMAIN SYN AS DECIMAL (5,2)
DEFAULT 0
CHECK (VALUE>=0 AND VALUE<=40);

/* Création Table: SPECIALITE */

CREATE TABLE SPECIALITE
(
CodeSP CHAR(4) NOT NULL,
DES_SP VARCHAR(20),
PRIMARY KEY (CodeSP)
);

/*Création Table: STAGIAIRE */

CREATE TABLE STAGIAIRE
(NumStag SMALLINT Not Null,
NomStag VARCHAR(20) Not Null,
GenreStage GENRE,
DateNais DATE,
CodeSP Char (4) Not Null, FOREIGN KEY (CodeSP) REFERENCES SPECIALITE(CodeSP) ON UPDATE CASCADE,
PRIMARY KEY (NumStag));

/*Création Table: MODULE */

CREATE TABLE MODULE
(NumMod SMALLINT Not Null,
NomMod VARCHAR(20) Not Null,
PRIMARY KEY (NumMod));

/*Création Table: NOTER */

CREATE TABLE NOTER
(NumStag SMALLINT Not Null,
NumMod SMALLINT Not Null,
E1 EMD,
E2 EMD,
SYN SYN,
PRIMARY KEY (NumStag,NumMod));

/*Modifier Table Module (Ajout Attribut Coef) /

ALTER TABLE MODULE
ADD Coef SMALLINT CONSTRAINT CK_Coef CHECK (Coef>=1 AND Coef<=5);

/*Modifier Table Module (Ajout Attribut NoteE) /

ALTER TABLE MODULE
ADD NoteE SMALLINT CONSTRAINT CK_NoteE CHECK (NoteE>=5 AND NoteN<=8);

8
Réalisé par : M.L. Belaïd Email : alias.bml@gmail.com
Programmer en réseau à l’aide d’un langage orienté objet

/*Création de GENERATEUR pour la table Module */

CREATE GENERATOR MODULE_NUM_INC;

/*initialisation du compteur (mettre à 0) */

SET GENERATOR MODULE_NUM_INC TO 0;

/*Création d’un TRIGGER pour Attribut NumMod (incrémentation automatique)*/

SET TERM^;
CREATE TRIGGER TRI_MODULE_NUM FOR MODULE
BEFORE INSERT AS
BEGIN
IF (NEW.NumMod IS NULL) THEN NEW.NumMod=GEN_ID(MODULE_NUM_INC, 1);
END^
SET TERM;^

Partie 2 :
1. Afficher la liste des stagiaires (NumStag, NomStag, GenreStag, DateNaiss, CodeSP) :
SELECT * FROM STAGIAIRE;

2. Afficher la liste des stagiaires (NumStag, NomStag, GenreStag, Des_SP) :

SELECT NumStag, NomStag, GenreStag, Des_SP
FROM STAGIAIRE ST INNER JOIN SPECIALITE SP ON ST.CodeSP=SP.CodeSP;

3. Afficher le nombre de stagiaires inscrits :

SELECT COUNT(*) FROM STAGIAIRE;

4. Afficher le nombre de stagiaires inscrit par spécialité :

SELECT CodeSP, COUNT(NumStag) FROM STAGIAIRE
GROUP BY CodeSP

5. Afficher pour le stagiaire N° 10 la liste des notes (Nom Module, coefficient du module, Emd1, Emd2, Synthèse,
MoyMod = (E1+E2+Syn)/4 et Moy_Mod_Coef= (E1+E2+SYN)/4*Coef.
SELECT NomMod,Coef, E1,E2,SYN, (E1+E2+SYN)/4 AS MOY_MOD, (E1+E2+SYN)/4*Coef AS MOY_MOD_COEF
FROM (STAGIAIRE S INNER JOIN NOTER N ON S.NumStag=N.NumStag)
INNER JOIN MODULE M ON N.NumMod=M.NumMod
WHERE NumStag=10

6. Afficher les stagiaires qui sont nés en 1990.

SELECT * FROM STAGIAIRE
WHERE DateNaiss BETWEEN '01/01/1990' AND '12/31/1990';

7. Ecrire une transaction pour insérer le module « Implémentation SQL Server » avec coefficient 5 et note
éliminatoire 8.
INSERT INTO MODULE (NomMod, Coef, NoteE)
VALUES (‘Implémentation SQL Server’,5 ,8);

Partie 3 :
1. Procédure Stockée Nombre de Stagiaires Inscris :
SET TERM^;
CREATE PROCEDURE NB_STAG_INSCRIS
RETURNS ( NBRSTAG INTEGER)
AS

9
Réalisé par : M.L. Belaïd Email : alias.bml@gmail.com
Programmer en réseau à l’aide d’un langage orienté objet

BEGIN
SELECT COUNT(*) FROM STAGIAIRE
INTO
:NBRSTAG;
SUSPEND;
END ^
SET TERM;^

/*Exécution de la procédure après insertion des données*/

EXECUTE PROCEDURE NB_STAG_INSCRIS

2. Procédure Stockée Nombre de Stagiaires Inscris par Spécialité

SET TERM^;
CREATE PROCEDURE NB_STAG_INSCRIS_Par_SP
RETURNS ( NBRSTAG INTEGER, SP char(4))
AS
BEGIN
FOR
SELECT CodeSP, COUNT(NumStag) FROM STAGIAIRE
GROUP BY CodeSP
INTO
:SP,
:NBRSTAG
DO
SUSPEND;
END ^
SET TERM;^

/*Exécution de la procédure
SELECT * FROM NB_STAG_INSCRIS_Par_SP

3. Procédure Stockées Calcul Moyenne d’un Stagiaire donné en Paramètre :

SET TERM^;
CREATE PROCEDURE CALCUL_MOYENNE(Num SMALLINT)
RETURNS
(
LM VARCHAR(20),
C SMALLINT,
EMD1 NUMERIC (5,2),
EMD2 NUMERIC (5,2),
SYNT NUMERIC (5,2),
MOY NUMERIC (5,2),
MOYCOEF NUMERIC (5,2)
)
AS
BEGIN
FOR
SELECT LibMod, Coef, E1,E2,SYN, (E1+E2+SYN)/4 AS MOYENNE, (E1+E2+SYN)/4*Coef AS MOYENNE_COEF
FROM (STAGIAIRE S INNER JOIN NOTER N ON S.NumStag=N.NumStag)
INNER JOIN MODULE M ON N.NumMod=M.NumMod
WHERE NumStag=:Num
INTO
:LM,
:C,
:EMD1,

10
Réalisé par : M.L. Belaïd Email : alias.bml@gmail.com
Programmer en réseau à l’aide d’un langage orienté objet

:EMD2,
:SYNT,
:MOY,
:MOYCOEF
DO
SUSPEND;
END^
SET TERM;^

SELECT * FROM CALCUL_MOYENNE (10)

11
Réalisé par : M.L. Belaïd Email : alias.bml@gmail.com
Programmer en réseau à l’aide d’un langage orienté objet

Les Vues : Les vues peuvent être considérées comme des tables virtuelles. Généralement, une table
contient un jeu de définitions et elle est destinée à stocker physiquement les données. Une vue a
également un jeu de définitions, créé au-dessus des tables ou d’autres vues, et elle ne stocke pas
physiquement les données.
Les vues sont nécessaires pour gérer finement les privilèges. Elles sont utiles pour masquer la
complexité de certains modèles relationnels.

La syntaxe pour la création d’une vue est comme suit :

CREATE VIEW nom_vue [(nom_col1 [,nom_col2 …])]
AS Select
[WITH CHECK OPTION];

Nom_vue : Nom de la vue; doit être unique parmi tous noms de vue, de table et de procédure dans la base de
données
Nom_Col : Noms de colonne de la vue.
Les noms de colonne doivent être uniques parmi tous les noms de colonnes dans la vue.
Obligatoire si la vue contient des colonnes basées sur des expressions, autrement optionnels.
Valeur par défaut: Nom de la colonne de la table sous-jacente

Select : Indique les critères de sélection pour les lignes à inclure dans la vue.

WITH CHECK OPTION : La clause WITH CHECK OPTION implique que si la vue peut être mise à jour, alors les valeurs
modifiées insérées ou supprimées doivent répondre à la validation de la clause WHERE comme s'il s'agissait d'une
contrainte.
Supposons que nous avons la table suivante :
TABLE CLIENT
(Nom_Client Varchar(20), Prenom_Client Varchar(20), Address Varchar(50), Ville Varchar(50))

Pour créer une vue appelée V_Client contenant seulement les colonnes Nom, Prenom et Adresse de cette
table, il faut saisir :
CREATE VIEW V_Client
AS SELECT Nom_Client, Prenom_Client, Adresse
FROM CLIENT
Nous avons à présent une vue appelée V_Client avec la structure suivante :
View V_Client
(Nom_Client Varchar(20), Prenom_Client Varchar(20), Adresse Varchar(50))

Il est aussi possible d’utiliser une vue pour appliquer des jointures à deux tables. Dans ce cas, les
utilisateurs ne verront qu’une vue au lieu de deux tables, disposant ainsi d’instructions SQL beaucoup
plus simples. Supposons que nous avons les deux tables suivantes :

Table Stock Table Géographie

Lieu Vente DateV Region Lieu
Alger 15000 05-01-2012 East Boumerdes
Blida 2500 07-01-2012 East Bouira
Alger 3000 08-01-2012 West Alger
Boumerdes 7000 08-01-2012 West Blida

Pour créer une vue contenant des ventes par données de région, il faudra définir l’instruction SQL suivante :
CREATE VIEW V_VENTE_REGION
AS SELECT A1.Lieu REGION, SUM(A2.Vente) VENTES
FROM Geographie A1, Stock A2
12
Réalisé par : M.L. Belaïd Email : alias.bml@gmail.com
Programmer en réseau à l’aide d’un langage orienté objet
WHERE A1.Lieu = A2.Lieu
GROUP BY A1.Region

Nous avons la vue V_VENTES_REGION, définie pour stocker les ventes par enregistrements de région. Pour
connaître le contenu de cette vue, il faut saisir :
SELECT * FROM V_VENTES_REGION
Résultat :
REGION VENTES
Est 7000
West 2050

Caractéristiques des Vues :

Une vue peut être utilisée comme une table dans toute requête de type SELECT. Mais à la différence des tables,
une vue peut être mise à jour (INSERT, UPDATE, DELETE) que si elle obéit à un certain nombre de conditions :

 Ne porter que sur une table (pas de jointure)

 Ne pas contenir de dédoublonnage (pas de mot clef DISTINCT) si la table n'a pas de clef
 Contenir la clef de la table si la table en a une
 Ne pas transformer les données (pas de concaténation, addition de colonne, calcul d'agrégat AVG, SUM...)
 Ne pas contenir de clause GROUP BY ou HAVING
 Ne pas contenir de sous requête
 Répondre au filtre WHERE si la clause WITH CHECK OPTIONS est spécifiée lors de la création de la vue

Bien évidemment une vue peut porter sur une autre vue et pour que la nouvelle vue construite à partir d'une
autre vue puisse être modifié, il faut que les deux vues répondent aussi à ces critères.

En fait c'est plus simple qu'il n'y parait; il suffit que le SGBDR puisse retrouver trace de la ligne dans la table et de
chaque valeur de chaque colonne.

Exemple : Soit la table T_EMPLOYE suivante :

/*Permet de stocker les employés de l'entreprise*/

CREATE TABLE T_EMPLOYE
(EMP_ID SMALLINT Not Null,
EMP_MATRICULE CHAR(8),
EMP_TITRE VARCHAR(4),
EMP_NOM VARCHAR(32),
EMP_PRENOM VARCHAR(32),
EMP_DATE_NAIS DATE,
EMP_SALAIRE NUMERIC(10,2),
EMP_STATUT CHAR(8),
EMP_MAIL VARCHAR(30),
EMP_TEL CHAR(10),
PRIMARY KEY(EMP_ID))

Vues restreignant l'accès aux colonnes

/*pour le syndicat, on pourra définir la vue suivante :*/
CREATE VIEW V_EMP_SYNDICAT AS
SELECT EMP_MATRICULE, EMP_TITRE, EMP_NOM, EMP_PRENOM, EMP_DATE_NAIS, EMP_MAIL, EMP_TEL
FROM T_EMPLOYE
/*elle ne peut être mise à jour car la clef ne s'y trouve pas*/

/*pour le carnet d'adresse on pourra définir la vue suivante :*/

CREATE VIEW V_EMP_SYNDICAT AS
SELECT EMP_ID, EMP_TITRE || ' ' || EMP_PRENOM || ' ' || EMP_NOM AS EMP_NOM_COMPLET, EMP_MAIL,
EMP_TEL
13
Réalisé par : M.L. Belaïd Email : alias.bml@gmail.com
Programmer en réseau à l’aide d’un langage orienté objet
FROM T_EMPLOYE
/*elle ne peut être mise à jour à cause des transformations de données (concaténation au
niveau du nom)*/

-- pour le service comptable, on pourra définir la vue suivante :

CREATE VIEW V_EMP_SYNDICAT
AS
SELECT EMP_ID, EMP_PRENOM, EMP_NOM, EMP_SALAIRE
FROM T_EMPLOYE
WHERE EMP_STATUT = 'ETAM'
WITH CHECK OPTION
-- elle pourra être mis à jour uniquement pour les salariés de type 'ETAM'
La clause WITH CHECK OPTION implique que si la vue peut être mise à jour, alors les valeurs modifiées insérées ou
supprimées doivent répondre à la validation de la clause WHERE comme s'il s'agissait d'une contrainte.

Par exemple dans le cadre de la vue pour le service comptable, il n'est pas possible de faire :

UPDATE T_EMPLOYE
SET EMP_SALAIRE = EMP_SALAIRE + 100
WHERE STATUT = 'CADRE'

14
Réalisé par : M.L. Belaïd Email : alias.bml@gmail.com
Programmer en réseau à l’aide d’un langage orienté objet

8. Les vues

Les vues de la norme SQL 2 ne sont autre que des requêtes instanciées.
Elles sont nécessaires pour gérer finement les privilèges. Elles sont utiles pour masquer la complexité de certains
modèles relationnel.

Voici la syntaxe SQL 2 pour définir une vue :

CREATE VIEW nom_vue [ ( nom_col1, [, nom_col2 ... ] ) ]

AS
requête_select
[WITH CHECK OPTIONS]
Exemple 94 - vue simplifiant un modèle

-- la table suivante :
CREATE TABLE T_TARIF
(TRF_ID INTEGER PRIMARY KEY,
TRF_DATE DATE,
PRD_ID INTEGER,
TRF_VALEUR FLOAT)

-- permet de stocker l'évolution d'un tarif, sachant que celui-ci n'est applicable
-- pour un produit donné (PRD_ID) qu'à partir de la date TRF_DATE
INSERT INTO T_TARIF VALUES (1, '1996-01-01', 53, 123.45)
INSERT INTO T_TARIF VALUES (2, '1998-09-15', 53, 128.52)
INSERT INTO T_TARIF VALUES (3, '1999-12-31', 53, 147.28)
INSERT INTO T_TARIF VALUES (4, '1997-01-01', 89, 254.89)
INSERT INTO T_TARIF VALUES (5, '1999-12-31', 89, 259.99)
INSERT INTO T_TARIF VALUES (6, '1996-01-01', 97, 589.52)

-- pour des raisons de commodité d'interrogation des données, on voudrait

-- faire apparaître l'intervalle de validité du tarif plutôt que la date d'application

-- la vue suivante répond à cette attente

CREATE VIEW V_TARIF
AS
SELECT TRF_ID, PRD_ID, TRF_DATE AS TRF_DATE_DEBUT,
(SELECT COALESCE(MIN(TRF_DATE) - INTERVAL 1 DAY, CURRENT_DATE)
FROM T_TARIF T2
WHERE T2.PRD_ID = T1.PRD_ID
AND T2.TRF_DATE > T1.TRF_DATE) AS TRF_DATE_FIN,
TRF_VALEUR
FROM T_TARIF T1

TRF_ID PRD_ID TRF_DATE_DEBUT

TRF_DATE_FIN TRF_VALEUR
------- ------- ---------------
------------ ----------
1 53 1996-01-01
1998-09-14 123.45
2 53 1998-09-15
SELECT *
FROM
1999-12-30 128.52
V_TARIF 3 53 1999-12-31
2002-09-03 147.28
4 89 1997-01-01
1999-12-30 254.89
5 89 1999-12-31
2002-09-03 259.99
6 97 1996-01-01
2002-09-03 589.52
Une vue peut être utilisée comme une table dans toute requête de type SELECT. Mais à la différence des tables, une
vue peut être mise à jour (INSERT, UPDATE, DELETE) que si elle obéit à un certain nombre de conditions :

15
Réalisé par : M.L. Belaïd Email : alias.bml@gmail.com
Programmer en réseau à l’aide d’un langage orienté objet

 ne porter que sur une table (pas de jointure)

 ne pas contenir de dédoublonnage (pas de mot clef DISTINCT) si la table n'a pas de clef
 contenir la clef de la table si la table en a une
 ne pas transformer les données (pas de concaténation, addition de colonne, calcul d'agrégat...)
 ne pas contenir de clause GROUP BY ou HAVING
 ne pas contenir de sous requête
 répondre au filtre WHERE si la clause WITH CHECK OPTIONS est spécifié lors de la création de la vue

Bien évidemment une vue peut porter sur une autre vue et pour que la nouvelle vue construite à partir d'une autre
vue puisse être modifié, il faut que les deux vues répondent aussi à ces critères.

En fait c'est plus simple qu'il n'y parait : il suffit que le SGBDR puisse retrouver trace de la ligne dans la table et de
chaque valeur de chaque colonne.

Exemple 95 - vue restreignant l'accès aux colonnes

-- soit la table suivante :

CREATE TABLE T_EMPLOYE
(EMP_ID INTEGER PRIMARY KEY,
EMP_MATRICULE CHAR(8),
EMP_TITRE VARCHAR(4),
EMP_NOM VARCHAR(32),
EMP_PRENOM VARCHAR(32),
EMP_DATE_NAIS DATE,
EMP_SALAIRE FLOAT,
EMP_STATUT CHAR(8),
EMP_MAIL VARCHAR(128),
EMP_TEL CHAR(16))
-- permet de stocker les employés de l'entreprise

-- pour le syndicat, on pourra définir la vue suivante :

CREATE VIEW V_EMP_SYNDICAT
AS
SELECT EMP_MATRICULE, EMP_TITRE, EMP_NOM, EMP_PRENOM, EMP_DATE_NAIS, EMP_MAIL, EMP_TEL
FROM T_EMPLOYE
-- elle ne peut être mise à jour car la clef ne s'y trouve pas

-- pour le carnet d'adresse on pourra définir la vue suivante

CREATE VIEW V_EMP_SYNDICAT
AS
SELECT EMP_ID, EMP_TITRE || ' ' || EMP_PRENOM || ' ' || EMP_NOM AS EMP_NOM_COMPLET,
EMP_MAIL, EMP_TEL
FROM T_EMPLOYE
-- elle ne peut être mise à jour à cause des transformation de données (concaténation au
niveau du nom)

-- pour le service comptable, on pourra définir la vue suivante :

CREATE VIEW V_EMP_SYNDICAT
AS
SELECT EMP_ID, EMP_PRENOM, EMP_NOM, EMP_SALAIRE
FROM T_EMPLOYE
WHERE STATUT = 'ETAM'
WITH CHECK OPTIONS
-- elle pourra être mis à jour uniquement pour les salariés de type 'ETAM'
La clause WITH CHECK OPTION implique que si la vue peut être mise à jour, alors les valeurs modifiées insérées ou
supprimées doivent répondre à la validation de la clause WHERE comme s'il s'agissait d'une contrainte.

Par exemple dans le cadre de la vue pour le service comptable, il n'est pas possible de faire :

UPDATE T_EMPLOYE
SET EMP_SALAIRE = EMP_SALAIRE + 100
WHERE STATUT = 'CADRE'

16
Réalisé par : M.L. Belaïd Email : alias.bml@gmail.com