Oracle Tipuri de obiecte PL/SQL: CREATE TYPE cu exemple

Ce este tipul de obiect în PL/SQL?

Programarea orientată pe obiecte este potrivită în special pentru construirea de componente reutilizabile și aplicații complexe. Programele sunt organizate în jurul „obiectelor” mai degrabă decât al „acțiunilor”; adică, sunt concepute să lucreze și să interacționeze cu un întreg obiect, mai degrabă decât cu o singură acțiune. Această abordare permite programatorului să populeze și să manipuleze detalii la nivel de obiect-entitate.

Imaginea de mai jos prezintă un exemplu de tip de obiect în care un cont bancar este tratat ca o entitate obiect. Atributele obiectului conțin valori - pentru un cont bancar acestea sunt numărul contului, soldul bancar și așa mai departe - în timp ce metodele obiectului descriu acțiuni precum calcularea ratei dobânzii sau generarea unui extras de cont, fiecare dintre acestea necesitând un proces pentru a fi finalizată.

In PL / SQLProgramarea orientată pe obiecte se bazează pe tipuri de obiecte. Un tip de obiect poate reprezenta orice entitate din lumea reală. Secțiunile de mai jos explorează tipurile de obiecte, componentele acestora și modul de creare și utilizare a acestora.

Componentele tipurilor de obiecte

Un tip de obiect PL/SQL conține în principal două componente.

1. Atribute
2. Membri/Metode

Atribute

Atributele sunt coloanele sau câmpurile în care sunt stocate datele. Fiecare atribut este mapat la tipul de date care definește tipul de procesare și stocare pentru atributul respectiv. Un atribut poate avea orice valoare validă. Tip de date PL/SQL, sau poate fi de alt tip de obiect.

Membri/Metode

Membrii sau metodele sunt subprograme definite în interiorul tipului de obiect. Nu sunt utilizate pentru stocarea datelor; în schimb, definesc procesarea efectuată în interiorul tipului de obiect - de exemplu, validarea datelor înainte de popularea obiectului. Sunt declarate în specificația tipului de obiect și definite în corpul tipului de obiect. Corpul este opțional: dacă nu sunt prezenți membri, un tip de obiect nu are o parte a corpului.

Creați obiect în Oracle

Un tip de obiect nu poate fi creat la nivel de subprogram; acesta poate fi creat doar la nivel de schemă. Odată ce tipul de obiect este definit în schemă, acesta poate fi utilizat în subprograme. Tipul de obiect este creat folosind instrucțiunea „CREATE TYPE”, iar corpul tipului poate fi creat numai după ce tipul său de obiect există.

Capturile de ecran de mai jos prezintă sintaxa CREATE TYPE pentru specificația obiectului și sintaxa CREATE TYPE BODY care definește metodele acestuia.

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

Explicația sintaxei:

• Sintaxa de mai sus arată crearea unui OBJECT cu atribute și a unui OBJECT BODY cu metode.
• Metodele pot fi, de asemenea, supraîncărcate în corpul obiectului.

Declarația de inițializare a tipului de obiect

Ca și alte componente din PL/SQL, tipurile de obiecte trebuie declarate înainte de a fi utilizate într-un program. Odată ce tipul de obiect este creat, acesta poate fi utilizat în secțiunea declarativă a unui subprogram pentru a declara o variabilă de tipul respectiv de obiect.

Ori de câte ori o variabilă este declarată ca tip de obiect, la momentul execuției este creată o nouă instanță a tipului de obiect, iar această instanță nou creată este referită prin numele variabilei. În acest fel, un singur tip de obiect poate stoca mai multe valori sub instanțe diferite.

Captura de ecran de mai jos arată o variabilă declarată ca un tip de obiect în interiorul unui bloc PL/SQL.

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

Explicația sintaxei:

• Sintaxa de mai sus prezintă declararea unui variabil ca tip de obiect în secțiunea declarativă.

