Oracle Tutoriel sur les types d'objets PL/SQL avec des EXEMPLES

Par : Fiona Brun Fiona Brun
Hours Le kit de préparation mis à jour

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. Ils sont organisés autour d'« objets » plutôt que d'« actions », c'est-à-dire que les programmes sont conçus pour fonctionner et interagir avec l'objet dans son ensemble plutôt qu'avec une action unique. Ce concept permet au programmeur de renseigner et de manipuler les détails au niveau des entités d'objet.

L'image ci-dessous montre un exemple du type d'objet dans lequel un compte bancaire est considéré comme une entité objet. Les attributs d'objet incluent des éléments qui contiennent certaines valeurs d'attribut, par exemple dans le compte bancaire ; il s'agit du numéro de compte, du solde bancaire, etc., tandis que les méthodes objets décrivent des éléments tels que le calcul du taux d'intérêt, la génération d'un relevé bancaire, etc., qui nécessitent l'exécution d'un certain processus.

Types d'objets en PL/SQL

En PL/SQL, la programmation orientée objet est basée sur les types d'objets.

Un type d'objet peut représenter n'importe quelle entité du monde réel. Nous allons discuter d'autres types d'objets dans ce chapitre.

Composants des types d'objet

PL / SQL Le type d’objet contient principalement deux composants.

  1. Attributs
  2. Membres/Méthodes

Attributs

Les attributs sont la colonne ou le champ dans lequel les données sont stockées. Chaque attribut sera mappé au type de données qui définit le type de traitement et de stockage pour cet attribut. L'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 les méthodes sont des sous-programmes définis dans le type d'objet. Ils ne sont utilisés pour stocker aucune donnée. Ils sont principalement utilisés pour définir un processus à l'intérieur du type d'objet. Pour des exemples de validation des données avant de remplir le type d'objet. Ils sont déclarés dans la section type d'objet et définis dans la section corps du type d'objet du type d'objet. La section Corps dans le type d’objet est une partie facultative. Si aucun membre n’est présent, alors un type d’objet ne contiendra aucune partie de corps.

Créer un objet dans Oracle

Un type d'objet ne peut pas être créé au niveau du sous-programme. Il ne peut être créé qu'au niveau du schéma. Une fois le type d'objet défini dans le schéma, il peut être utilisé dans les sous-programmes. Le type d'objet peut être créé en utilisant 'CREATE TYPE'. Le corps du type ne peut être créé qu'après avoir créé son type d'objet.

Créer un objet dans OracleCréer un objet dans Oracle

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 montre la création de 'OBJECT' avec des attributs et de 'OBJECT-BODY' avec des méthodes.
  • Les méthodes peuvent également être surchargées dans le corps de l'objet.

ARTICLES LIÉS

Initialisation de la déclaration du type d'objet

Comme les autres composants PL/SQL, les types d’objets doivent également être déclarés avant de les utiliser dans le programme.

Une fois le type d'objet créé, il peut être utilisé dans la section déclarative du sous-programme pour déclarer une variable de ce type d'objet.

Chaque fois qu'une variable est déclarée dans le sous-programme comme type d'objet, au moment de l'exécution, une nouvelle instance du type d'objet sera créée, et cette instance nouvellement créée peut être référencée au nom de la variable. De cette manière, un seul type d'objet peut stocker plusieurs valeurs sous différentes instances.

Initialisation de la déclaration du type d'objet

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

Explication de la syntaxe :

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

Une fois que la variable est déclarée comme type d'objet dans un sous-programme, elle sera atomiquement nulle, c'est-à-dire que l'objet entier lui-même sera nul. Il doit être initialisé avec des valeurs pour les utiliser dans le programme. Ils peuvent être initialisés à l'aide de constructeurs.

Les constructeurs sont la méthode implicite d'un objet qui peut être référencée avec le même nom que celui du type d'objet. La syntaxe ci-dessous montre l'initialisation du type d'objet.

Initialisation de la déclaration du type d'objet

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

Explication de la syntaxe :

  • La syntaxe ci-dessus montre l'initialisation de l'instance de type d'objet avec une valeur nulle.
  • Désormais, l'objet lui-même n'est pas nul car il a été initialisé, mais les attributs à l'intérieur de l'objet seront nuls car nous n'avons attribué aucune valeur à ces attributs.

