Oracle Types d'objets PL/SQL : CREATE TYPE avec exemples

Qu’est-ce que le type d’objet en PL/SQL ?

La programmation orientée objet est particulièrement adaptée à la création de composants réutilisables et d'applications complexes. Les programmes sont organisés autour d'« objets » plutôt que d'« actions » ; autrement dit, ils sont conçus pour interagir avec un objet entier et non avec une action isolée. Cette approche permet au programmeur de renseigner et de manipuler les détails au niveau de l'entité objet.

L'image ci-dessous illustre un exemple de type d'objet où un compte bancaire est traité comme une entité objet. Les attributs de l'objet contiennent des valeurs (pour un compte bancaire, il s'agit du numéro de compte, du solde, etc.), tandis que les méthodes de l'objet décrivent des actions telles que le calcul du taux d'intérêt ou la génération d'un relevé bancaire, chacune nécessitant un traitement.

In PL / SQLLa programmation orientée objet repose sur les types d'objets. Un type d'objet peut représenter n'importe quelle entité du monde réel. Les sections suivantes explorent les types d'objets, leurs composants, ainsi que la manière de les créer et de les utiliser.

Composants des types d'objet

Un type d'objet PL/SQL contient principalement deux composants.

1. Attributs
2. Membres/Méthodes

Attributs

Les attributs sont les colonnes ou les champs dans lesquels les données sont stockées. Chaque attribut est associé à un type de données qui définit son traitement et son stockage. Un attribut peut être de n'importe quel type valide. Type de données PL/SQL, ou il peut s'agir d'un autre type d'objet.

Membres/Méthodes

Les membres, ou méthodes, sont sous-programmes Ces membres sont définis au sein du type objet. Ils ne servent pas à stocker des données ; ils définissent plutôt le traitement effectué au sein du type objet, par exemple la validation des données avant leur insertion dans l’objet. Ils sont déclarés dans la spécification du type objet et définis dans son corps. Le corps est facultatif : si aucun membre n’est présent, le type objet n’a pas de corps.

Créer un objet dans Oracle

Un type d'objet ne peut être créé qu'au niveau du schéma et non au niveau d'un sous-programme. Une fois défini dans le schéma, il peut être utilisé dans les sous-programmes. La création du type d'objet s'effectue à l'aide de l'instruction « CREATE TYPE », et son corps ne peut être créé qu'après la création du type d'objet.

Les captures d'écran ci-dessous montrent la syntaxe CREATE TYPE pour la spécification de l'objet et la syntaxe CREATE TYPE BODY qui définit ses méthodes.

CREATE TYPE<object_type_name> AS OBJECT
(
<attribute_l><datatype>,
.
.
);
/
CREATE TYPE BODY<object_type_name> AS OBJECT
(
MEMBER[PROCEDURE|FUNCTION]<member_name> 
IS
<declarative section>
BEGIN
<execution part>
END;
.
.
);
/

Explication de la syntaxe :

• La syntaxe ci-dessus illustre la création d'un OBJET avec des attributs et d'un CORPS D'OBJET avec des méthodes.
• Les méthodes peuvent également être surchargées dans le corps de l'objet.

Initialisation de la déclaration du type d'objet

Comme les autres composants de PL/SQL, les types d'objets doivent être déclarés avant d'être utilisés dans un programme. Une fois le type d'objet créé, il peut être utilisé dans la section déclarative d'un sous-programme pour déclarer une variable de ce type.

Lorsqu'une variable est déclarée comme un objet, une nouvelle instance de cet objet est créée à l'exécution et cette instance est référencée par le nom de la variable. Ainsi, un même objet peut stocker plusieurs valeurs dans différentes instances.

La capture d'écran ci-dessous montre une variable déclarée comme un type objet à l'intérieur d'un Bloc PL/SQL.

DECLARE
<variable_name> <object_type_name>;
BEGIN
.
.
END;
/

Explication de la syntaxe :

• La syntaxe ci-dessus montre la déclaration d'un variable en tant que type d'objet dans la section déclarative.

