Base de données

1. Créer les types T_Meuble (en omettant la fonction vol()) et T_Armoire correspondant au diagramme de
classes UML de la mini-base de données ci-dessous.

MEUBLE
Ref : NUMBER(8)
Desi : VARCHAR(20)
Dim_Haut : NUMBER(3)
Dim_Larg : NUMBER(3)
Dim_Prof : NUMBER(3)

CONSTRUCTOR FUNCTION T_Meuble ()

STATIC FUNCTION Com pte()
STATIC PROCEDURE Affiche()
MEMBER FUNCTION Volpp( )
MEMBER PROCEDURE Modifie( )
MEMBER PROCEDURE Supprime( )
MAP MEMBER FUNCTION Vol()

ARMOIRE
Nb_Portes : NUMBER(1)

CONSTRUCTOR FUNCTION T_Armoire( )

STATIC FUNCTION Compte()
STATIC PROCEDURE Affiche()
MEMBER FUNCTION Volpp()
MEMBER PROCEDURE Modifie( )

2. Modifier le type T_Meuble en ajoutant la fonction vol()

3. Définir une table nommée Meuble d’objets de type T_Meuble.

Constructeurs

1. Surcharger le constructeur par défaut de T_Meuble à l’aide d’une fonction prenant en paramètres uniquement
la désignation et les dimensions du meuble. Cette fonction doit, en plus des initialisations d’attributs classiques
dans un constructeur :
 stocker l’objet meuble créé dans la table Meuble ;
 générer automatiquement la référence du nouveau meuble (10000000 pour la première référence, puis
autoincrémentation de 10 en 10).
2. Créer un nouveau constructeur pour T_Armoire, similaire à celui de T_Meuble.
Stocker les objets de type T_Armoire dans la table Meuble.

Méthodes statiques

1. Définir une méthode Compte pour le type T_Meuble, qui renvoie le nombre de meubles dans la table
Meuble.
2. Surcharger la méthode Compte dans le type T_Armoire de manière à ne renvoyer que le nombre d’armoires.
Note : comme pour les constructeurs, il est inutile d’employer la clause OVERRIDING pour les méthodes
statiques.
Bases de données avancées – TD n°3 1
3. Définir une méthode Affiche pour le type T_Meuble qui affiche tous les meubles de la table Meuble au
format « référence désignation - Hauteur : xxx, Largeur : xxx, Profondeur : xxx ».
4. Surcharger la méthode Affiche dans le type T_Armoire de manière à afficher en plus l’attribut Nb_portes.

Méthodes membres

1. Définir une méthode Volpp pour le type T_Meuble, permettant de renvoyer le volume de l’objet meuble
appelant (hauteur x largeur x profondeur).
2. Surcharger la méthode Volpp dans le type T_Armoire afin de renvoyer le volume de l’objet armoire appelant
divisé par le nombre de portes de l’armoire.
3. Définir une méthode Modifie pour le type T_Meuble, permettant de modifier les valeurs de tous les attributs
de l’objet meuble appelant.
4. Définir une méthode Modifie pour le type T_Armoire, similaire à la méthode Modifie du type T_Meuble.
5. Ajouter au type T_Meuble une méthode de comparaison d’objets MAP nommée Vol, qui effectue le même
calcul que Volpp.
6. Définir une méthode Supprime pour le type T_Meuble, permettant de supprimer l’objet meuble appelant.
Est-il nécessaire de créer la même méthode spécifiquement pour T_Armoire ?

Bloc PL/SQL

