• Reconocer identificadores válidos y no válidos.
• Enumerar los usos de variables.
• Declarar e inicializar variables.
• Enumeración y descripción de distintos tipos de datos.
• Identificar los beneficios de utilizar el atributo %TYPE.
• Declarar, usar y mostrar variables de entorno(Bind Variables).
• Enumerar los usos de variables.
• Declarar e inicializar variables.
• Enumeración y descripción de distintos tipos de datos.
• Identificar los beneficios de utilizar el atributo %TYPE.
• Declarar, usar y mostrar variables de entorno(Bind Variables).
NOTA: Usamos como ejemplo la Base de Datos: ORCL, la cual viene por defecto en cualquier versión de ORACLE.
____________________________________________________________________________________
Variables en PL/SQL.
Con PL/SQL, puede declarar variables y, a continuación, utilizarlas en SQL y sentencias procedimentales.
Las variables se utilizan para almacenar datos y luego manipular los valores.
Ejemplo:
La sentencia recupera el nombre y departamento de la tabla. Para poder manipular los datos extraídos es necesario almacenarlos. Las variables se utilizan para almacenar los valores temporalmente. Se puede utilizar el valor almacenado en estas variables para el procesamiento y la manipulación de los mismos. Las variables pueden almacenar cualquier objeto de PL/SQL, tales como tipos, cursores y subprogramas.
La Reutilización es otra de las ventajas de la declaración de variables. Después que se declaran, se pueden utilizar repetidamente en una aplicación, refiriéndose a ellas varias veces en varios estados.
Requerimiento para Nombres de Variables:
Un nombre de variable:
• Debe comenzar con una letra.
• Pueden incluir letras o números.
• Puede incluir caracteres especiales (como $, _, y #).
• Debe contener no más de 30 caracteres.
• No debe incluir palabras reservadas.
____________________________________________________________________________________
Habilitando la Salida/OUTPUT en Bloques PL/SQL.
PL/SQL no proporciona funcionalidad de entrada o salida. Por lo tanto, es necesario utilizar paquetes predefinidos de Oracle para tales fines. Para generar una salida, debe realizar lo siguiente:
1. Ejecutar el siguiente comando:
SET SERVEROUTPUT ON
Nota: Para habilitar la salida en SQL*Plus, debe emitir explícitamente el comando SET SERVEROUTPUT ON
2. En el bloque PL/SQL, utilice el procedimiento PUT_LINE del paquete DBMS_OUTPUT para mostrar la salida. Pasar el valor a ser mostrado en pantalla como argumento del procedimiento. Luego el procedimiento da salida al argumento.
Ejemplo:
SET SERVEROUTPUT ON
DECLARE
v_nombre VARCHAR2(5) := 'Jorge';
BEGIN
DBMS_OUTPUT.PUT_LINE('El valor de la Variable es: : '||v_nombre);
END;
/*En este ejemplo usamos el comando: SET SERVEROUTPUT ON para habilitar la salida del bloque, declaramos una variable que inicializamos con el valor 'Jorge', luego usamos el procedimiento PUT_LINE del paquete: DBMS_OUTPUT para visualizar la cadena: 'El valor de la Variable es: : ' concatenada con el valor de la variable.*/
---OUTPUT:
____________________________________________________________________________________
Manejo de Variables en PL/SQL.
Las variables son:• Declaradas y (opcionalmente) inicializadas en la sección declarativa.
• Utilizadas, pasandoles nuevos valores en la sección ejecutable.
• Pasadas como parámetros a subprogramas de PL/SQL.
• Utilizadas para alojar la salida de un subprograma PL/SQL.
Puede utilizar variables de las siguientes maneras:
Declarar e inicializarlas en la sección declarativa: Puedes declarar variables en la parte declarativa de cualquier bloque PL/SQL, subprograma o paquete. Al declararlas: se les asigna espacio de almacenamiento para alojar valores, se les especifica sus tipos de datos, y se les asigna un hombre a la ubicación de almacenamiento para así hacer referencia a ellas. Al declararlas también puede asignar un valor inicial e imponer la restricción NOT NULL en ellas. Las referencias a plazo (Forward References) no están permitidas. Debe declarar una variable antes de hacer referencia a ella en otras sentencias, incluyendo otras sentencias declarativas.
Utilizarlas y asignar nuevos valores en la sección ejecutable: En la sección ejecutable, el valor existente de la variable puede ser reemplazado con un nuevo valor.
Pasarlas como parámetros a subprogramas de PL/SQL: Los subprogramas pueden tomar parámetros. Puede pasar variables como parámetros a subprogramas.
Utilizarlas para mostrar la salida de un subprograma de PL/SQL: Las variables pueden ser usadas para alojar el valor devuelto por una función.
Sintaxis:
identifier [CONSTANT] datatype [NOT NULL]
[:= | DEFAULT expr];
En la Sintaxis:
• identifier: es el nombre de la variable.
• CONSTANT: limita la variable de modo que su valor no puede cambiar (Las constantes deben ser inicializadas.)
• datatype: es un escalar, compuesto, referencia o tipo de datos LOB.
• NOT NULL: Restringe la variable de manera que contiene un valor (Las variables NOT NULL deben inicializarse.)
• expr: es cualquier expresión PL/SQL que puede ser una expresión literal, otra variable o una expresión que incluya operadores y funciones.
Ejemplos:
• identifier: es el nombre de la variable.
• CONSTANT: limita la variable de modo que su valor no puede cambiar (Las constantes deben ser inicializadas.)
• datatype: es un escalar, compuesto, referencia o tipo de datos LOB.
• NOT NULL: Restringe la variable de manera que contiene un valor (Las variables NOT NULL deben inicializarse.)
• expr: es cualquier expresión PL/SQL que puede ser una expresión literal, otra variable o una expresión que incluya operadores y funciones.
Ejemplos:
DECLARE
v_fecha DATE;
v_deptno NUMBER(2) NOT NULL := 10;
v_lugar VARCHAR2(13) DEFAULT 'Atlanta';
c_comm CONSTANT NUMBER := 1400;
/*En este ejemplo declaramos 3 variables y 1 constante; Notar como le asignamos valores a algunas de ellas al momento de declararlas. Las constantes deben ser inicializadas con un valor al momento de declararlas...*/
---
SET SERVEROUTPUT ON
DECLARE
v_miNombre VARCHAR2(10);
BEGIN
DBMS_OUTPUT.PUT_LINE('Mi nombre es: '|| v_miNombre);
v_miNombre := 'MoQueTe';
DBMS_OUTPUT.PUT_LINE('Mi nombre es: '|| v_miNombre);
END;
BEGIN
v_miNombre := 'Steven';
DBMS_OUTPUT.PUT_LINE('Mi nombre es: '|| v_miNombre);
END;
SET SERVEROUTPUT ON
DECLARE
v_miNombre VARCHAR2(10);
BEGIN
DBMS_OUTPUT.PUT_LINE('Mi nombre es: '|| v_miNombre);
v_miNombre := 'MoQueTe';
DBMS_OUTPUT.PUT_LINE('Mi nombre es: '|| v_miNombre);
END;
/*En este bloque, la variable v_miNombre está declarada pero no inicializada. Luego en la sección ejecutable se le asigna el valor MoQueTe. Posteriormente con PUT_LINE se muestra la cadena: 'Mi nombre es: ' concatenada con el valor de la variable. Notar que el primer PUT_LINE no muestra el nombre ya que la variable contenía un valor NULL hasta ese momento.*/
---OUTPUT:
SET SERVEROUTPUT ON
DECLARE
v_miNombre VARCHAR2(10) := 'Jonny';DECLARE
BEGIN
v_miNombre := 'Steven';
DBMS_OUTPUT.PUT_LINE('Mi nombre es: '|| v_miNombre);
END;
/*En este bloque, la variable v_miNombre está declarada y inicializada con el valor Jonny. Luego en la sección ejecutable se le asigna el valor Steven. Posteriormente con PUT_LINE se muestra la cadena: 'Mi nombre es: ' concatenada con el valor de la variable. Notar que se muestra Steven en lugar de Jonny, esto debido a que el valor de la variable fue cambiado en la session ejecutable antes de mostrarse en pantalla.*/
---OUTPUT
--
En los dos últimos bloques notamos que:
• Los literales de cadena deben ir entre comillas simples. Si la cadena tiene una comilla como en "Today's Date", la cadena sería: 'Today''s Date'..
• El operador de asignación es: ":=".
Delimitadores en literales de cadena.
Si la cadena contiene un apóstrofe (idéntica a una comilla simple), debe doblar el signo de comillas, como en el siguiente ejemplo:
v_event VARCHAR2(15) := 'Father''s day';
El primer signo de comillas actúa como el carácter de escape. Pero esto hace que su cadena luzca algo complicada, sobre todo si tiene instrucciones/sentencias SQL como cadenas. Como otra opción se puede especificar cualquier carácter que no este presente en la cadena como un delimitador. El siguiente ejemplo muestra cómo utilizar la notación q' para especificar el delimitador.
SET SERVEROUTPUT ON
DECLARE
v_event VARCHAR2(15);
BEGIN
v_event := q'!Father's day!';
DBMS_OUTPUT.PUT_LINE('In Dom.Rep. the last Sunday of June is: '|| v_event );
v_event := q'[Mother's day]';
DBMS_OUTPUT.PUT_LINE('In Dom.Rep. the last Sunday of May is: '|| v_event );
END;
/*Como vemos se empieza con la cadena q' si desea utilizar un delimitador. El carácter que sigue la notación es el delimitador utilizado. Introduzca la cadena después de especificar el delimitador, cerrar el delimitador, y cerrar la notación con una comilla simple.*/
---OUTPUT:
El ejemplo utiliza: ! y [ como delimitadores. Como se ve a continuación:
v_event := q'!Father's day!';
v_event := q'[Mother's day]';
Puede comparar estos dos últimos ejemplos con el que usamos con dos comillas simples: ''.
La imagen ilustra los siguientes tipos de datos:
Ejemplos de Variables Escalares.
SET SERVEROUTPUT ON
DECLARE
v_event VARCHAR2(15);
BEGIN
v_event := q'!Father's day!';
DBMS_OUTPUT.PUT_LINE('In Dom.Rep. the last Sunday of June is: '|| v_event );
v_event := q'[Mother's day]';
DBMS_OUTPUT.PUT_LINE('In Dom.Rep. the last Sunday of May is: '|| v_event );
END;
/*Como vemos se empieza con la cadena q' si desea utilizar un delimitador. El carácter que sigue la notación es el delimitador utilizado. Introduzca la cadena después de especificar el delimitador, cerrar el delimitador, y cerrar la notación con una comilla simple.*/
---OUTPUT:
v_event := q'!Father's day!';
v_event := q'[Mother's day]';
Puede comparar estos dos últimos ejemplos con el que usamos con dos comillas simples: ''.
____________________________________________________________________________________
Los Tipos de Variables.
Todas las variables PL/SQL tienen un tipo de datos, que especifica un formato de almacenamiento, limitaciones, y un rango de valores válidos. PL/SQL es compatible con la mayoría de categorías de tipos de datos, incluyendo escalar, de referencia, large object (LOB), y compuestos(composite).
• Tipos de datos escalares: Estos almacenan un valor único. El valor depende del tipo de dato de la variable. Por ejemplo, la variable v_miNombre de los ejemplos anteriores es de tipo VARCHAR2. Por lo tanto, v_miNombre puede contener un valor de cadena. PL/SQL también soporta variables booleanas.
• Tipos de datos de referencia: Estos contienen valores, llamados punteros(pointers), que apuntan a una ubicación de almacenamiento.
• Tipos de datos LOB: Contienen valores, llamados localizadores(locators), que especifican la ubicación de objetos grandes (tales como imágenes gráficas) que se almacenan fuera de la tabla.
• Tipos de datos compuestos(Composite): Estos están disponibles mediante el uso de Colecciones (collection) y variables tipo registro(records). Las colecciones y registros de PL/SQL contienen elementos internos que se pueden tratar como variables individuales.
Las variables que no son PL/SQL(Non-PL/SQL) incluyen variables declaradas en programas pre-compilados, en pantallas de aplicaciones de Forms y variables host.
La imagen ilustra los siguientes tipos de datos:
• TRUE: representa un valor booleano(BOOLEAN).
• 15-ENE-09: representa una fecha(DATE).
• La imagen representa un BLOB.
• Todo el texto del cuadro puede representar un tipo de dato VARCHAR2 o CLOB.
• 256.120,08 representa un tipo de datos NUMBER con precisión y escala.
• El rollo de película representa un BFILE.
• El nombre de la ciudad de Atlanta representa un tipo de datos VARCHAR2.
Algunas pautas a seguir cuando se declara variables PL/SQL.
• Seguir una nomenclatura consistentes y convencional, por ejemplo, puede usar el v_nombre para representar una variable y c_name para representar una constante. La clave es adoptar una nomenclatura coherente para facilitar la identificación.
• Utilice identificadores significativos y apropiados para las variables. Por ejemplo, considere el uso de v_salario y sal_con_comision en lugar de salario1 y salario2.
• Si se utiliza la restricción NOT NULL, debe asignar un valor cuando se declara la variable.
• En declaraciones de constantes, la palabra clave CONSTANT debe preceder(antes) al especificador de tipo. Una constante se debe inicializar en su declaración; de lo contrario, se obtiene un error de compilación. Después de inicializar una constante, no se puede cambiar su valor.
• Inicializar la variable con el operador de asignación (:=) o con la palabra reservada: DEFAULT. Si no se asigna un valor inicial, la variable contiene NULL de forma predeterminada hasta que asigne un valor. Para asignar o reasignar un valor a una variable, usar una sentencia de asignación PL/SQL. Sin embargo, es una buena práctica de programación inicializar todas las variables al declararlas.
• Dos objetos pueden tener el mismo nombre sólo si se definen en diferentes bloques. Donde coexisten, se puede calificar con etiquetas y utilizarlas.
• Evitar el uso de nombres de columna como identificadores. Si una variable PL/SQL es usada en una sentencia SQL y tiene el mismo nombre que una columna, el servidor Oracle asume que es la columna que se está haciendo referencia.
Ejemplo:
DECLARE
employee_id NUMBER(6);
BEGIN
SELECT employee_id INTO employee_id
FROM employees
WHERE last_name = 'Kochhar';
END;
/*Aunque este ejemplo funciona, Resulta difícil de leer y/o mantener un código en el cual se utilicen variables con nombres de tablas o columnas de la Base de Datos.*/
---
• Imponer la restricción NOT NULL cuando la variable debe contener un valor. No puede asignar valores nulos a una variable que se defina como NOT NULL. La restricción NOT NULL debe ser seguida de una cláusula de inicialización.
Ejemplo:
v_ciudad VARCHAR2(30) NOT NULL := 'San Juan de la Maguana';
____________________________________________________________________________________
Nomenclaturas Convencionales para Estructuras PL/SQL.
Structura
PL/SQL
|
Patron
|
Ejemplo
|
Variable
|
v_nombre_variable
|
v_monto_pag
|
Constante
|
c_nombre_variable
|
c_monto_pag
|
Parametro
|
p_nombre_parametro
|
p_codigo
|
Variable Bind
(host)
|
b_nombre_bind
|
b_salario
|
Cursor
|
cur_nombre_cursor
|
cur_clientes
|
Record
|
rec_nombre_Record
|
rec_clientes
|
Type
|
type_nombre_type
|
type_ limites
|
Exception
|
e_nombre_excepcion
|
e_invalid_product
|
File
handle
|
f_ nombre_archivo
|
f_archivo_cuentas
|
____________________________________________________________________________________
Tipo de Datos Escalares.
PL/SQL proporciona una variedad de tipos de datos predefinidos. Puede elegir desde un entero, punto flotante(floating point), carácter, booleano, fecha, colección, y LOB. Por ahora vamos a cubrir los tipos básicos que se utilizan con frecuencia en programas de PL/SQL.
Un tipo de datos escalar posee un valor único y no tiene componentes internos. Los tipos de datos escalares se pueden clasificar en cuatro categorías: numéricos, caracteres, fechas y booleano. Los tipos Caracteres y Numéricos tienen subtipos que asocian un tipo base a una restricción. Por ejemplo, INTEGER y POSITIVE son subtipos del tipo base NUMBER.
Tipo de Dato
|
Description
|
CHAR[(Tamaño_Máximo)]
|
Tipo base para caracteres de
longitud fija de hasta 32,767 bytes. Si no se especifica una longitud máxima,
la longitud predeterminada es 1.
|
VARCHAR2(Tamaño_Máximo)
|
Tipo base para caracteres de longitud variable de hasta
32.767 bytes. No hay un tamaño predeterminado para variables y constantes VARCHAR2.
|
NUMBER[(precisión, escala)]
|
Número que tiene precisión p
y escala s. La precisión p puede variar de 1 a 38. La escala
s
puede variar de -84 a 127.
|
BINARY_INTEGER
|
Tipo base para enteros entre -2,147,483,647
a 2,147,483,647
|
PLS_INTEGER
|
Tipo base para enteros entre -2,147,483,647
y 2,147,483,647. Los valores PLS_INTEGER requieren menos espacio de
almacenamiento y son más rápidos que los valores NUMBER. En Oracle Database
11g, los tipos de datos y PLS_INTEGER BINARY_INTEGER son idénticos. Las
operaciones aritméticas con valores PLS_INTEGER y BINARY_INTEGER son más
rápidas que con valores NUMBER.
|
BOOLEAN
|
Tipo base que almacena uno de los
tres posibles valores utilizados para cálculos lógicos: VERDADERO(TRUE),
FALSO(FALSE) y NULL.
|
BINARY_FLOAT
|
Representa un número de coma
flotante en formato IEEE 754. Se requiere 5 bytes para almacenar el valor.
|
BINARY_DOUBLE
|
Representa un número de coma
flotante en formato IEEE 754. Se requiere 5 bytes para almacenar el valor.
|
DATE
|
Tipo base para fechas y horas. Los
valores de la fecha incluyen la hora del día en segundos desde la medianoche.
El rango de fechas esta entre 4712 A. C. y A. D. 9999.
|
TIMESTAMP
|
El tipo de dato TIMESTAMP, El
cual es una extensión del tipo de dato DATE, almacena el año, mes, día, hora,
minuto, segundo y fracción de segundo. La sintaxis es la siguiente
TIMESTAMP[(precisión)], donde el
parámetro precisión(opcional) especifica el número de dígitos en la parte
fraccionaria del campo segundos. Para especificar la precisión, debe utilizar
un número entero en el rango de 0-9. El valor por defecto es 6.
|
TIMESTAMP WITH TIME ZONE
|
El tipo de dato TIMESTAMP WITH
TIME ZONE, El cual es una extensión del tipo de dato TIMESTAMP, incluye un
desplazamiento de zona horaria. El desplazamiento de zona horaria es la
diferencia (en horas y minutos) entre la hora local y el Tiempo Universal
Coordinado (UTC), anteriormente conocido como meridiano de Greenwich. La
sintaxis es TIMESTAMP[(precisión)] WITH TIME ZONE, donde el parámetro
precisión(opcional) especifica el número de dígitos de la parte fraccionaria
del campo de segundos. Para especificar la precisión, debe utilizar un número
entero en el rango de 0-9. El valor por defecto es 6.
|
TIMESTAMP WITH
LOCAL TIME ZONE
|
El tipo de dato TIMESTAMP WITH LOCAL TIME ZONE, El cual es una extensión del tipo de dato TIMESTAMP, incluye un
desplazamiento de zona horaria. El desplazamiento de zona horaria es la
diferencia (en horas y minutos) entre la hora local y el Tiempo Universal
Coordinado (UTC), anteriormente conocido como meridiano de Greenwich. La
sintaxis es TIMESTAMP[(precisión)] WITH LOCAL TIME ZONE donde el parámetro precisión(opcional)
especifica el número de dígitos de la parte fraccionaria del campo de
segundos. No se puede utilizar una constante simbólica o variable para
especificar la precisión; debe utilizar un literal entero en el rango de 0-9.
El valor por defecto es 6.
Este tipo de datos se diferencia
de TIMESTAMP WITH TIME ZONE en que, al insertar un valor en una columna de
Base de Datos, el valor se normaliza a la zona horaria de la Base de Datos, y
el desplazamiento de zona horaria no se almacena en la columna. Al recuperar
el valor, el servidor Oracle devuelve el valor en la zona horaria local de la
sesión.
|
INTERVAL YEAR TO
MONTH
|
Se utiliza el tipo de dato INTERVAL YEAR TO MONTH para almacenar y manipular intervalos de años y meses. La sintaxis es INTERVAL YEAR[(precisión)] TO MONTH, donde precisión especifica el número de dígitos en el campo de años.
No se puede utilizar una constante simbólica o variable para especificar la
precisión; debe utilizar un literal entero en el rango de 0-4. El valor
predeterminado es 2.
|
INTERVAL DAY TO
SECOND
|
Se utiliza el tipo de dato INTERVAL DAY TO SECOND para almacenar y manipular los intervalos de días, horas, minutos y
segundos. La sintaxis es INTERVAL DAY[(precision1)] TO SECOND[(precision2)], donde precision1 y precision2 especifican el número de
dígitos en los campos de días y segundos, respectivamente. En ambos casos, no
se puede utilizar una constante simbólica o variable para especificar la
precisión; debe utilizar un literal entero en el rango de 0-9. Los
valores por defecto son 2 y 6, respectivamente.
|
DECLARE
v_puesto VARCHAR2(9);
v_contador BINARY_INTEGER := 0;
v_sal_total_dept NUMBER(9,2) := 0;
v_fecha_orden DATE := SYSDATE + 7;
c_tasa_impuesto CONSTANT NUMBER(3,2) := 18.25;
v_validez BOOLEAN NOT NULL := TRUE;
Los usos de estas variables son:
• v_puesto: para almacenar los tipos de puestos de los empleados.
• v_contador: para contar las iteraciones de un bucle.
• v_sal_total_dept: para almacenar la suma total un departamento x.
• v_fecha_orden: para almacenar la fecha de algún pedido.
• c_tasa_impuesto: para almacenar la tasa de impuesto. Este valor no cambia durante todo el bloque PL/SQL.
• v_validez: para indicar si una pieza de información es válida o inválida;
Atributo %TYPE.
Las variables PL/SQL se suelen declara para sostener y manipular los datos almacenados en una Base de Datos. Cuando declara variables PL/SQL para alojar los valores de columnas, debe asegurarse de que la variable tenga la precisión y el tipo de dato correcto. Si no lo es, se produce un error de PL/SQL durante la ejecución. Si usted tiene que diseñar grandes subprogramas, esto puede llevar mucho tiempo y es propenso a errores.
En lugar de codificar el tipo de dato y la precisión de una variable de manera fija(hard-coding), puede utilizar el atributo %TYPE para declarar una variable de acuerdo a una columna de la Base de Datos o a otra variable ya declarada. El atributo %TYPE se utiliza con mayor frecuencia cuando el valor almacenado en la variable se deriva de una columna en la Base de Batos. Cuando se utiliza el atributo %TYPE para declarar una variable, se debe prefijar con la tabla de base de datos y el nombre de la columna. Si se hace referencia a una variable declarada anteriormente, se debe prefijar el nombre de la variable previamente declarada a la variable por declarar.
Ventajas del Atributo %TYPE.
• Puede evitar errores causados por la falta de coincidencia del tipo de dato o por precisión errónea.
• Puede evitar codificar de manera fija(hard-coding) el tipo de datos de una variable.
• No es necesario que cambie la declaración de la variable, si la definición de columna cambia. Si ya ha declarado variables sin el atributo %TYPE para una columna de Base de Datos, el bloque PL/SQL puede arrojar errores si se altera la columna para la cual fue declarada la variable. Cuando se utiliza el atributo %TYPE, PL/SQL determina el tipo de datos y el tamaño de la variable cuando se compila el bloque. Esto asegura que una variable de este tipo es siempre compatible con la columna que se utiliza para rellenar la misma.
Sintaxis:
identificador table.column_name%TYPE;
Ejemplos:
DECLARE
v_emp_apellido employees.last_name%TYPE;
--
v_balance NUMBER(7,2);
v_min_balance v_balance%TYPE := 1000;
Los usos de estas variables son:
• v_emp_apellido: es del mismo tipo de dato que el campo last_name de la tabla employees, por lo cual es ideal para almacenar valores extraídos de esa columna.
• v_balance: es de tipo de dato numérico con precisión 7,2, la cual puede ser usada para almacenar un valor numérico x.
• v_min_balance: es del mismo tipo de dato que la variable v_balance anteriormente declarada.
Nota: Si declara una variable con la restricción NOT NULL y luego declara otra del mismo tipo usando el Atributo %TYPE, la restricción NOT NULL es trasferida a la segunda variable.
Ejemplo:
DECLARE
v_balance NUMBER(7,2) NOT NULL := 5345.4;
v_min_balance v_balance%TYPE;
BEGIN
NULL;
END;
/*Recibimos un error al tratar de compilar este bloque ya que la variable v_min_balance es también NOT NULL por cual debe ser inicializada al momento de su declaración.*/
---OUTPUT:
Una restricción NOT NULL en un campo de Base de Datos no se aplica a variables que se declaren con el Atributo %TYPE. Por lo tanto, si se declara una variable con %TYPE de una columna de Base de Datos definida como NOT NULL, puede asignar el valor NULL a la variable.
Variables Booleanas.
Con PL/SQL, puede comparar variables en sentencias SQL y/o sentencias de procedimiento. Estas comparaciones, llamadas expresiones booleanas, consisten en expresiones simples o complejas separadas por operadores relacionales. En una sentencia SQL, puede utilizar expresiones booleanas para especificar las filas de una tabla a ser afectadas por una sentencia. En sentencias de procedimiento, las expresiones booleanas son la base para el control condicional. NULL representa un valor perdido, inaplicable, o desconocido.
• Sólo puede asignar los valores TRUE, FALSE y NULL(Si no tiene la Restricción NOT NULL) a una variable BOOLEAN.
• Las expresiones condicionales utilizan los operadores lógicos AND y OR, y el operador unario NOT para comprobar los valores de las variables.
• Expresiones aritméticas, de carácter, y de fecha se pueden utilizar para devolver un valor booleano.
Ejemplos:
emp_sal1 := 50000;
emp_sal2 := 60000;
--
emp_sal1 < emp_sal2
/*La instruction anterior retorna TRUE(verdadera) ya que el valor de emp_sal1 es menor que el de emp_sal2.*/
---
DECLARE
bandera BOOLEAN := FALSE;
BEGIN
bandera := TRUE;
END;
/*Declaramos la variable booleana bandera y la inicializamos con FALSE, posteriormente le asignamos el valor TRUE.*/
---
Variables del Tipo de Dato LOB.
Los Large Objects (LOB) están destinados a almacenar una gran cantidad de datos. Una columna de Base de Datos puede ser de la categoría LOB. Con la categoría de tipos de datos LOB(BLOB, CLOB, ...), puede almacenar bloques de datos no estructurados (como texto, imágenes gráficas, clips de vídeo, y las formas de onda de sonido) de hasta 128 terabytes en función del tamaño de bloque de la Base de Datos. Los tipos de datos LOB permiten el acceso eficiente y aleatorio a los datos y pueden ser usados como atributos de un tipo de objeto.
• El tipo de dato Character Large Object (CLOB) se utiliza para almacenar grandes bloques de caracteres en la Base de Datos.
• El tipo de dato Binary Large Object (BLOB) se utiliza para almacenar grandes objetos binarios(estructurados o no-estructurados) en la Base de Datos. Los datos no son interpretados por la Base de Datos al momento de ser insertados o recuperados. Los mismos deben ser interpretados por las aplicaciones externas que hacen uso de ellos.
• El tipo de dato de archivo binario (BFILE) se utiliza para almacenar grandes archivos binarios. A diferencia de otros LOB, los BFILE se almacenan fuera de la Base de Batos. Estos podrían ser archivos del sistema operativo. Sólo se almacena en la Base de Batos un puntero del BFILE.
• El tipo de dato National Language Character Large Object (NCLOB) se utiliza para almacenar grandes bloques de datos de un solo byte(single-byte) o de varios bytes con ancho fijo(fixed-width multibyte) NCHAR Unicode en la Base de Datos.
Tipos de Datos Compuestos(Composite): Registros(Records) y Colecciones(Collections).
Anteriormente mencionamos que, un tipo de dato escalar puede alojar un valor único el cual no tiene componentes internos. Los tipos de datos Composite llamados PL/SQL Records y PL/SQL Collections tienen componentes internos que puede tratar como variables individuales.
En un Record de PL/SQL, los componentes internos llamados campos pueden ser de diferentes tipos de datos. Para acceder a cada campo debe usar la Sintaxis: nombre_record.nombre_campo. Una variable Records puede contener varias columnas de una tabla o una fila completa. Cada campo del Record corresponde a una columna de la tabla.
En una colección de PL/SQL, los componentes internos son siempre del mismo tipo de dato, los cuales se denominan elementos. Se accede a cada elemento por su subíndice único. Las listas y las matrices son ejemplos clásicos de las colecciones. Hay tres tipos de colecciones de PL/SQL: Matrices Asociativas(Associative Arrays), Tablas Anidadas(Nested Table) y los tipos VARRAY.
Las Variables Bind.
Las variables Bind, son variables que se crean en un entorno fuera de la Base de Datos(Host Environment). Por esta razón, a veces se les llama variables Host.
Usos de las variables Bind:
Las variables Bind se crean en el ambiente y no en la parte declarativa de un bloque PL/SQL. Por esta razón, las variables Bind son accesibles incluso después de la ejecución del bloque. Una vez creadas, las variables Bind pueden ser utilizadas y manipuladas por varios subprogramas. Pueden ser utilizadas en instrucciones SQL y bloques PL/SQL al igual que cualquier otra variable. Estas variables se pueden pasar en tiempo de ejecución como valores de entrada o salida de subprogramas de PL/SQL.
Nota: Una variable Bind es una variable de entorno, no una variable global.
Creación de variables Bind:
Para crear una variable Bind en SQL Developer, utilice el comando VARIABLE. Por ejemplo, debe declarar una variable de tipo NUMBER o VARCHAR2 de la siguiente manera:
VARIABLE return_code NUMBER
VARIABLE return_msg VARCHAR2(30)
Visualizando valores en variables Bind:
Para hacer referencia y ver el valor de una variable Bind en SQL Developer debe utilizar el comando PRINT. Puede hacer referencia a una variable Bind en un programa PL/SQL precediendo la variable con dos puntos.
Nota: Si crear una variable Bind de tipo NUMBER, no puede especificar la precisión y escala. Sin embargo, puede especificar el tamaño de las cadenas de caracteres. Una variable NUMBER en Oracle es almacenada en la misma manera, independientemente de la dimensión. El servidor de Oracle utiliza el mismo número de bytes para almacenar 7, 70, y 0,0734. Con cadenas de caracteres, el usuario tiene que especificar el tamaño de modo que el número necesario de bytes se puede asignar.
Ejemplo:
VARIABLE b_result NUMBER
BEGIN
SELECT (salary*12) + NVL(commission_pct,0) INTO :b_result
FROM employees
WHERE employee_id = 144;
END;
/
PRINT b_result
/*Notar como en el bloque PL/SQL anterior se crea y utiliza la variable Bind: b_result.*/
---OUTPUT:
Referenciando Variables Bind.
Como se dijo anteriormente, después de crear una variable Bind, puede hacer referencia a ella en cualquier otra instrucción SQL o programa PL/SQL.
Ejemplo:
VARIABLE b_emp_salario NUMBER
BEGIN
SELECT salary INTO :b_emp_salario
FROM employees
WHERE employee_id = 178;
END;
/
PRINT b_emp_salario
SELECT first_name, last_name
FROM employees
WHERE salary = :b_emp_salario;
/*En el ejemplo, b_emp_salario se crea como una variable Bind en el bloque PL/SQL. Luego se utiliza en la instrucción SELECT.*/
---OUTPUT:
Usando AUTOPRINT con Variables Bind.
Utilice el comando SET AUTOPRINT ON para mostrar automáticamente el contenido de las variables Bind utilizadas en un bloque PL/SQL.
Ejemplo:
VARIABLE b_emp_sal NUMBER
SET AUTOPRINT ON
DECLARE
v_num_emp NUMBER(6) := &numero_empleado;
BEGIN
SELECT salary INTO :b_emp_sal
FROM employees
WHERE employee_id = v_num_emp;
END;
/*En el ejemplo:
• Se crea la variable Bind: b_emp_sal y se especifica el comando SET AUTOPRINT ON.
• Declaramos la variable: v_num_emp, y se inicializa con otra variable de sustitución llenada por el usuario al momento de ejecución.
• Por último, la variable Bind y las variables temporales se utilizan en la sección ejecutable del bloque PL/SQL.*/
---OUTPUT:
Cuando se introduce en un número de empleado válido este caso 100 la salida de la variable Bind se imprime automáticamente. La variable Bind contiene el sueldo correspondiente al número de empleado que proporcionó el usuario.
_____________________________________________________________________________________
Fuente: Oracle Database: PL/SQL Fundamentals
