- INTRODUCCIÓN:
Los type de Oracle son tipos de datos que declara el usuario, y que puede ser utilizado para la declaración de variables, tanto en procedimientos, como en funciones, o incluso en tablas.
Con el tiempo, los type de Oracle, han derivado en lo que en Java o C++ se denominan clases. Es decir que cada tipo esta formado por sus objetos y sus atributos:
· Los objetos son variables, que a su vez pueden pertenecer a otros tipos.
· Los atributos son procedimientos o funciones que pertenecen al type.
A parte, los type de Oracle tienen todas las características propias de la programación orientada a objetos:
· Encapsulación: El type contiene dentro todos los objetos y atributos correspondientes, siendo estos últimos transparentes para el usuario.
· Herencia: Un type puede heredar todos los objetos y atributos de otro.
· Polimorfismo: El type de oracle, una vez heredado puede añadir nuevos objetos y atributos.
- TYPE OBJECT:
Los tipos de objeto, crean tipos de variable, que puede contener, objetos de otro tipo y métodos. La sintaxis de creación es:
CREATE OR REPLACE TYPE NOMBRE IS OBJECT (
VARIABLE1 TIPO_DATO,
VARIABLE2 TIPO_DATO,
…
VARIABLEN TIPO DATO,
MEMBER PROCEDURE NOMBRE_PROC (VAR IN TIPO_DATO) ,
MEMBER FUNCTION NOMBRE_FUNC (VAR IN TIPO_DATO) RETURN TIPO_DATO
);
CREATE OR REPLACE TYPE BODY NOMBRE IS (
MEMBER PROCEDURE NOMBRE PROC (VAR) IS
VRIABLE1 TIPO_DATO,
VARIABLE2 TIPO_DATO,
…
VARIABLEN TIPO DATO
BEGIN
CODIGO;
END NOMBRPE PROC;
END;
Como podemos observar, los tipos tienen dos partes: el TYPE, que contiene la especificación de objetos y métodos, y el TYPE BODY, que contiene el código de los métodos del tipo. Evidentemente sólo se hará el TYPE BODY si existen métodos en el tipo.
Una vez creado el tipo, Oracle lo va a interpretar como un tipo de dato, y como tal podrá ser usado en cualquier parte. Así, al declarar una variable en un procedimiento o en una función, podremos usar el tipo como si se tratara de otro tipo de datos tales como varchar2 o number.
De hecho, también se puede utilizar como tipo de datos en tablas, declarandolo después como una neested table, de la siguiente manera:
CREATE OR REPLACE TYPE CourseList AS TABLE OF VARCHAR2(64);
CREATE TABLE department (
name VARCHAR2(20),
director VARCHAR2(20),
office VARCHAR2(20),
courses CourseList)
NESTED TABLE courses STORE AS courses_tab;
Una vez creada la tabla, se pueden realizar operaciones de insert, update, delete o select como en cualquier otra tabla. Para más información visitar la página : http://www.psoug.org/reference/nested_tab.html .
- TYPE TABLE:
El tipo de tabla, crea una tabla física en base de datos, de un tipo de datos concreto (lo cual incluye cualquier otro type que haya creado en la base de datos) sobre la que, a lo demás, podremos ejecutar sentencias sql. Para poder ejecutar sentencias SQL sobre un tipo tabla, hay que basar este en un tipo de objeto (type object) en el cual cada objeto será el campo de la base de datos; así como crear el tipo tabla a nivel de base de datos. Si el tipo de tabla es creado a nivel de procedimiento o función no podrá ser usado para ejecutar sentencias SQL.
La sintaxis de creación es la siguiente:
CREATE OR REPLACE TYPE NOMBRE_TIPO IS TABLE OF TIPO_DATO;
Una vez creado el tipo, podremos usarlo dentro de cualquier procedimiento o función. Para ello tendremos que inicializarlo, con un constructor. Una vez hecho esto, se utilizará con la referencia al tipo de dato usado (en caso de que sea otro type). Por ejemplo:
Creamos el type que nos va a decir los campos:
CREATE OR REPLACE TYPE PERSON IS OBJECT(
NOMBRE VARCHAR2(10),
APELLIDOS VARCHAR2(15));
CREATE OR REPLACE TYPE PERSON_TABLE IS TABLE OF PERSON;
Para usarlo en un procedimiento, lo haríamos de la siguiente manera:
CREATE OR REPLACE PROCEDURE INTRO_PERSON IS
DECLARE
PERSON_DATES PERSON_TABLE;
NUM_PERSON NUMBER;
BEGIN
PERSON_DATES := PERSON_TABLE(); -- Constructor que inicializa la variable.
/* Introducimos los datos que queremos. En este caso, 3 nombres. Hacemos referencia,
como veis Al tipo inicial, y no al tipo de tabla, a la hora de rellenarlo. Esto es así
imprescindible. Con respecto al rellenado de las variables del tipo, se puede hacer referencia
por posición (escribiendo en la Posición adecuada el dato), o por referencia (tal y como está
relleno en el ejemplo)*/
PERSON_DATES.EXTEND;
PERSON_DATES(1) := PERSON(NOMBRE => ‘JUAN’, APELLIDOS => ‘RAMIREZ’);ç
PERSON_DATES.EXTEND;
PERSON_DATES(1) := PERSON(NOMBRE => ‘PEDRO’, APELLIDOS => ‘RAMIREZ’);
PERSON_DATES.EXTEND;
PERSON_DATES(1) := PERSON(NOMBRE => ‘FRANCISCO’, APELLIDOS => ‘PEREZ’);
/*Aplicamos ahora una sentencia SQL sobre la variable PERSON_DATES*/
SELECT COUNT(APELLIDOS)
INTO NUM_PERSON
FROM TABLE(CAST(PERSON_DATES AS PERSON_TABLE))
WHERE APELLIDOS LIKE ‘REMIREZ’;
DBMS_OUTPUT.PUT_LINE (‘Nº DE PERSONAS: ’ || NUM_PERSON) ;
END;
Podemos ver que al aplicar la sentecia SQL hay dos palabras clave importantes: TABLE y CAST.
La primera indica a Oracle que se trata de una tabla de memoria, y no de una tabla de base de datos.
La segunda hace un cast de conversión. Es necesario hacerlo, porque si no Oracle no reconoce el tipo.
- TYPE BODY:
Los procedimientos y funciones miembros de un tipo se programan igual que cualquier otro procedimiento o función. Lo único a tener en cuenta es que para hacer referencia a cualquiera de los atributos del tipo (cualquiera de las variables), se pondría la palabra self delante.
Ejemplo:
Supongamos que al typo PERSON creado anteriormente le añadimos como member functión la función validar:
MEMBER FUNCTION VALIDAR RETURN NUMBER IS
VALIDACION NUMBER;
BEGIN
IF SELF.NOMBRE = SELF.APELLIDOS THEN
VALIDACION := 1;
ELSE
VALIDACION = 0;
END IF;
RETURN VALIDACION;
END;
El procedimiento del ejemplo anterior podría usarse de la siguiente manera:
CREATE OR REPLACE PROCEDURE INTRO_PERSON IS
DECLARE
PERSON_DATES PERSON_TABLE;
NUM_PERSON NUMBER;
VALIDAR NUMBER;
BEGIN
PERSON_DATES := PERSON_TABLE(); -- Constructor que inicializa la variable.
/* Introducimos los datos que queremos. En este caso, 3 nombres. Hacemos referencia,
como veis Al tipo inicial, y no al tipo de tabla, a la hora de rellenarlo. Esto es así
imprescindible. Con respecto al rellenado de las variables del tipo, se puede hacer referencia
por posición (escribiendo en la Posición adecuada el dato), o por referencia (tal y como está
relleno en el ejemplo)*/
PERSON_DATES.EXTEND;
PERSON_DATES(1) := PERSON(NOMBRE => ‘JUAN’, APELLIDOS => ‘RAMIREZ’);
/*Validamos si el nombre no coincide con el apellido*/
VALIDAR:= PERSON.VALIDAR;
IF VALIDAR = 1 THEN
RAISE DUP_VAL_ON_INDEX;
END IF;
PERSON_DATES.EXTEND;
PERSON_DATES(1) := PERSON(NOMBRE => ‘PEDRO’, APELLIDOS => ‘RAMIREZ’);
/*Validamos si el nombre no coincide con el apellido*/
VALIDAR:= PERSON.VALIDAR;
IF VALIDAR = 1 THEN
RAISE DUP_VAL_ON_INDEX;
END IF;
PERSON_DATES.EXTEND;
PERSON_DATES(1) := PERSON(NOMBRE => ‘FRANCISCO’, APELLIDOS => ‘PEREZ’);
/*Validamos si el nombre no coincide con el apellido*/
VALIDAR:= PERSON.VALIDAR;
IF VALIDAR = 1 THEN
RAISE DUP_VAL_ON_INDEX;
END IF;
/*Aplicamos ahora una sentencia SQL sobre la variable PERSON_DATES*/
SELECT COUNT(APELLIDOS)
INTO NUM_PERSON
FROM TABLE(CAST(PERSON_DATES AS PERSON_TABLE))
WHERE APELLIDOS LIKE ‘REMIREZ’;
DBMS_OUTPUT.PUT_LINE (‘Nº DE PERSONAS: ’ || NUM_PERSON) ;
EXCEPTION
WHEN DUP_VAL_ON_INDEX
DBMS_OUTPUT.PUT_LINE (‘NO PUEDE COINCIDIR EL NOMBRE CON EL
APELLIDO’) ;
END;
- HERENCIA:
Para heredar se usa el comando UNDER. Si cogemos el tipo PERSON, del ejemplo anterior para crear un nuevo tipo, que a lo demás incluya el DNI, la sentencia sería:
CREATE OR REPLACE TYPE PERSON_COMPLEX UNDER PERSON (
DNI VARCHAR2(10)
);
Esto crearía un tipo llamado PERSON_COMPLEX, que tendría todos los atributos y métodos del tipo PERSON, más el atributo DNI.