Odată ce variabila este declarată ca tip de obiect într-un subprogram, aceasta este atomic nulă — întregul obiect în sine este nul. Trebuie inițializată cu valori înainte de a putea fi utilizată în program. Obiectele sunt inițializate folosind constructori.

Constructorii sunt metodele implicite ale unui obiect la care se poate face referire cu același nume ca și tipul obiectului. Captura de ecran de mai jos prezintă inițializarea unei instanțe de tip obiect.

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

Explicația sintaxei:

• Sintaxa de mai sus arată inițializarea instanței de tip obiect cu o valoare nulă.
• Obiectul în sine nu mai este nul odată ce a fost inițializat, dar atributele din interiorul obiectului rămân nule până când li se atribuie valori.

Constructori

Constructorii sunt metodele implicite ale unui obiect la care se poate face referire cu același nume ca și tipul obiectului. Ori de câte ori se face referire la obiect pentru prima dată, acest constructor este apelat implicit.

De asemenea, puteți inițializa obiecte folosind acești constructori. Un constructor poate fi definit explicit prin definirea unui membru în corpul tipului de obiect cu același nume ca și tipul de obiect.

Exemplu 1: În exemplul următor, folosim membrul de tip obiect pentru a insera înregistrări în tabelul emp cu valorile ('RRR', 1005, 20000, 1000) și ('PPP', 1006, 20000, 1001). Odată ce datele sunt inserate, le afișăm folosind membrul de tip obiect. De asemenea, folosim un constructor explicit pentru a popula ID-ul managerului cu valoarea implicită 1001 pentru a doua înregistrare.

Îl executăm în următorii pași.

• Pasul 1: Creați tipul de obiect și corpul tipului de obiect.
• Pasul 2: Creați un bloc anonim pentru a apela tipul de obiect prin constructorul implicit pentru emp_no 1005.
• Pasul 3: Creați un bloc anonim pentru a apela tipul de obiect prin constructorul explicit pentru emp_no 1006.

Pasul 1) Creați tipul de obiect și corpul tipului de obiect.

Captura de ecran de mai jos prezintă specificația de tip de obiect emp_object creată împreună cu atributele și membrii săi.

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

Captura de ecran de mai jos arată corpul de tip emp_object creat cu constructorul explicit și procedurile membre.

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 Explicație

• Code liniile 1-9: Crearea tipului de obiect „emp_object” cu 4 atribute și 3 membri. Acesta conține definiția unui constructor cu doar 3 parametri. (Constructorul implicit real conține numărul de parametri egal cu numărul de atribute prezente în tipul de obiect.)
• Code linia 10: Crearea corpului tipului.
• Code liniile 11-21: Definirea constructorului explicit. Atribuirea valorilor parametrilor atributelor și atribuirea valorii implicite „1001” atributului „manager”.
• Code liniile 22-26: Definirea membrului „insert_records”, în care valorile atributelor sunt inserate în tabelul „emp”.
• Code liniile 27-34: Definirea membrului „display_records”, care afișează valorile atributelor de tip obiect.

ieșire:

Tip creat

Tip body creat

Pas 2) Crearea unui bloc anonim pentru a apela tipul de obiect creat prin constructorul implicit pentru emp_no 1005.

Captura de ecran de mai jos prezintă blocul anonim care apelează emp_object prin constructorul implicit.

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 Explicație

• Code liniile 37-45: Inserarea înregistrărilor folosind constructorul implicit. Apelul către constructor conține numărul real de valori ale atributelor.
• Code linia 38: Declară „guru_emp_det” ca fiind tipul de obiect „emp_object”.
• Code linia 41: Instrucțiunea „guru_emp_det.display_records” apelează membrul „display_records”, iar valorile atributelor sunt afișate.
• Code linia 42: Instrucțiunea „guru_emp_det.insert_records” apelează membrul „insert_records”, iar valorile atributelor sunt inserate în tabel. Blocul validează apoi tranzacție.