1. Dans un bloc PL/SQL anonyme, déclarer trois variables de type T_Meuble (m1, m2 et m3) et une variable de
type T_Armoire (a1).
2. Dans le code, initialiser m1, m2 et m3 à l’aide du constructeur par défaut du type T_Meuble.
T_MEUBLE(0, 'Coffre', 100, 100, 50)
T_MEUBLE(10000000, 'Meuble téléphone', 110, 50, 30)
T_MEUBLE(10000010, 'Colonne CD', 180, 20, 10)
3. Initialiser a1 à l’aide du constructeur du type T_Armoire.
T_ARMOIRE(10000020, 'Armoire métal', 190, 130, 70, 2)
4. Afficher le nombre de meubles et le nombre d’armoires.
5. Afficher tous les meubles et toutes les armoires
6. Afficher les volumes du meuble m2 et de l’armoire a1.
7. Modifier l’objet meuble m2 par : T_MEUBLE('10000001', 'Meuble téléphone', 115, 45, 30).
Afficher ensuite la valeur de l’attribut Dim_haut de m2 (pour vérification), puis afficher les meubles.
8. Modifier l’objet meuble a1 par : T_ARMOIRE('50000000', 'Armoire bois', 210, 150, 75, 3), puis afficher
les armoires.
9. Comparer les objets m2 et m3, puis m2 et a1 (test d’égalité) et afficher si les meubles sont différents
(volumes différents) ou susceptibles d’être identiques (volumes égaux).
10. Supprimer le meuble m3 et l’armoire a1. Afficher ensuite la valeur de l’attribut Dim_haut de m3 (pour
vérification), puis afficher les meubles.

Evolutions de schéma

1. Ajouter au type T_Meuble un attribut Prix réel.

Vues objet

1. Créer une vue objet nommée Vue_Salle_cours basée sur le type T_Salle_cours et permettant d’afficher toutes
les caractéristiques des salles de cours de la table Salle du TD n° 1.
2. Afficher la structure et le contenu de la vue objet Vue_Salle_cours.
3. Définir un déclencheur de type INSTEAD OF permettant, lors d’une insertion dans la vue objet
Vue_Salle_cours, d’effectuer l’insertion correspondante dans la table source Salle.
4. Insérer un nouvel objet dans la table Salle par l’intermédiaire de la vue objet Vue_Salle_cours.
Vérifier le contenu de la vue objet Vue_Salle_cours et de la table Salle.

Bases de données avancées – TD n°3 2

 Correction du TD n°3
-- Interfaces des types

1) CREATE TYPE T_Meuble AS OBJECT(

-- Attributs
Ref NUMBER(8),
Desi VARCHAR(20),
Dim_haut NUMBER(3),
Dim_larg NUMBER(3),
Dim_prof NUMBER(3),
-- Méthodes
CONSTRUCTOR FUNCTION T_Meuble(pdesi VARCHAR,
phaut NUMBER,
plarg NUMBER,
pprof NUMBER ) RETURN SELF AS RESULT,
STATIC FUNCTION Compte RETURN INTEGER,
STATIC PROCEDURE Affiche,
NOT FINAL MEMBER FUNCTION Volpp RETURN NUMBER,
MEMBER PROCEDURE Modifie(nref NUMBER,
ndesi VARCHAR,
nhaut NUMBER,
nlarg NUMBER,
nprof NUMBER ),
MEMBER PROCEDURE Supprime
) NOT FINAL
/

CREATE TYPE T_Armoire UNDER T_Meuble(

-- Attributs
Nb_portes NUMBER(1),
-- Méthodes
CONSTRUCTOR FUNCTION T_Armoire( pdesi VARCHAR,
phaut NUMBER,
plarg NUMBER,
pprof NUMBER,
pnbp NUMBER ) RETURN SELF AS RESULT,
STATIC FUNCTION Compte RETURN INTEGER,
STATIC PROCEDURE Affiche,
OVERRIDING MEMBER FUNCTION Volpp RETURN NUMBER,
MEMBER PROCEDURE Modifie(nref NUMBER,
ndesi VARCHAR,
nhaut NUMBER,
nlarg NUMBER,
nprof NUMBER,
nnbp NUMBER )
)
/
2) -- Altérations de type (1)
ALTER TYPE T_Meuble ADD MAP MEMBER FUNCTION Vol RETURN NUMBER CASCADE;