Une fois déclarée comme objet dans un sous-programme, la variable est atomiquement nulle ; l’objet lui-même est nul. Elle doit être initialisée avec des valeurs avant de pouvoir être utilisée dans le programme. L’initialisation des objets se fait à l’aide de constructeurs.

Les constructeurs sont les méthodes implicites d'un objet auxquelles on peut faire référence en utilisant le même nom que le type de l'objet. La capture d'écran ci-dessous illustre l'initialisation d'une instance de type objet.

DECLARE
<variable_name> <object_type_name>; 
BEGIN
<variable_name>:=<object_type_name>();
END;
/

Explication de la syntaxe :

• La syntaxe ci-dessus illustre l'initialisation d'une instance de type objet avec une valeur nulle.
• L'objet lui-même n'est plus nul une fois initialisé, mais les attributs qu'il contient restent nuls jusqu'à ce que des valeurs leur soient attribuées.

Constructeurs

Un constructeur est une méthode implicite d'un objet, accessible par son nom identique à celui de son type. Lors de la première utilisation de l'objet, ce constructeur est appelé implicitement.

Vous pouvez également initialiser des objets à l'aide de ces constructeurs. Un constructeur peut être défini explicitement en définissant un membre dans le corps du type d'objet portant le même nom que le type d'objet.

Exemple 1: Dans l'exemple suivant, nous utilisons le membre de type objet pour insérer des enregistrements dans la table `emp` avec les valeurs `('RRR', 1005, 20000, 1000)` et `('PPP', 1006, 20000, 1001)`. Une fois les données insérées, nous les affichons à l'aide du membre de type objet. Nous utilisons également un constructeur explicite pour initialiser l'identifiant du responsable avec la valeur par défaut 1001 pour le deuxième enregistrement.

Nous procédons en suivant les étapes suivantes.

• Étape 1 : Créer le type d’objet et le corps du type d’objet.
• Étape 2 : Créez un bloc anonyme pour appeler le type d'objet via le constructeur implicite pour emp_no 1005.
• Étape 3 : Créez un bloc anonyme pour appeler le type d'objet via le constructeur explicite pour emp_no 1006.

Étape 1) Créer un type d'objet et un corps de type d'objet.

La capture d'écran ci-dessous montre la création de la spécification de type d'objet emp_object avec ses attributs et ses membres.

CREATE TYPE emp_object AS OBJECT(
emp_no NUMBER,
emp_name VARCHAR2(50),
salary NUMBER,
manager NUMBER,
CONSTRUCTOR FUNCTION emp_object(p_emp_no NUMBER, p_emp_name VARCHAR2,
p_salary NUMBER) RETURN SELF AS RESULT),
MEMBER PROCEDURE insert_records,
MEMBER PROCEDURE display_records);
/

La capture d'écran ci-dessous montre la création du corps de type emp_object avec le constructeur explicite et les procédures membres.

CREATE OR REPLACE TYPE BODY emp_object AS
CONSTRUCTOR FUNCTION emp_object(p_emp_no NUMBER,p_emp_name VARCHAR2,
p_salary NUMBER)
RETURN SELF AS RESULT
IS
BEGIN
Dbms_output.put_line('Constructor fired..');
SELF.emp_no:=p_emp_no;
SELF.emp_name:=p_emp_name;
SELF.salary:=p_salary;
SELF.manager:=1001;
RETURN;
END;
MEMBER PROCEDURE insert_records
IS
BEGIN
INSERT INTO emp VALUES(emp_no,emp_name,salary,manager);
END;
MEMBER PROCEDURE display_records
IS
BEGIN
Dbms_output.put_line('Employee Name:'||emp_name);
Dbms_output.put_line('Employee Number:'||emp_no);
Dbms_output.put_line('Salary:'||salary);
Dbms_output.put_line('Manager:'||manager);
END;
END;
/

Code Explication