ieșire:

Numele angajatului: RRR

Număr de angajat: 1005

Salariu: 20000

Manager: 1000

Pas 3) Crearea unui bloc anonim pentru a apela tipul de obiect creat prin constructorul explicit pentru emp_no 1006.

Captura de ecran de mai jos prezintă blocul anonim care apelează emp_object prin constructorul explicit cu trei argumente.

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

producție

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

Code Explicaţie:

• Code liniile 46-53: Inserarea înregistrării folosind constructorul explicit.
• Code linia 46: Declară „guru_emp_det” ca fiind tipul de obiect „emp_object”.
• Code linia 50: Instrucțiunea „guru_emp_det.display_records” apelează membrul „display_records”, iar valorile atributelor sunt afișate.
• Code linia 51: Instrucțiunea „guru_emp_det.insert_records” apelează membrul „insert_records”, iar valorile atributelor sunt inserate în tabel. Deoarece sunt transmise doar trei argumente, constructorul explicit setează ID-ul managerului la valoarea implicită 1001.

Moștenirea în tipul obiectului

Proprietatea de moștenire permite unui tip de subobiect să acceseze toate atributele și membrii tipului de superobiect sau ai tipului de obiect părinte.

Tipul de sub-obiect se numește tipul de obiect moștenit, iar tipul de super-obiect se numește tipul de obiect părinte. Sintaxa de mai jos arată cum se creează tipuri de obiecte părinte și moștenite. Captura de ecran de mai jos prezintă sintaxa tipului părinte (SUPER) marcat ca NESFINAL.

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

Explicația sintaxei:

• Sintaxa de mai sus ilustrează crearea tipului SUPER. Clauza NOT FINAL permite moștenirea tipului.

Captura de ecran de mai jos prezintă sintaxa de tip moștenită (SUB) creată cu cuvântul cheie UNDER.

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

Explicația sintaxei:

• Sintaxa de mai sus prezintă crearea tipului SUB. Acesta conține toți membrii și atributele din tipul de obiect părinte.

Exemplu 1: În exemplul de mai jos, folosim proprietatea de moștenire pentru a insera o înregistrare cu ID-ul managerului „1002” pentru înregistrarea respectivă („RRR”, 1007, 20000). Executăm programul în următorii pași.

• Pasul 1: Creați tipul SUPER.
• Pasul 2: Creați tipul și corpul SUB.
• Pasul 3: Creați un bloc anonim pentru a apela tipul SUB.

Pasul 1) Creați tipul SUPER sau tipul Părinte.

Captura de ecran de mai jos arată super-tipul emp_object creat cu clauza 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 Explicaţie:

• Code liniile 1-9: Se creează tipul de obiect „emp_object” cu 4 atribute și 3 membri. Acesta conține definiția unui constructor cu doar 3 parametri. A fost declarat ca „NOT FINAL”, deci este un tip părinte.

Pasul 2) Creați tipul SUB sub tipul SUPER.

Captura de ecran de mai jos arată tipul moștenit sub_emp_object și corpul său în curs de creare.

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 Explicaţie:

• Code liniile 10-13: Crearea atributului „sub_emp_object” ca tip moștenit cu un atribut suplimentar „default_manager” și o declarație de procedură membru.
• Code linia 14: Crearea corpului pentru tipul de obiect moștenit.
• Code liniile 16-21: Definirea procedurii membre care inserează înregistrări în tabelul 'emp' cu valorile din tipul de obiect SUPER, cu excepția valorii manager. Pentru valoarea managerului, se utilizează 'default_manager' din tipul SUB.

Pasul 3) Crearea unui bloc anonim pentru apelarea tipului SUB.

Captura de ecran de mai jos prezintă blocul anonim care apelează tipul SUB și introduce ID-ul implicit al managerului.

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 Explicaţie:

• Code linia 25: Se declară „guru_emp_det” ca fiind de tipul „sub_emp_object”.
• Code linia 27: Inițializarea obiectului cu constructorul implicit. Constructorul are 5 parametri (4 atribute din tipul PARENT și 1 atribut din tipul SUB). Ultimul parametru (1002) definește valoarea atributului default_manager.
• Code linia 28: Apelarea membrului „insert_default_mgr” pentru a insera înregistrarea cu ID-ul implicit de manager transmis în constructor.

Egalitatea obiectelor PL/SQL

Instanțele obiectelor care aparțin aceluiași tip de obiect pot fi comparate pentru egalitate. Pentru a face acest lucru, tipul de obiect are nevoie de o metodă specială numită metoda ORDER.

Această metodă ORDER ar trebui să fie o funcție care returnează un tip numeric. Acceptă doi parametri ca intrare (primul parametru: id-ul instanței obiectului self; al doilea parametru: id-ul altei instanțe a obiectului).

ID-urile celor două instanțe de obiect sunt comparate, iar rezultatul este returnat sub formă de număr.

• O valoare pozitivă indică faptul că instanța obiectului SELF este mai mare decât cealaltă instanță.
• O valoare negativă indică faptul că instanța obiectului SELF este mai mică decât cealaltă instanță.
• Zero indică faptul că instanța obiectului SELF este egală cu cealaltă instanță.
• Dacă oricare dintre instanțe este nulă, funcția returnează null.

Captura de ecran de mai jos prezintă sintaxa funcției membru ORDER care trebuie inclusă în corpul tipului pentru verificarea egalității.

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

Explicația sintaxei:

• Sintaxa de mai sus arată funcția ORDER care trebuie inclusă în corpul tipului pentru verificarea egalității.
• Parametrul pentru această funcție ar trebui să fie o instanță de același tip de obiect.
• Funcția poate fi apelată ca „obj_instance_1.match(obj_instance_2)”, iar această expresie returnează valoarea numerică afișată, unde obj_instance_1 și obj_instance_2 sunt instanțe ale tipului de obiect.

Exemplu 1: În exemplul următor, comparăm două obiecte. Creăm două instanțe și comparăm atributul „salary” între ele. Facem acest lucru în doi pași.

• Pasul 1: Creați tipul și corpul obiectului.
• Pasul 2: Creați blocul anonim pentru a compara instanțele obiectului.

Pasul 1) Crearea tipului și corpului obiectului.

Capturile de ecran de mai jos prezintă specificația emp_object_equality și corpul acesteia, care definește funcția ORDER ce compară atributul salariu.

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 Explicaţie:

• Code liniile 1-4: Se creează tipul de obiect „emp_object_equality” cu 1 atribut și 1 membru.
• Code liniile 6-16: Definirea funcției ORDER care compară atributul „salariu” al instanței SELF cu instanța parametrului. Returnează o valoare negativă dacă salariul SELF este mai mic, o valoare pozitivă dacă salariul SELF este mai mare și 0 dacă salariile sunt egale.

Code ieșire:

Tip creat

Pasul 2) Crearea blocului anonim pentru compararea instanțelor obiectului.

Captura de ecran de mai jos prezintă blocul anonim care compară două instanțe emp_object_equality după salariu.

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

producție

Salary of second instance is greater

Code Explicaţie:

• Code linia 20: Declararea obiectului „l_obj_1′ de tipul „emp_object_equality”.
• Code linia 21: Declararea obiectului „l_obj_2′ de tipul „emp_object_equality”.
• Code linia 23: Se inițializează 'l_obj_1' cu valoarea salarială '15000'.
• Code linia 24: Se inițializează 'l_obj_2' cu valoarea salarială '17000'.
• Code liniile 25-33: Afișarea mesajului pe baza numărului returnat de funcția ORDER.

Întrebări frecvente