3) -- Table des instances

CREATE TABLE Meuble OF T_Meuble(CONSTRAINT meuble_pk PRIMARY KEY(Ref));
Bases de données avancées – TD n°3 3
-- Constructeurs

CONSTRUCTOR FUNCTION T_Meuble(pdesi VARCHAR,

phaut NUMBER,
plarg NUMBER,
pprof NUMBER ) RETURN SELF AS RESULT IS
n INTEGER;
BEGIN
-- Calcul identifiant
SELECT COUNT(*) INTO n FROM Meuble;
IF n > 0 THEN
SELECT MAX(Ref)+10 INTO SELF.Ref FROM Meuble;
ELSE
SELF.Ref := 10000000;
END IF;
-- Autres attributs
SELF.Desi := pdesi;
SELF.Dim_haut := phaut;
SELF.Dim_larg := plarg;
SELF.Dim_prof := pprof;
-- Stockage
INSERT INTO Meuble VALUES (SELF);
RETURN;
END;

CONSTRUCTOR FUNCTION T_Armoire( pdesi VARCHAR,

phaut NUMBER,
plarg NUMBER,
pprof NUMBER,
pnbp NUMBER ) RETURN SELF AS RESULT IS
n INTEGER;
BEGIN
-- Calcul identifiant
SELECT COUNT(*) INTO n FROM Meuble;
IF n > 0 THEN
SELECT MAX(Ref)+10 INTO SELF.Ref FROM Meuble;
ELSE
SELF.Ref := 10000000;
END IF;
-- Autres attributs
SELF.Desi := pdesi;
SELF.Dim_haut := phaut;
SELF.Dim_larg := plarg;
SELF.Dim_prof := pprof;
SELF.Nb_portes := pnbp;
-- Stockage
INSERT INTO Meuble VALUES (TREAT (SELF as T_Armoire));
RETURN;
END;

Bases de données avancées – TD n°3 4

-- Méthodes statiques

1) STATIC FUNCTION Compte RETURN INTEGER IS

n INTEGER;
BEGIN
SELECT COUNT(*) INTO n FROM Meuble;
RETURN n;
END;

2) STATIC FUNCTION Compte RETURN INTEGER IS

n INTEGER;
BEGIN
SELECT COUNT(*) INTO n FROM Meuble
WHERE OBJECT_VALUE IS OF(T_Armoire);
RETURN n;
END;

3) STATIC PROCEDURE Affiche IS

CURSOR cmeubles IS SELECT * FROM Meuble;
m T_Meuble;
BEGIN
FOR m IN cmeubles LOOP
DBMS_OUTPUT.PUT_LINE(m.Ref || ' ' || m.Desi || ' - Hauteur : ' ||
m.Dim_haut || ', Largeur : ' || m.Dim_larg || ', Profondeur : ' || m.Dim_prof);
END LOOP;
END;

4) STATIC PROCEDURE Affiche IS

CURSOR carmoires IS SELECT m.Ref, m.Desi, m.Dim_haut, m.Dim_larg,
m.Dim_prof, TREAT(OBJECT_VALUE AS T_Armoire).Nb_portes Nbp
FROM Meuble m
WHERE OBJECT_VALUE IS OF(T_Armoire);
a T_Armoire;
BEGIN
FOR a IN carmoires LOOP
DBMS_OUTPUT.PUT_LINE(a.Ref || ' ' || a.Desi || ' - Hauteur : ' ||
a.Dim_haut || ', Largeur : ' || a.Dim_larg || ',
Profondeur : ' || a.Dim_prof || ', Nombre de portes : ' || a.Nbp);
END LOOP;
END;

-- Méthodes membres

1) NOT FINAL MEMBER FUNCTION Volpp RETURN NUMBER IS