• Code lignes 1-9 : Création du type d'objet « emp_object » avec 4 attributs et 3 membres. Il contient la définition d'un constructeur avec seulement 3 paramètres. (Le constructeur implicite réel possède autant de paramètres que d'attributs présents dans le type d'objet.)
• Code ligne 10: Création du corps du type.
• Code lignes 11-21 : Définition du constructeur explicite. Attribution des valeurs des paramètres aux attributs et attribution de la valeur par défaut « 1001 » à l’attribut « manager ».
• Code lignes 22-26 : Définition du membre 'insert_records', dans lequel les valeurs des attributs sont insérées dans la table 'emp'.
• Code lignes 27-34 : Définition du membre 'display_records', qui affiche les valeurs des attributs de type objet.

Sortie :

Type créé

Corps de type créé

Étape 2) Création d'un bloc anonyme pour appeler le type d'objet créé via le constructeur implicite pour emp_no 1005.

La capture d'écran ci-dessous montre le bloc anonyme qui appelle emp_object via le constructeur implicite.

DECLARE
guru_emp_det emp_object;
BEGIN
guru_emp_det:=emp_object(1005,'RRR',20000,1000);
guru_emp_det.display_records;
guru_emp_det.insert_records;
COMMIT;
END;

Code Explication

• Code lignes 37-45 : Insertion des enregistrements via le constructeur implicite. L'appel au constructeur contient le nombre réel de valeurs d'attributs.
• Code ligne 38: Déclare 'guru_emp_det' comme type d'objet 'emp_object'.
• Code ligne 41: L'instruction 'guru_emp_det.display_records' appelle le membre 'display_records' et les valeurs des attributs sont affichées.
• Code ligne 42: L'instruction 'guru_emp_det.insert_records' appelle le membre 'insert_records' et les valeurs des attributs sont insérées dans la table. Le bloc effectue ensuite la validation. transaction.

Sortie :

Nom de l'employé : RRR

Numéro d'employé : 1005

Salaire: 20000

Gestionnaire : 1000

Étape 3) Création d'un bloc anonyme pour appeler le type d'objet créé via le constructeur explicite pour emp_no 1006.

La capture d'écran ci-dessous montre le bloc anonyme qui appelle emp_object via le constructeur explicite avec trois arguments.

DECLARE
guru_emp_det emp_object;
BEGIN
guru_emp_det:=emp_object(1006,'PPP',20000);
guru_emp_det.display_records;
guru_emp_det.insert_records;
COMMIT;
END;
/

Sortie

Employee Name:PPP 
Employee Number:1006 
Salary:20000 
Manager:1001

Code Explication:

• Code lignes 46-53 : Insertion de l'enregistrement à l'aide du constructeur explicite.
• Code ligne 46: Déclare 'guru_emp_det' comme type d'objet 'emp_object'.
• Code ligne 50: L'instruction 'guru_emp_det.display_records' appelle le membre 'display_records' et les valeurs des attributs sont affichées.
• Code ligne 51: L'instruction « guru_emp_det.insert_records » appelle la méthode « insert_records » et les valeurs des attributs sont insérées dans la table. Comme seuls trois arguments sont fournis, le constructeur explicite attribue à l'identifiant du responsable sa valeur par défaut, 1001.

Héritage dans le type d'objet

La propriété d'héritage permet à un sous-type d'objet d'accéder à tous les attributs et membres du super-type d'objet, ou type d'objet parent.

Le type sous-objet est appelé type d'objet hérité, et le type super-objet est appelé type d'objet parent. La syntaxe ci-dessous illustre la création des types d'objets parent et hérité. La capture d'écran ci-dessous montre la syntaxe du type parent (SUPER), marquée comme NON DÉFINITIVE.

CREATE TYPE <object_type_name_parent> AS OBJECT
(
<attribute_l><datatype>,
.
.
)NOT FINAL;
/

Explication de la syntaxe :

• La syntaxe ci-dessus illustre la création du type SUPER. La clause NOT FINAL autorise l'héritage de ce type.

La capture d'écran ci-dessous montre la syntaxe du type hérité (SUB) créée avec le mot-clé UNDER.

CREATE TYPE<object_type_name_sub>UNDER<object_type_name_parent>
(
<attribute_l><datatype>,
.
);
/

Explication de la syntaxe :

• La syntaxe ci-dessus illustre la création du type SUB. Il contient tous les membres et attributs du type d'objet parent.