Constructeurs

Les constructeurs sont la méthode implicite d'un objet qui peut être référencée avec le même nom que celui du type d'objet. Chaque fois que l'objet est référencé pour la première fois, ce constructeur sera appelé implicitement.

Nous pouvons également initialiser les objets en utilisant ces constructeurs. Le constructeur peut être défini explicitement en définissant le membre dans le corps du type d'objet avec le même nom que le type d'objet.

Exemple 1: Dans l'exemple suivant, nous allons utiliser le membre de type objet pour insérer l'enregistrement 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 allons les afficher en utilisant un membre de type objet. Nous allons également utiliser le constructeur explicite pour renseigner par défaut l'identifiant du gestionnaire avec la valeur 1001 pour le deuxième enregistrement.

Nous allons l'exécuter dans les étapes ci-dessous.

  • Step1:
  • Créer un type d'objet
  • Corps du type d'objet
  • Étape 2 : Création d'un bloc anonyme pour appeler le type d'objet créé via un constructeur implicite pour emp_no 1005.
  • Étape 3 : Création d'un bloc anonyme pour appeler le type d'objet créé via un constructeur explicite pour emp_no 1006.

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

Constructeurs

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);
/

Constructeurs

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.managerial:=1001;
RETURN;
END:
MEMBER PROCEDURE insert_records
IS
BEGIN
INSERT INTO emp VALUES(emp_noemp_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:
/

Explication du code

  • Ligne de code 1-9: Création du type d'objet 'emp_object' avec 4 attributs et 3 membres. Il contient la définition des constructeurs avec seulement 3 paramètres. (Le constructeur implicite réel contiendra le nombre de paramètres égal au nombre d'attributs présents dans le type d'objet)
  • Ligne de code 10: Création du corps du type.
  • Ligne de code 11-21: Définition du constructeur explicite. Attribution de la valeur du paramètre aux attributs et attribution de la valeur à l'attribut « manager » avec la valeur par défaut « 1001 ».
  • Ligne de code 22-26: Définition du membre 'insert_records' dans lequel les valeurs des attributs sont insérées dans la table 'emp'.
  • Ligne de code 27-34: Définition du membre 'display_records' dans lequel afficher les valeurs des attributs de type d'objet.

Sortie

Type créé

Corps de type créé

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

Constructeurs

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;

Explication du code

  • Ligne de code 37-45: Insertion des enregistrements à l'aide du constructeur implicite. L'appel au constructeur contient le nombre réel de valeurs d'attributs.
  • Ligne de code 38: Déclare le guru_emp_det comme type d'objet de 'emp_object'.
  • Ligne de code 41: L'instruction 'guru_emp_det.display_records' a appelé la fonction membre 'diplay_records' et les valeurs des attributs sont affichées
  • Ligne de code 42: L'instruction 'guru_emp_det.insert_records' a appelé la fonction membre 'insert_records' et les valeurs des attributs sont insérées dans le tableau.

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 un constructeur explicite pour emp_no 1006

Constructeurs

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

Explication du code :

  • Ligne de code 46-53: Insertion des enregistrements à l'aide du constructeur explicite.
  • Ligne de code 46: Déclare le guru_emp_det comme type d'objet de 'emp_object'.
  • Ligne de code 50: L'instruction 'guru_emp_det.display_records' a appelé la fonction membre 'display_records' et les valeurs des attributs sont affichées
  • Ligne de code 51: L'instruction 'guru_emp_det.insert_records' a appelé la fonction membre 'insert_records' et les valeurs des attributs sont insérées dans le tableau.

Héritage dans le type d'objet

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

Le type de sous-objet est appelé type d'objet hérité et le type de super-objet est appelé type d'objet parent. La syntaxe ci-dessous montre comment créer un type d'objet parent et hérité.

Héritage dans le type d'objet

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

Explication de la syntaxe :

  • La syntaxe ci-dessus montre la création du type SUPER.

Héritage dans le type d'objet

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

Explication de la syntaxe :

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

Exemple1: Dans l'exemple ci-dessous, nous allons utiliser la propriété d'héritage pour insérer l'enregistrement avec l'identifiant de gestionnaire « 1002 » pour l'enregistrement suivant (« RRR », 1007, 20000).

Nous allons exécuter le programme ci-dessus dans les étapes suivantes

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

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

Héritage dans le type d'objet

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;
/

Explication du code :

  • Ligne de code 1-9: Création du type d'objet 'emp_object' avec 4 attributs et 3 membres. Il contient la définition des constructeurs avec seulement 3 paramètres. Il a été déclaré comme « NON FINAL », il s'agit donc d'un type parent.

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

Héritage dans le type d'objet

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;
/

Explication du code :

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

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

Héritage dans le type d'objet

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;
/

Explication du code :

  • Ligne de code 25: Déclarer 'guru_emp_det' comme type 'sub_emp_object'.
  • Ligne de code 27: Initialisation de l'objet avec le constructeur implicite. Le constructeur a 5 paramètres (4 attributs du type PARENT et 2 attributs du type SUB). Le dernier paramètre (1002) définit la valeur de l'attribut default_manager
  • Ligne de code 28: Appel du membre 'insert_default_mgr' pour insérer les enregistrements avec l'identifiant de gestionnaire par défaut transmis dans le constructeur.

Égalité des objets PL/SQL

L'instance d'objet qui appartient aux mêmes objets peut être comparée pour vérifier son égalité. Pour cela, nous devons avoir la méthode spéciale dans le type d'objet appelée méthode 'ORDER'.

Cette méthode 'ORDER' doit être la fonction qui renvoie le type numérique. Il prend deux paramètres en entrée (premier paramètre : identifiant de l'instance d'auto-objet, deuxième paramètre : identifiant d'une autre instance d'objet).

L'identifiant des deux instances d'objet est comparé et le résultat est renvoyé sous forme numérique.

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

Égalité des objets PL/SQL

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 de l'égalité.
  • Le paramètre de cette fonction doit être une instance du même type d'objet.
  • La fonction ci-dessus peut être appelée « obj_instance_1.match(obj_instance_2) » et cette expression renverra la valeur numérique comme indiqué, où obj_instance_1 et obj_instance_2 sont l'instance de object_type_name.

Example1: Dans l'exemple suivant, nous allons voir comment comparer deux objets. Nous allons créer deux instances et comparer l'attribut 'salaire' entre elles. Nous allons procéder en deux étapes.

  • Étape 1 : Création du type et du corps de l'objet.
  • Étape 2 : Création du bloc anonyme pour appeler et comparer l'instance d'objet.

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

Égalité des objets PL/SQL

Égalité des objets PL/SQL

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;
/

Explication du code :

  • Ligne de code 1 à 4 : Création du type d'objet 'emp_object_equality' avec 1 attribut et 1 membre.
  • Ligne de code 6-16: Définition de la fonction ORDER qui compare l'attribut 'salary' de l'instance SELF et le type d'instance de paramètre. Il renvoie négatif si le salaire SELF est inférieur ou positif si le salaire SELF est supérieur et 0 si les salaires sont égaux.

Sortie de code :

Type créé

Étape 2) Création du bloc anonyme pour appeler comparer l'instance d'objet.

Égalité des objets PL/SQL

DECLARE
l_obj_l emp_object_equality;
l_obj_2 emp_object_equality;
BEGIN
l_obj_l:=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_l.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

Explication du code :

  • Ligne de code 20: Déclaration du l_obj_1 de type emp_object_equality.
  • Ligne de code 21: Déclaration du l_obj_2 de type emp_object_equality.
  • Ligne de code 23: Initialisation de l_obj_1 avec une valeur de salaire de '15000'
  • Ligne de code 24: Initialisation de l_obj_1 avec une valeur de salaire de '17000'
  • Ligne de code 25-33: Imprime le message en fonction du numéro de retour de la fonction COMMANDE.

Résumé

Dans ce chapitre, nous avons vu le type d'objet et ses propriétés. Nous avons également discuté des constructeurs, des membres, des attributs, de l'héritage et de l'égalité dans les objets PL/SQL.

Résumez cet article avec :