BEGIN
RETURN SELF.Dim_haut * SELF.Dim_larg * SELF.Dim_prof;
END;

2) OVERRIDING MEMBER FUNCTION Volpp RETURN NUMBER IS

BEGIN
RETURN SELF.Dim_haut * SELF.Dim_Larg * SELF.Dim_prof / SELF.Nb_portes;
END;

Bases de données avancées – TD n°3 5

 3) MEMBER PROCEDURE Modifie(
nref NUMBER,
ndesi VARCHAR,
nhaut NUMBER,
nlarg NUMBER,
nprof NUMBER ) IS

BEGIN
UPDATE Meuble SET
Ref = nref,
Desi = ndesi,
Dim_haut = nhaut,
Dim_larg = nlarg,
Dim_prof = nprof
WHERE Ref = SELF.Ref;
SELF.Ref := nref;
SELF.Desi := ndesi;
SELF.Dim_haut := nhaut;
SELF.Dim_larg := nlarg;
SELF.Dim_prof := nprof;
END;

4) MEMBER PROCEDURE Modifie( nref NUMBER,

ndesi VARCHAR,
nhaut NUMBER,
nlarg NUMBER,
nprof NUMBER,
nnbp NUMBER) IS

anc_ref NUMBER ;
BEGIN
anc_ref := SELF.Ref ;
SELF.Ref := nref;
SELF.Desi := ndesi;
SELF.Dim_haut := nhaut;
SELF.Dim_larg := nlarg;
SELF.Dim_prof := nprof;
SELF.Nb_portes := nnbp;
UPDATE Meuble SET OBJECT_VALUE = TREAT(SELF AS T_Armoire)
WHERE Ref = anc_ref;
END;

5) MAP MEMBER FUNCTION Vol RETURN NUMBER IS

BEGIN
RETURN SELF.Dim_haut * SELF.Dim_larg * SELF.Dim_prof;
END;

6) MEMBER PROCEDURE Supprime IS

BEGIN
DELETE FROM Meuble WHERE Ref = SELF.Ref;
SELF := NULL;
END;

Bases de données avancées – TD n°3 6

-- Bloc PL/SQL
set serveroutput on

DECLARE
m1 T_Meuble;
m2 T_Meuble;
m3 T_Meuble;
a1 T_Armoire;

BEGIN

-- Initialisations
m1 := NEW T_Meuble(0, 'Coffre', 100, 100, 50);
m2 := NEW T_Meuble('Meuble téléphone', 110, 50, 30);
m3 := NEW T_Meuble('Colonne CD', 180, 20, 10);
a1 := NEW T_Armoire('Armoire métal', 190, 130, 70, 2);

-- Comptes
DBMS_OUTPUT.PUT_LINE('Nombre de meubles : ' || T_Meuble.Compte);
DBMS_OUTPUT.PUT_LINE('Nombre d''armoires : ' || T_Armoire.Compte);

-- Affichages
T_Meuble.Affiche;
T_Armoire.Affiche;

-- Volumes
DBMS_OUTPUT.PUT_LINE('m2.Volpp = ' || m2.Volpp);
DBMS_OUTPUT.PUT_LINE('a1.Volpp = ' || a1.Volpp);

-- Modifications
m2.Modifie(10000001, 'Meuble téléphone', 115, 45, 30);
DBMS_OUTPUT.PUT_LINE(m2.Dim_haut);
T_Meuble.Affiche;
a1.Modifie(50000000, 'Armoire bois', 210, 150, 75, 3);
T_Armoire.Affiche;

-- Comparaisons
IF m2 = m3 THEN
DBMS_OUTPUT.PUT_LINE('m2 et m3 sont les mêmes meubles !');
ELSE
DBMS_OUTPUT.PUT_LINE('m2 et m3 ne sont pas les mêmes meubles.');
END IF;