Exemple 1: Dans l'exemple ci-dessous, nous utilisons la propriété d'héritage pour insérer un enregistrement avec l'identifiant de gestionnaire « 1002 » pour l'enregistrement (« RRR », 1007, 20000). Nous exécutons le programme en suivant les étapes suivantes.

• Étape 1 : Créer le type SUPER.
• Étape 2 : Créez le type SUB et le corps.
• Étape 3 : Créez un bloc anonyme pour appeler le type SUB.

Étape 1) Créer un type SUPER ou un type parent.

La capture d'écran ci-dessous montre la création du supertype emp_object avec la clause NOT FINAL.

CREATE TYPE emp_object AS OBJECT(
emp_no NUMBER,
emp_name VARCHAR2(50),
salary NUMBER,
manager NUMBER,
CONSTRUCTOR FUNCTION emp_object(p_emp_no NUMBER,p_emp_name VARCHAR2(50),
p_salary NUMBER)RETURN SELF AS RESULT),
MEMBER PROCEDURE insert_records,
MEMBER PROCEDURE display_records)NOT FINAL;
/

Code Explication:

• Code lignes 1-9 : Création du type objet « emp_object » avec 4 attributs et 3 membres. Il contient la définition d'un constructeur avec seulement 3 paramètres. Déclaré comme « NOT FINAL », il s'agit d'un type parent.

Étape 2) Créez un sous-type sous le type SUPER.

La capture d'écran ci-dessous montre le type hérité sub_emp_object et son corps en cours de création.

CREATE OR REPLACE TYPE sub_emp_object 
UNDER emp_object
(default_manager NUMBER,MEMBER PROCEDURE insert_default_mgr);
/


CREATE OR REPLACE TYPE BODY sub_emp_object 
AS
MEMBER PROCEDURE insert_default_mgr 
IS
BEGIN
INSERT INTO emp
VALUES(emp_no,emp_name,salary,manager);
END;
END;
/

Code Explication:

• Code lignes 10-13 : Création de 'sub_emp_object' en tant que type hérité avec un attribut supplémentaire 'default_manager' et une déclaration de procédure membre.
• Code ligne 14: Création du corps pour le type d'objet hérité.
• Code lignes 16-21 : Définition de la procédure membre qui insère des enregistrements dans la table « emp » avec les valeurs du type d'objet SUPER, à l'exception de la valeur du responsable. Pour cette dernière, elle utilise « default_manager » du type SUB.

Étape 3) Création d'un bloc anonyme pour appeler le type SUB.

La capture d'écran ci-dessous montre le bloc anonyme qui appelle le type SUB et insère l'identifiant du gestionnaire par défaut.

DECLARE
guru_emp_det sub_emp_object;
BEGIN
guru_emp_det:= sub_emp_object(1007,'RRR',20000,1000,1002);
guru_emp_det.insert_default_mgr;
COMMIT;
END;
/

Code Explication:

• Code ligne 25: Déclaration de 'guru_emp_det' comme type 'sub_emp_object'.
• Code ligne 27: Initialisation de l'objet avec le constructeur implicite. Ce constructeur possède 5 paramètres (4 attributs du type PARENT et 1 attribut du type SUB). Le dernier paramètre (1002) définit la valeur de l'attribut default_manager.
• Code ligne 28: Appel de la fonction membre 'insert_default_mgr' pour insérer l'enregistrement avec l'identifiant du gestionnaire par défaut passé dans le constructeur.

Égalité des objets PL/SQL

Les instances d'objets appartenant au même type peuvent être comparées afin de déterminer leur égalité. Pour ce faire, le type d'objet requiert une méthode spécifique appelée méthode ORDER.

Cette méthode ORDER doit être une fonction qui renvoie un type numérique. Elle prend deux paramètres en entrée (premier paramètre : l’identifiant de l’instance de l’objet lui-même ; deuxième paramètre : l’identifiant d’une autre instance d’objet).

Les identifiants des deux instances d'objet sont comparés, et le résultat est renvoyé sous forme de nombre.