IF m2 = a1 THEN
DBMS_OUTPUT.PUT_LINE('m2 et a1 sont les mêmes meubles !');
ELSE
DBMS_OUTPUT.PUT_LINE('m2 et a1 ne sont pas les mêmes meubles.');
END IF;

-- Suppressions
m3.Supprime;
a1.Supprime;
DBMS_OUTPUT.PUT_LINE(m3.Dim_haut);
T_Meuble.Affiche;
END;
Bases de données avancées – TD n°3 7
Résultat de l’exécution du bloc anonyme :
Nombre de meubles : 3
Nombre d'armoires : 1
10000000 Meuble téléphone - Hauteur : 110, Largeur : 50, Profondeur : 30
10000010 Colonne CD - Hauteur : 180, Largeur : 20, Profondeur : 10
10000020 Armoire métal - Hauteur : 190, Largeur : 130, Profondeur : 70
10000020 Armoire métal - Hauteur : 190, Largeur : 130,
Profondeur : 70, Nombre de portes : 2
m2.Volpp = 165000
a1.Volpp = 864500
115
10000001 Meuble téléphone - Hauteur : 115, Largeur : 45, Profondeur : 30
10000010 Colonne CD - Hauteur : 180, Largeur : 20, Profondeur : 10
10000020 Armoire métal - Hauteur : 190, Largeur : 130, Profondeur : 70
10000020 Armoire métal - Hauteur : 190, Largeur : 130,
Profondeur : 70, Nombre de portes : 2
m2 et m3 ne sont pas les mêmes meubles.
m2 et a1 ne sont pas les mêmes meubles.
10000001 Meuble téléphone - Hauteur : 115, Largeur : 45, Profondeur : 30
10000020 Armoire métal - Hauteur : 190, Largeur : 130, Profondeur : 70

Procédure PL/SQL terminée avec succès.

-- Altérations de type (2)

ALTER TYPE T_Meuble ADD ATTRIBUTE (Prix NUMBER(8,2))
CASCADE INCLUDING TABLE DATA;

-- Affichage table Meuble

SELECT VALUE(m) FROM Meuble m;

VALUE(M)(REF, DESI, DIM_HAUT, DIM_LARG, DIM_PROF, PRIX)

-----------------------------------------------------------
T_MEUBLE(10000001, 'Meuble téléphone', 115, 45, 30, NULL)
T_ARMOIRE(10000020, 'Armoire métal', 190, 130, 70, NULL, 2)

-- Vues objet

1) CREATE VIEW Vue_Salle_cours OF T_Salle_cours

WITH OBJECT IDENTIFIER(Numero) AS
SELECT Numero,
Videoprojecteur,
TREAT(OBJECT_VALUE AS T_Salle_cours).Capacite,
TREAT(OBJECT_VALUE AS T_Salle_cours).Retroprojecteur,
TREAT(OBJECT_VALUE AS T_Salle_cours).Micro
FROM Salle
WHERE OBJECT_VALUE IS OF(T_Salle_cours);

2) DESC Vue_Salle_cours
SELECT * FROM Vue_Salle_cours;

NUMERO V CAPACITE R M
-------------------- - ---------- - -
Grand amphi O 400 OO
A1 N 80 NN
A2 N 50 ON
Bases de données avancées – TD n°3 8
3) CREATE OR REPLACE TRIGGER Insertion_Salle_cours
INSTEAD OF INSERT ON Vue_Salle_cours
FOR EACH ROW
BEGIN
INSERT INTO Salle VALUES(
T_Salle_cours( :NEW.Numero,
:NEW.Videoprojecteur,
:NEW.Capacite,
:NEW.Retroprojecteur,
:NEW.Micro));
END;
/

4) INSERT INTO Vue_Salle_cours VALUES ('05R', 'N', 50, 'N', 'N');

SELECT * FROM Vue_Salle_cours;

SELECT VALUE(s) FROM Salle s;

Bases de données avancées – TD n°3 9