• Une valeur positive indique que l'instance de l'objet SELF est supérieure à l'autre instance.
• Une valeur négative indique que l'instance de l'objet SELF est inférieure à l'autre instance.
• Zéro indique que l'instance de l'objet SELF est égale à l'autre instance.
• Si l'une des deux instances est nulle, la fonction renvoie null.

La capture d'écran ci-dessous illustre la syntaxe de la fonction membre ORDER qui doit être incluse dans le corps du type pour la vérification d'égalité.

CREATE TYPE BODY<object_type_name_ 1>AS OBJECT
(
  ORDER MEMBER FUNCTION match(<parameter> object_type_name_ 1)
  RETURN INTEGER IS
  BEGIN
    IF <attribute_name>parameter <attribute_name>THEN
      RETURN -1; --any negative number will do
    ELSIF id>c.id THEN
      RETURN 1; --any positive number will do
    ELSE
      RETURN 0;
    END IF;
  END;
  .
  .
);
/

Explication de la syntaxe :

• La syntaxe ci-dessus montre la fonction ORDER qui doit être incluse dans le corps du type pour la vérification d'égalité.
• Le paramètre de cette fonction doit être une instance du même type d'objet.
• La fonction peut être appelée comme « obj_instance_1.match(obj_instance_2) », et cette expression renvoie la valeur numérique indiquée, où obj_instance_1 et obj_instance_2 sont des instances du type d'objet.

Exemple 1: Dans l'exemple suivant, nous comparons deux objets. Nous créons deux instances et comparons leur attribut « salaire ». Cette opération se déroule en deux étapes.

• Étape 1 : Créer le type d’objet et le corps.
• Étape 2 : Créer le bloc anonyme pour comparer les instances d’objet.

Étape 1) Création du type d'objet et du corps.

Les captures d'écran ci-dessous montrent la spécification emp_object_equality et son corps, qui définit la fonction ORDER qui compare l'attribut salary.

CREATE TYPE emp_object_equality AS OBJECT(
salary NUMBER,
ORDER MEMBER FUNCTION equals(c emp_object_equality)RETURN INTEGER);
/

CREATE TYPE BODY emp_object_equality AS
ORDER MEMBER FUNCTION equals(c emp_object_equality)RETURN INTEGER 
IS
BEGIN
IF salary<c.salary
THEN RETURN -1;
ELSIF salary>c.salary
THEN RETURN 1;
ELSE
RETURN 0;
END IF;
END;
END;
/

Code Explication:

• Code lignes 1-4 : Création du type d'objet 'emp_object_equality' avec 1 attribut et 1 membre.
• Code lignes 6-16 : Définition de la fonction ORDER qui compare l'attribut « salaire » de l'instance SELF et de l'instance du paramètre. Elle renvoie une valeur négative si le salaire de SELF est inférieur, une valeur positive s'il est supérieur, et 0 si les salaires sont égaux.

Code Sortie :

Type créé

Étape 2) Création du bloc anonyme pour comparer les instances d'objet.

La capture d'écran ci-dessous montre le bloc anonyme qui compare deux instances de emp_object_equality par salaire.

DECLARE
l_obj_1 emp_object_equality;
l_obj_2 emp_object_equality;
BEGIN
l_obj_1:=emp_object_equality(15000); 
l_obj_2:=emp_object_equality(17000);
IF l_obj_1.equals(l_obj_2)>0
THEN
Dbms_output.put_line('Salary of first instance is greater');
ELSIF l_obj_1.equals(l_obj_2)<0
THEN
Dbms_output.put_line('Salary of second instance is greater'); 
ELSE
Dbms_output.put_line('Salaries are equal');
END IF;
END;
/

Sortie

Salary of second instance is greater

Code Explication:

• Code ligne 20: Déclaration de 'l_obj_1' de type 'emp_object_equality'.
• Code ligne 21: Déclaration de 'l_obj_2' de type 'emp_object_equality'.
• Code ligne 23: Initialisation de 'l_obj_1' avec la valeur du salaire '15000'.
• Code ligne 24: Initialisation de 'l_obj_2' avec la valeur du salaire '17000'.
• Code lignes 25-33 : Impression du message en fonction du numéro renvoyé par la fonction ORDER.

FAQ