Your SlideShare is downloading. ×
  • Like
PL/SQL
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Now you can save presentations on your phone or tablet

Available for both IPhone and Android

Text the download link to your phone

Standard text messaging rates apply

PL/SQL

  • 34,064 views
Published

Capitulos PL/SQL 1-9 en espanol

Capitulos PL/SQL 1-9 en espanol

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
No Downloads

Views

Total Views
34,064
On SlideShare
0
From Embeds
0
Number of Embeds
11

Actions

Shares
Downloads
1,446
Comments
9
Likes
8

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. Marcela Gómez Loja 2008
  • 2.  
  • 3. DECLARACIÓN DE VARIABLES
  • 4.
    • Conocer la estructura de un bloque PL/SQL básico y sus secciones.
    • Declarar variables PL/SQL
    • Ejecutar un bloque PL/SQL
  • 5.
    • PL/SQL, consiste de tres secciones:
    • DECLARE
    • ……… ....
    • BEGIN
    • …………
    • EXCEPTION
    • ………… ..
    • END;
  • 6.  
  • 7. Ejecutando Sentencias y Bloques PL/SQL
    • DECLARE
    • v_variable VARCHAR2(5);
    • BEGIN
    • SELECT column_name
    • NTO v_variable
    • FROM table_name;
    • EXCEPTION
    • WHEN exception_name THEN
    • …………… ..
    • END;
  • 8.
    • Es importante:
    • Poner punto y coma (;) al final de una sentencia SQL o sentencia de control PL/SQL.
    • Cuando un bloque es ejecutado exitosamente sin errores de manejo y compilación, aparece el siguiente mensaje:
    • PL/SQL procedure successfully completed
    • Las palabras claves de sección DECLARE, BEGIN y EXCEPTION no van seguido de punto y coma.
    • END y todas las otras sentencias PL/SQL requieren un punto y coma para terminar la sentencia.
    • Se puede tener toda la expresión en una sola línea, pero este método no es recomendable para claridad o edición.
  • 9.
    • NOTA:
    • En PL/SQL a un error se lo llama excepción.
    • Con la modularidad es fácil solucionar un problema complejo esto gracias a que se puede trabajar en módulos.
  • 10. Tipos de bloque PL/SQL es un programa que tiene uno o más bloques. Estos bloques pueden estar separados o anidados unos con otros. Por lo tanto, un bloque puede representar una pequeña parte de otro bloque. [DECLARE] BEGIN [ EXCEPTION ] END; -- statements Anónimo DECLARE name BEGIN [EXCEPTION] END; IS --statements Procedimiento FUNTION name BEGIN [EXCEPTION] END; RETURN datatype --statements IS RETURN value; Función
  • 11.
    • Bloque anónimo.- es un bloque secreto. Estos son declarados en un punto en una aplicación donde son ejecutados. Se puede enraizar en un bloque anónimo dentro de un programa pre-compilado y dentro de iSQL*Plus o un servidor director. Los triggers en los componentes de Oracle Developer constan de estos bloques.
    • Sub-Programas.- son bloques nombrados en PL/SQL que pueden aceptar parámetros y pueden ser invocados. Se los puede declarar como procedimientos o como funcione. Generalmente se usa un procedimiento para ejecutar una acción y una función para computar un valor.
  • 12.
    • Usando los componentes de Oracle Developer (formas, reportes, y gráficos), tu puedes declarar procedimientos y funciones como parte de la aplicación (un formulario o reporte) y llamar a estos desde otros procedimientos, funciones y triggers dentro de una misma aplicación.
    • NOTA:
    • Una función es similar a un procedimiento, excepto que una función puede retornar un valor.
  • 13. Conceptos de programa
  • 14. La siguiente tabla contiene una idea general de los conceptos de programa de PL/SQL que usa un bloque básico.
  • 15.  
  • 16.  
  • 17. Uso de Variables
    • Con PL/SQL se puede declarar variables. Las variables pueden ser usadas para lo siguiente:
    • Almacenamiento Temporal de Datos: los datos pueden ser temporalmente guardados en una o más variables para ser usados cuando se validan los datos de entrada y para el procesamiento después en el proceso de circulación de datos.
    • Manipulación de Valores guardados: las variables pueden ser usadas para cálculos y otras manipulaciones de datos sin acceder a la base de datos.
  • 18.
    • Reusabilidad: después de ser declaradas, las variables pueden ser usadas repetidamente en una aplicación solo mencionándolas en otras declaraciones, otra declaración de sentencias.
    • Facilidad de mantenimiento: cuando use %TYPE y %ROWTYPE, usted declara variables, basando la declaración en la definición de una columna de una base de datos. Si una definición subyacente cambia, la declaración variable cambia en consecuencia al tiempo de ejecución. Esto suministra la independencia de datos, reduce el coste de mantenimiento, y permite que programas se adapten a los cambios de base de datos para cubrir nuevas necesidades de la empresa.
  • 19. Manejando variables en PL/SQL
    • Declaración y Inicialización de Variables en la sección de declaración: se puede declarar variables en la parte declarativa de PL/SQL de cualquier bloque, subprograma o paquete. Las declaraciones asignan un espacio para almacenar un valor, especifican el tipo de datos, y nombran la ubicación en donde se va a almacenar con el propósito de hacer referencia al valor. Las declaraciones también pueden atribuir un valor inicial e imponer la restricción NOT NULL en la variable. Se debe declarar una variable antes de mencionarla en otras declaraciones, incluyendo la declaración de otras sentencias.
  • 20.
    • Asignar nuevos valores para variables en la sección ejecutable: en la sección ejecutable, el valor existente de la variable es remplazado por un nuevo valor que es asignado para la variable.
    • Paso de valores en subprogramas PL/SQL a través de parámetros: existen tres modos de parámetros, IN (por defecto), OUT, y IN OUT. Use el parámetro IN para pasar valores al subprograma que está siendo llamado. Use el parámetro OUT para retornas valores al que llama a un subprograma. Y use el parámetro IN OUT para pasar valores iníciales a un subprograma que está siendo llamado y para devolver valores actualizados al que llama al subprograma.
  • 21. Tipos de Variables
    • Todas las variables PL/SQL tienen un tipo de dato, cuando se especifica el formato de almacenamiento, restricciones y validar el rango de valores. PL/SQL soporta cuatro categorías de tipos de datos: escalar, compuesto, referencia y LOB (objetos grandes), que se pueden utilizar para declarar variables, constantes y punteros.
    • Datos de tipo escalares sujetan un solo valor. Los principales tipos de datos son ésos que corresponden a un tipo de columna en las tablas de un servidor Oracle; PL/SQL también soporta variables booleanas.
  • 22.
    • Datos de tipo compuesto , como los registros, permiten que grupos de campos sean definidos y manipulados en bloques PL/SQL.
    • Los tipos de datos de referencia sujetan valores, llamados punteros, que designan otros ítems del programa.
    • Los tipos de datos LOB sujetan valores, llamados halladores, eso especifica la ubicación de objetos grandes (como ideas gráficas) que son guardados fuera de línea.
  • 23. Declaración de Variables PL/SQL Sintaxis: Identifier: es el nombre de la variable CONSTANT: restringe la variable con el propósito de que su valor no pueda cambiar; las constantes deben ser inicializadas.
  • 24. Data type: puede ser un escalar, compuesto, referenciado o LOB. NOT NULL: restringe a la variable para que tenga un valor . Expr: es cualquier expresión PL/SQL que puede ser una expresión literal, otra variable o una expresión que involucra operadores y funciones.
  • 25. Inicialización de variables y palabras claves Identifier: es el nombre de la variable escalar Expr: puede ser una variable, literal o llamada a una función, pero no a una columna de la base de datos. Las variables son inicializadas todo el tiempo en un bloque o subprograma. Por defecto las variables son inicializadas con NULL. Default: se puede usar la palabra clave de default en lugar del operador de asignación. NOT NULL: imponer la estricción NOT NULL cuando la variable debe contener un valor.
  • 26. Tipos de datos base escalares
  • 27.  
  • 28.  
  • 29.  
  • 30. Declaración de Variables Booleanas Este tipo de variables nos permiten realizar comparaciones a través de expresiones booleanas, estas pueden ser simples o complejas separadas por operadores relacionales. Ejemplo: v_sal1 := 50000; v_sal2 := 60000; La siguiente expresión es verdadera v_sal1 < v_sal2
  • 31. Declaración y inicialización de una variable booleana DECLARE v_flag BOOLEAN:= FALSE; BEGIN v_flag := TRUE; END; DBMS_OUTPUT.PUT_LINE Se puede declarar una variable principal o anfitriona, referenciarla en un bloque PL/SQL, y luego presentar su contenido en iSQL*Plus usando el comando PRINT. Otra alternativa para presentar que la información de un bloque de PL/SQL es DBMS_OUTPUT.PUT_LINE es un paquete oracle-supplied, y PUT_LINE es un procedimiento dentro de ese paquete.
  • 32. Dentro de un bloque PL/SQL, referencia DBMS_OUTPUT.PUT_LINE y entre paréntesis se especifica lo que se quiere que presente. El paquete debe estar primero permitido en una sesión en iSQL*Plus. Para ejecutar el paquete en iSQL*Plus se debe realizar con el comando SERVEROUTPUT ON. Ejemplo:
  • 33.  
  • 34.  
  • 35. SINTAXIS DE BLOQUE DE PL-SQL.
    • Declaración puede continuar después de varias líneas.
    • Una línea de PL-SQL contiene grupo de caracteres conocidos como unidades léxicas que pueden clasificarse como:
    • Delimitadores (simples y símbolos compuestos).
    • Identificadores (se incluye cualquier palabra reservada)
    • Literales.
    • Comentarios.
  • 36. IDENTIFICADORES.
    • Pueden contener 30 caracteres.
    • Deben empezar con un carácter alfabético.
    • Pueden contener números, signos de dólar, subrayar, y signos de números.
    • No pueden contener caracteres como guiones, slashes, y espacios.
    • No deben tener el mismo nombre de una columna de la tabla de la base de datos.
    • No deben haber palabras reservadas.
  • 37. SINTAXIS DE BLOQUE DE PL-SQL.
    • LITERALES.
    • Caracteres y fechas deben estar encerrados en comillas simples.
    • v_name := `Henderson`
    • Los números pueden ser simples valores o notaciones científicas.
    • Un slash (/) corre en bloques de PL-SQL en archivos de script o en herramientas tales como iSQL*PLUS.
  • 38. COMENTARIOS EN CODIGO.
    • Los comentarios en líneas simples se hacen con dos guiones (--)
    • Los comentarios para múltiples líneas se hace entre los símbolos /* y */. Ejm
    • DECLARE
    • ……
    • V_sal number (9,2);
    • BEGIN
    • /*calcular el salario anual basado en la fecha de contrato*/
    • V_sal : g_montly_sal *12;
    • END
  • 39. FUNCIONES DE SQL EN PL/SQL
    • Disponible en declaración de procedimientos:
    • Filas simples numeradas.
    • Caracteres de fila simple.
    • Conversión de tipos de datos.
    • Datos.
    • Timestamp
    • Grandes y mínimas.
    • Miscelánea de funciones.
    • No disponible en declaración de procedimientos:
    • decode
    • Grupo de funciones .
  • 40. FUNCIONES DE SQL EN PL/SQL: Ejemplo.
    • Construyendo una lista de correo para una empresa:
    • V_mailing_address := v_name o CHR (10) o v_address o CHR (10) o v_state o CHR (10) o v_síp;
    • Convertir el nombre de empleado a minuscula:
    • V_ename := LOWER (v_name);
  • 41. CONVERSION DE TIPOS DE DATOS
    • Convertir datos a tipos de datos comparables.}
    • Mezcla de tipos de datos pueden resultar en un error y afectar el funcionamiento.
    • Funciones de conversión son:
    • - TO_CHAR
    • _ TO_DATE
    • _TO_NUMBER
    • DECLARE
    • V_date date := TO_DATE(`12-JAN-2001`,`DD-MON-YYYY);
    • BEGIN
  • 42.
    • Este declaración produce un error en tiempo de ejecución si la variable v_date es declarada como un tipo de dato DATE.
    • V_date := `January 13, 2001`;
    • para corregir el error, use la función de conversión TO_DATE.
    • V_date := TO_DATE (`January 13, 2001`,`Month DD, YYYY`);
  • 43. BLOQUE ANIDADOS Y ALCANCE DE LAS VARIABLES.
    • Los bloques de PL/SQL pueden ser anidadas dondequiera que una declaración ejecutable sea permitida.
    • Un bloque anidado llega a ser una declaración.
    • Una sección de excepción puede contener bloques anidados.
    • Una sección de excepción puede contener bloques anidados.
    • El alcance de un identificador es desde la región de una unidad de programa desde la cual usted puede referenciar el identificador.
  • 44. ALCANCE DE LOS IDENTIFICADORES.
    • Un identificador es visible en la región donde usted puede referenciar el identificador sin tener que caracterizar este:
    • Un bloque puede buscar bloques encerrados.
    • Un bloque no puede observar los bloques encerrados.
  • 45. CAPACITAR UN IDENTIFICADOR
    • La capacitación puede etiquetar un bloque encerrado.
    • Capacitar un identificador puede usarse el prefijo de etiquetación de bloques.
    • DECLARE
    • birthdate DATE;
    • BEGIN
    • DECLARE
    • birthdate DATE;
    • BEGIN
    • outer.birthdate := TO_DATE (03-AUG-1976, DD-MON-YYYY)
    • END
    • END
  • 46. OPERADORES EN PL/SQL.
    • Lógicos
    • Aritméticos.
    • Concatenación.
    • Paréntesis para controlar el orden de las operaciones.
    • Los mismo es SQL.
    • Operadores exponencial (**).
  • 47. PROGRAMACION GUIDELINES.
    • El código hecho se mantiene fácilmente por:
    • Código documentado con comentarios.
    • Desarrollando un caso de conversión para el código.
    • Desarrollando conversión de nombres por identificadores y otros objetos.
    • Incremento de legibilidad y
  • 48. CODIGO INDENTING.
    • Para claridad, se muestra un ejemplo de código.
    • BEGIN
    • IF x = 0 THEN
    • y:=1;
    • EN IF
    • END;
    • DECLARE
    • V_deptno NUMBER (4);
    • V_location_id NUMBER (4);
    • BEGIN
    • SELECT department_id, location_id, v_deptno, v_location_id
    • FROM deparments
    • WHERE depar ment_name = `SALES`
    • END;
  • 49.
    • Son símbolos simples o compuestos que
    • tienen significado especial para PL/SQL.
    • Símbolos Simples
  • 50. Símbolos compuestos Nota.- No puede usarse palabras reservadas como los identificadores a menos que ellos son adjuntos en la cita doble.
  • 51.  
  • 52.  
  • 53. Objetivos
    • Después de completada esta lección, usted estará en la capacidad de:
    • Escribir en PL/SQL una sentencia SELECT exitosamente.
    • Escribir en PL/SQL sentencias DML
    • Controlar transacciones en PL/SQL
    • Determinar el resultado de las sentencias del Lenguaje de Manipulación de datos. (DML)
  • 54. Sentencias SQL en PL/SQL
    • Cuando usted extraiga información o aplique cambios a la base de datos usted debe usar SQL. PL/SQL soporta el Lenguaje de Manipulación de datos (DML) y los comandos del control de transacciones de SQL. Usted puede usar una sentencia SELECT para incrementar una variable con valores consultados de una fila o una tabla.
  • 55.
    • Usted puede usar comandos DML para modificar los datos en una tabla de la base de datos. Sin embargo recuerde los siguientes puntos acerca de los bloques PL/SQL mientras está usando sentencias DML y comandos de control de transacciones.
    • La palabra clave END significa el fin de un bloque PL/SQL, no el fin de una transacción. Justo como un bloque puede contener múltiples transacciones una transacción puede tener múltiples bloques.
    • PL/SQL no soporta directamente el Lenguaje de Definición de Datos (DDL), así como CREATE TABLE, ALTER TABLE o DROP TABLE.
    • PL/SQL no soporta sentencias del Leguaje de Control de Datos (DCL) así como GRANT o REVOKE.
  • 56.
    • Resumen
    • A través de las sentencias SQL en PL/SQL se podrá:
    • Extraer una fila de datos usando el comando SELECT.
    • Hacer cambios a filas en la base de datos usando comandos DML.
    • Controlar una transacción con comandos como el COMMIT, ROLLBACK o SAVEPOINT.
    • Determinar el resultado DML con atributos de cursor implícito.
  • 57. Recuperando datos usando PL/SQL
    • Utilice la sentencia SELECT para recuperar datos de la base de datos. Con la sintaxis:
    • select_list : es una lista de al menos una columna y puede incluir expresiones SQL, filas, funciones, o grupo de funciones.
    • variable_name: es la variable escalar que retiene el valor recuperado.
    • record_name: es el registro PL/SQL que alberga el valor recuperado.
  • 58.
    • table: Especifica el nombre de la tabla de la base de datos.
    • condition: está compuesta de un nombre de columna, expresión, constante, y operadores de comparación incluyendo variables y constantes PL/SQL.
    • Sintaxis:
    • SELECT select_list
    • INTO {variable_name[, variable_name]…
    • | record_name}
    • FROM table
    • [WHERE condition];
  • 59. Guía para recuperar datos en PL/SQL
    • Terminar cada sentencia SQL con un punto y coma (;).
    • La cláusula INTO se requiere para la sentencia SELECT cuando esta es insertada en PL/SQL.
    • La cláusula WHERE es opcional y puede ser usada para especificar variables de entrada, constantes, literales o expresiones PL/SQL.
    • Especificar el mismo número de variables en la cláusula INTO como columnas en la base de datos en la cláusula SELECT. Debe asegurar que se correspondan posicionalmente y que sus tipos de datos sean compatibles.
    • Use funciones de grupo, así como SUM, en una sentencia SQL. porque las funciones de grupo se aplican a filas en una tabla.
  • 60. Sentencia SELECT en PL/SQL
    • Cláusula INTO
    • La cláusula INTO es obligatoria y ocurre entre las cláusulas SELECT y FROM. Esta es usada para especificar los nombres de variables que contienen los valores que SQL retorna de una cláusula SELECT. Usted debe especificar una variable para cada ítem seleccionado, y el orden de las variables debe corresponderse con los ítems seleccionados.
    • Use la cláusula INTO para llenar variables o variables host.
  • 61.
    • Las consultas deben retornar una y solo una fila.
    • La sentencia SELECT dentro de un bloque PL/SQL está dentro de la clasificación ANSI de insertar SQL, para lo cual se aplican las siguientes reglas: Las consultas deben retornar una y solo una fila, una consulta que retorna mas de una fila o ninguna genera un error.
    • PL/SQL maneja estos errores levantando excepciones, las cuales usted puede atrapar en la sección de excepciones del bloque con las excepciones NO_DATA_FOUND y TOO_MANY_ROWS.
  • 62. Ejemplo 1
    • DECLARE
    • v_deptno NUMBER(4);
    • v_location_id NUMBER(4);
    • BEGIN
    • SELECT department_id, location_id
    • INTO v_deptno, v_location_id
    • FROM departments
    • WHERE department_name = ‘Sales’;
    • END;
    • /
  • 63. Ejemplo 2
    • DECLARE
    • v_hire_date employees.hire_date%TYPE;
    • v_salary employees.salary%TYPE;
    • BEGIN
    • SELECT hire_date, salary
    • INTO v_hire_date, v_salary
    • FROM employees
    • WHERE employee_id = 100;
    • END;
    • /
  • 64.
    • En el ejemplo anterior, la variable v_hire_date y v_salary son declarados en la sección DECPLARE del bloque PL/SQL.
    • En la sección ejecutable, los valores de las columnas HIRE_DATE y SALARY para el empleado con el número de empleado 100 son recuperados de la tabla Empleados y almacenados en las variables v_hire_date y v_salary respectivamente.
    • Observe como la cláusula INTO, a lo largo con la sentencia SELECT, recupera los valores de las columnas de la base de datos dentro de las variables PL/SQL.
  • 65. Ejemplo 3
    • SET SERVEROUTPUT ON
    • DECLARE
    • v_sum_sal NUMBER(10, 2);
    • v_deptno NUMBER NOT NULL := 60;
    • BEGIN
    • SELECT SUM(salary) - – función de grupo
    • INTO v_sum_sal
    • FROM employees
    • WHERE department_id = v_deptno;
    • DBMS_OUTPUT.PUT.LINE (‘La suma del salario es’
    • ||TO_CHAR(v_sum_sal));
    • END;
    • /
  • 66.
    • En el ejemplo 3, las variables v_sum_sal y v_deptno son declaradas en la sección DECLARE del bloque PL/SQL.
    • En la sección ejecutable, el total del salario para el departamento con el número de departamento 60 es calculado usando la función de grupo SUM de SQL, y asignado a la variable v_sum_sal.
    • Nótese que la función de grupo no puede ser usada en la sintaxis PL/SQL. Ellas son usadas en la sentencia SQL dentro del bloque PL/SQL.
    • La salida del bloque PL/SQL se muestra a continuación:
    • La suma del salario es 28800
    • PL/SQL procedure successfully completed.
  • 67. Convención de nombres
    • DECLARE
    • v_hire_date employees.hire_date%TYPE;
    • sys_date hire_ date%TYPE;
    • employee_id employees.employee_id%TYPE := 176;
    • BEGIN
    • SELECT hire_date, sysdate
    • INTO v_hire_date, v_salary
    • FROM employees
    • WHERE employee_id = employee_id;
    • END;
    • /
    • DECLARE
    • *
    • ERROR al line 1:
    • ORA-01422: exact fetch returns more than requested number of rows
    • ORA-06512: at line 6
  • 68.
    • En sentencias SQL potencialmente ambiguas, los nombres de las columnas de la base de datos preceden sobre los nombres de variables locales. El ejemplo es definido como sigue: Retorna la fecha de inicio y la fecha de hoy de la tabla Empleados para el empleado cuyo id es 176.
    • Este ejemplo levanta una excepción en tiempo de ejecución no manejada porque en la cláusula WHERE, los nombres de las variables PL/SQL son los mismos que los nombres de las columnas de la base de datos en la tabla empleados
  • 69.
    • La siguiente sentencia DELETE quita todos los empleados de la tabla empleados en donde el apellido no es nulo, no justo ‘King’, porque el servidor Oracle asume que ambos apellidos en la cláusula WHERE se refiere a la columna de la base de datos.
    • DECLARE
    • last_name VARCHAR2(25) := ‘King’;
    • BEGIN
    • DELETE FROM employees
    • WHERE last_name = last_name;
  • 70. Manipulando Datos usando PL/SQL
  • 71.
    • Usted manipula los datos en la base de datos usando comandos DML. Usted puede usar comandos DML como INSERT, UPDATE, DELKETE y MERGE sin restricción en PL/SQL. Filas bloqueadas son liberadas incluyendo sentencias COMMIT o ROLLBACK en el código PL/SQL.
    • La declaración INSERT añade nuevas filas de datos a la tabla.
    • La declaración UPDATE modifica lasa filas existentes en la tabla.
    • La declaración DELETE quita filas no deseadas de la tabla.
  • 72.
    • La declaración MERGE selecciona filas de una tabla para actualizar o insertarlas en otra tabla. La decisión de insertar, actualizar o no dentro de la tabla objetivo se basa en una condición dentro de la cláusula ON.
    • NOTA:
    • MERGE es una declaración determinista. Usted no puede actualizar la misma fila de la tabla objetivo múltiples veces en la misma declaración MERGE. Usted debe tener privilegios de objeto INSERT y UPDATE en la tabla objetivo y el privilegio SELECT en la tabla origen.
  • 73. Insertando datos
    • En el ejemplo que se muestra a continuación, una declaración INSERT es usada dentro del bloque PL/SQL para insertar un registro dentro de la tabla Empleados. Mientras este usando el comando INSERT en un bloque PL/SQL usted puede:
    • Usar funciones como USER y SYSDATE.
    • Generar valores de claves primarias usando secuencias de base de datos.
    • Derivar valores en el bloque PL/SQL
    • Añadir valores por defecto de columna
  • 74.
    • Ejemplo
    • Añada nueva información de empleados a la tabla Empleados .
    • BEGIN
    • INSERT INTO employees
    • (employee_id, first_name, last_name, email, hire_date, job_id, salary)
    • VALUES
    • (employees_seq.NEXTVAL, ‘Ruth’, ‘Cores’, ‘RECORES’, sysdate, ‘AD_ASST’, 4000);
    • END;
    • /
    • NOTA:
    • No hay posibilidad de ambigüedad con identificadores y nombres de columnas en la sentencia SELECT. Ningún identificador en la cláusula INSERT debe ser el nombre de una columna de la base de datos.
  • 75. Actualizando datos
    • Puede haber ambigüedad en la cláusula SET de una declaración UPDATE porque aunque el identificador en la parte izquierda del operador de asignación es siempre una columna de la base de datos, el identificador de la parte derecha no puede ser una columna de la base de datos o variable PL/SQL.
    • Recuerde que la cláusula WHERE es usada para determinar que filas son afectadas. Si no hay filas modificadas, no ocurren errores, a diferencia de una sentencia SELECT en PL/SQL.
  • 76.
    • Ejemplo
    • Incremente el salario de todos los empleados quienes son empleados (stock clerks).
    • DECLARE
    • v_sal_increase employees.salary%TYPE := 800;
    • BEGIN
    • UPDATE employees
    • SET salary = salary + v_sal_increase
    • WHERE job_id = ‘ST_CLERK’;
    • END;
    • /
    • NOTA: La variable de asignación de PL/SQL siempre usa :=; y SQL para una columna de asignación siempre usa =. Memorice que si el nombre de una columna y el nombre de un identificador son idénticos en la cláusula WHERE, el servidor Oracle observa a la base de datos primero por el nombre .
  • 77. Borrando datos
    • La sentencia DELETE quita filas no deseadas de una tabla. Sin el uso de una cláusula WHERE, los contenidos enteros de una tabla pueden ser quitados, a condición de que no hay restricciones de integridad.
    • Ejemplo
    • Borre filas que pertenezcan al departamento 10 de la tabla empleados.
    • DECLARE
    • v_deptno employees.department_id%TYPE := 10;
    • BEGIN
    • DELETE FROM employees
    • WHERE department_id = v_deptno;
    • END;
    • /
  • 78. Combinación de filas
    • La declaración MERGE inserta o actualiza filas en una tabla, usando los datos de otra tabla. Cada fila es insertada o actualizada en la tabla objetivo, dependiendo de una condición de equijoin.
    • El ejemplo muestra un enlace de la clave de empleado en la tabla COPY_EMP a la clave de empleado en la tabla EMPLOYEES. Si se encuentra un enlace, la fila es actualizada para enlazar la fila en la tabla Empleados. Si la fila no se encuentra, esta es insertada dentro de la tabla COPY_EMP.
  • 79.
    • DECLARE
    • v_empno EMPLOYEES.EMPLOYEE_ID%TYPE := 100;
    • BEGIN
    • MERGE INTO copy_emp c
    • USING employees e
    • ON (e.employee_id = v_empno)
    • WHEN MATCHED THEN
    • UPDATE SET
    • c.first_name = e.first_name,
    • c.last_name = e.last_name,
    • c.email = e.mail,
    • c.phone_number = e.phone_number,
    • c.hire_date = e.hire_date,
    • c.job_id = e.job_id,
    • c.salary = e.salary,
    • c.commission_pct = e.commission_pct,
    • c.manager_id = e.manager_id,
    • c.department_id = e.department_id
    • WHEN NOT MATCHED THEN
    • INSERT VALUES(e.employee_id, e.first_name, e.last_name, e.email, e.phone_number, e.hire_date, e.job_id, e.salary, e.commission_pct, e.manager_id, e.departament_id);
    • END;
    • /
  • 80. Convenciones de nombres
    • Evite la ambigüedad en la cláusula WHERE adhiriéndose a una convención de nombres que distingue nombres de columna de base de datos de nombres de variables PL/SQL, en resumen:
    • Use una convención de nombres para evitar ambigüedad en la cláusula WHERE.
    • Los nombres de las columnas de la base de datos e identificadores deben tener nombres distintos.
  • 81.
    • Errores en la sintaxis pueden surgir porque PL/SQL primero verifica la base de datos por columna en l atabla.
    • Los nombres de variables locales y parámetros formales preceden a los nombres de las tablas de la base de datos.
    • Los nombres de las columnas de las tablas de la base de datos preceden a los nombres de las variables locales.
  • 82.
    • La siguiente tabla muestra una configuración de prefijos y sufijos que distinguen identificadores de otros identificadores, objetos de datos y otros nombres de objetos.
  • 83. Cursor SQL
    • Siempre que usted ejecute una sentencia SQL, el servidor Oracle abre un área de memoria en la cual el comando es analizado y ejecutado. Esta área es llamada cursor.
    • Cuando la parte ejecutable de un bloque ejecuta una sentencia SQL, PL/SQL crea un cursor implícito, el cual PL/SQL maneja automáticamente. El programador explícitamente declara y nombra un cursor explícito. Existen cuatro atributos válidos en PL/SQL que pueden ser aplicados a cursores.
  • 84.
    • En resumen:
    • Un cursor es un área de trabajo privada de SQL.
    • Existen dos tipos de cursores:
      • Cursores implícitos
      • Cursores explícitos
    • El servidor Oracle utiliza los cursores implícitos para analizar y ejecutar sus sentencias SQL.
    • Los cursores explícitos son explícitamente declarados por el programador.
  • 85. Atributos de un cursor SQL
    • Utilizando los atributos de cursor de SQL , usted puede probar el resultado de sus sentencias.
    SQL%ROWCOUNT Número de filas afectadas por la sentencia SQL más reciente (valor íntegro) SQL%FOUND Atributo booleano que evalúa a VERDADERO (TRUE) si la declaración SQL más reciente afecta una o varias filas. SQL%NOTFOUND Atributo booleano que evalúa a VERDADERO (TRUE) si la declaración SQL más reciente no afecta alguna fila. SQL%ISOPEN Siempre evalúa a falso porque PL/SQL cierra los cursores implícitos inmediatamente después de su ejecución.
  • 86.
    • Los atributos de los cursores SQL permiten evalúar lo que pasó cuando un cursor implícito fue usado. Use estos atributos en sentencias PL/SQL, pero no en sentencias SQL.
    • Se pueden utilizar los atributos SQL%ROWCOUNT, SQL%FOUND, SQL%NOTFOUND, y SQL%ISOPEN en la sección de excepciones de un bloque para unir información acerca de la ejecución de una sentencia DML. PL/SQL no retorna errores si una sentencia DML no afecta a alguna fila en la tabla subyacente. Sin embargo, si una sentencia SELECT no retorna alguna fila, PL/SQL retorna una excepción.
  • 87.
    • Ejemplo:
    • Borrar las filas de un empleado específico de la tabla empleados. Imprima el número de filas borradas.
    • VARIABLE rows_deleted VARCHAR2(30)
    • DECLARE
    • v_employee_id employees.employee_id%TYPE := 176.
    • BEGIN
    • DELETE FROM employees
    • WHERE employee_id = v_employee_id;
    • :rows_deleted :=(SQL%ROWCOUNT || ‘row deleted.’);
    • End;
    • /
    • Print rows_deleted
    • Este ejemplo borra las filas de la tabla Empleados para el número de empleado 176. Usando el atributo SQL%ROWCOUNT, se puede imprimir el número de filas borradas.
  • 88. Sentencias de control de transacciones
    • Usted controla la lógica de las transacciones con las sentencias SQL COMMIT y ROLLBACK, dando a algunos grupos de la base de datos cambios permanentes mientras se descartan otros.
    • Con el servidor Oracle, las transacciones de DML comienzan con el primer comando seguido de un COMMIT o ROLLBACK . Estas acciones pueden ocurrir dentro de un bloque PL/SQL o como resultado de algún evento en el entorno de un host (por ejemplo, en más casos finalizando una sesión automáticamente de iSQL*Plus se confirman las transacciones pendientes). Para crear un punto intermedio en el proceso de una transacción, use SAVEPOINT.
  • 89.
    • COMMIT [WORK];
    • SAVEPOINT savepoint_name;
    • ROLLBACK [WORK]
    • ROLLBACK [WORK] TO [SAVEPOINT] savepoint_name;
    • En donde : WORK ies para conformidad con el estándar ANSI.
    • NOTA:
    • Los comandos de control de transacciones son todos válidos dentro de PL/SQL, aunque el ambiente del host puede tener algunas restricciones sobre su uso.
  • 90.
    • Usted puede incluir comandos de bloqueo explícitos en un bloque que toman efecto hasta el final de la transacción. También, un bloque PL/SQL no necesariamente implica una transacción.
  • 91.  
  • 92.  
  • 93. Controlando Flujo de Ejecución de PL/SQL
    • Utliza la condición IF para cambiar la ejecución logica de las sentencias. Las condiciones de las sentencias IF son:
    • IF-THEN-END IF
    • IF-THEN-ELSE-END IF
    • IF-THEN-ELSIF-END IF
  • 94. SENTENCIA IF
    • SINTAXIS:
    • IF condicion THEN sentencia;
    • [ELSIF condicion THEN sentencias;]
    • [ELSE sentencia;]
    • END IF;
  • 95. SENTENCIAS IF SIMPLES
    • Las sentencias simples tienen la siguiente sintaxis:
    • IF condicion THEN sentencia
    • END IF;
  • 96. SENTENCIAS IF COMPUESTAS
    • Las sentencias IF compuestas usan operadores logicos como AND Y NOT
    • SINTAXIS:
    • IF condición AND condicion
    • THEN sentencia;
    • END IF;
  • 97. FLUJO DE EJECECUCIÓN DE SENTENCIAS IF-THEN-ELSEIF
    • TRUE NOT TRUE
    • TRUE NOT TRUE
    IF condicion Acción THEN Acción ELSE condicion ELSIF Acción THEN
  • 98. Flujo de la ejecución de Sentencias IF-THEN-ELSE
    • TRUE NOT TRUE
    IF condicion Acción THEN (incluye una sentencia IF) Acción ELSE (incluye una sentencia IF)
  • 99. SENTENCIAS IF-THEN-ELSE
    • Para dar un valor, calcular un porcentaje de el valor basado en una condicion.
    • Ejemplo.
    • IF v_start > 100 THEN
    • v_start = 0.2 v_start;
    • ELSIF v_start >= 50 THEN
    • v_start := 0.5 v_start;
    • ELSE
    • v_start := 0.1 v_start
    • END IF;
  • 100. Expresiones CASE
    • Una expresión CASE selecciona un resultado y lo retorna.
    • Para seleccionar el resultado , la expresión CASE usa una expresión cuyo valor es usado para seleccionar una o varias alternativas.
    • CASE selector
    • WHEN expression1 THEN result1
    • WHEN expression2 THEN result2
    • … ..
    • WHEN expressionN THEN resultN
    • [ELSE resultN+1;]
    • END;
  • 101. Expresiones CASE : Ejemplo
    • SET SERVERPUT ON
    • DECLARE
    • v_grade CHAR(1) := UPPER (‘&p_grade’);
    • v_appraisal VARCHAR2(20);
    • BEGIN
    • v_appraisal :=
    • CASE v_grade
    • WHEN ‘A’ THEN ‘Excellent’
    • WHEN ‘B’ THEN ‘Very Good’
    • WHEN ‘C’ THEN ‘Good’
    • ELSE ‘No such grade’
    • END;
    • DBMS_OUTPUT.PUT_LINE(‘Grade: ‘ || v_grade || ` Appraisal ` || v_appraisal);
    • END;
    • /
  • 102. Manipulando Nulos
    • Cuando trabajamos con Nulos, puede evitar algunos errores comunes ,. Teniendo en cuenta las siguentes reglas:
    • Comparaciones simples que involucran nulos siempre producen nulos
    • Aplicando el operador lógico NOT al nulo produce nulo
    • En sentencias de control condicional, si la condición produce NULL, se asociación de secuencias no es ejecutada.
  • 103. Tablas Lógicas
    • Construir una condición booleana simple con un operador de comparación
    AND TRUE FALSE NULL TRUE TRUE FALSE NULL FALSE FALSE FALSE FALSE NULL NULL FALSE NULL OR TRUE FALSE NULL TRUE TRUE TRUE TRUE FALSE TRUE FALSE NULL NULL TRUE NULL NULL NOT TRUE FALSE FALSE TRUE NULL NULL
  • 104. Tablas Lógicas
    • Comparaciones booleanas con operadores lógicos
    • Ud. Puede construir una condición simple booleana combinando números, caracteres i expresiones de tiempo con operadores lógicos.
    • Ud. Puede construir una condición booleana compuesta componiendo condiciones simples booleanas con operadores lógicos AND, OR y NOT. En las tablas lógicas mostradas anteriormente:
    • FALSE toma precedencia en una condición AND y TRUE toma precedencia en una condición OR
    • AND retorna TRUE solo si ambos operandos son TRUE
    • OR retorna TRUE si ambos operadores son FALSE
    • NULL y TRUE siempre evalúan el NULL
  • 105. Condiciones Booleanas
    • Cual es el valor de V_FLAG en cada caso ?
    • v_flag := v_recorder_flag AND v_available_flag;
    • Respuestas
    • 1. TRUE 2. FALSE 3. NULL 4. FALSE
    V_REORDER_FLAG V_AVAILABLE_FLAG V_FLAG TRUE TRUE ? TRUE FALSE ? FALSE TRUE ? FALSE FALSE ?
  • 106. Control Iterativo : Sentencias LOOP
    • LOOPs repite una sentencia o secuencia de múltiples sentencias
    • Hay tres tipos de ciclos
      • Ciclo básico – ejecuta acciones repetitivas sin condiciones de conjunto
      • Ciclo for - ejecuta control iterativo de acciones basadas en un conteo
      • Ciclo while – ejecuta control iterativo de acciones basadas en una condición
      • Use la sentencia EXIT para terminar el ciclo.
  • 107. Ciclos Básicos Ciclos Básicos La mas simple forma de las sentencias LOOP es la básica, la cual encierra una secuencia de sentencias entre las palabras reservadas LOOP y END LOOP. Un ciclo básico permite la ejecución de al menos una sentencia como mínimo. LA sentencia EXIT Usted puede usar EXIT para terminar el ciclo. LOOP -- delimitado statement1; -- sentencias … EXIT [WHEN condition] -- Termina sentencia END LOOP; -- delimitador Condicion: Es una variable booleana o expresión (TRUE, FALSE, o NULL)
  • 108. Ciclos While
    • En la sintaxis:
      • Condition es una variable booleana (TRUE, FALSE, NULL)
      • Statement puede ser una o mas sentencias PL/SQL o SQL
    • Si las variables involucradas en las condiciones no cabían durante el cuerpo del ciclo, luego la condicion continua con TRE y el ciclo no termina
    • Nota: Si la condicion produce un NULL, el ciclo es desviado al control de la próxima sentencia
    WHILE condition LOOP -- La condicion es evaluada al comienzo statement1; -- de cada iteración statement2; … END LOOP; Use el WHILE para repetir sentencias mientras una condicion es verdadera
  • 109. Ciclos WHILE : Ejemplo
    • DECLARE
      • V_ country_id locations.country_id%TYPE:=‘CA’;
      • V_location_id locations.location_id%TYPE;
      • V_city locations.city%TYPE:=‘Montreal’;
      • V_counter NUMBER := 1;
      • BEGIN
      • SELECT MAX (location_id) INTO v_location_id FROM locations
      • WHERE country_id = vcountry_id;
      • WHILE v_counter <=3 LOOP
      • INSERT INTO locations (location_id, city, country_id)
      • VALUES ((v_location_id + v_counter), v_city, v_country_id);
      • v_counter:= v_counter+1;
      • END LOOP;
      • END;
      • /
  • 110. Ciclos FOR
    • REVERSE causa al contador decrementar con cada iteración desde el salto alto al bajo
    • Lower_bound especifica el salto mas bajo del rango de valores del contador
    • upper_bound especifica el salto mas alto del rango de valores del contador
    FOR counter IN [REVERSE] lower_bound .. Upper_bound LOOP statement1; -- de cada iteración statement2; … END LOOP; Use un ciclo FOR para conseguir un atajo para el numero de iteraciones No declare un contador; este es declarado implícitamente como un entero ‘ lower_bound .. Upper_bound’ es sintaxis requerida
  • 111. Ciclo FOR
    • Inserte tres nuevas location_id para el código de la ciudad CA y la ciudad de Montreal
    DECLARE V_country_id locations.country_id%TYPE := ‘CA’; V_location_id locations.location_id%TYPE ; v_city locations.city%TYPE := ‘Montreal’; BEGIN SELECT MAX (locatio_id) INTO v_location_id FROM locations WHERE country_id = V_country_id; FOR i IN 1…3 LOOP INSERT INTO locations (location_id, city, country_id) VALUES ((v_location_id + i ), v_city, v_country_id); END LOOP; END;
  • 112. Ciclo FOR
    • Líneas directivas
    • Referencian al contador solo dentro del ciclo, es indefinido fuera del ciclo
    • No referencia al contador como el objetivo de una asignación.
  • 113. Líneas directivas mientras se usan ciclos
    • Use el ciclo básico cuando las sentencias dentro del ciclo deban ejecutarse al menos una vez
    • Use el ciclo WHILE si la condicion debe ser evaluada al comienzo de cada iteración,
    • Use un ciclo FOR si se conoce el numero de iteraciones.
  • 114. Ciclos Anidados y etiquetas
    • Ciclos anidados para múltiples etiquetas
    • Use etiquetas para distinguir entre bloques y ciclos.
    • Salga del ciclo exterior con la sentencia EXIT que referencia la etiqueta
    • Usted puede anidar ciclos a múltiples niveles. Usted puede anidar ciclos básicos, FOR, While dentro de otro.
    • La finalización de un ciclo anidado no determina la culminación del ciclo al menos que una excepción fue levantada. Sin embargo, Usted puede etiquetar ciclos y salir del ciclo externo con la sentencia EXIT.
  • 115. Ciclos Anidados y etiquetas
    • BEGIN
      • <<outer_loop>>
      • LOOP
      • v_counter := v_counter +1;
      • EXIT WHEN v_counter>10 ;
      • <<Inner_loop>>
      • LOOP
      • EXIT outer_loop WHEN total_done = ‘YES’ ;
      • -- Leave both loops
      • EXIT WHEN inner_done = ‘YES’;
      • -- Leave inner loop only
      • END LOOP Inner_loop;
      • END LOOP outer_loop:
    • END
  • 116. Resumen
    • En esta lección debiste haber aprendido a :
    • Cambiar el flujo lógico de las sentencias usando estructuras de control
      • Condicionales (Sentencia IF)
      • Expresiones CASE
      • Ciclos:
        • Ciclos Basicos
        • Ciclos FOR
        • Ciclos While
    • Sentencias de salida EXIT
  • 117.
    • Capitulo 5
  • 118. CAPITULO 5 Marcela Gómez
  • 119.
    • Después de completar ésta lección, usted será capaz de hacer lo siguiente:
    • Crear registros PL/SQL definidos por el usuario
    • Crear un registro con el atributo %ROWTYPE
    • Crear un índice por tabla
    • Crear un índice por tabla de registros
    • Describir las diferencias entre registros, tablas, y tablas de registros
    OBJETIVOS
  • 120.
    • Son de dos tipos :
    • Registros PL/SQL
    • Colecciones PL/SQL
      • Indices por tabla
      • Tablas anidadas
      • Varray
    • Contienen componentes internos
    • Son reusables
    Composición de tipos de datos
  • 121. Registros PL/SQL
    • Debe contener uno o mas componentes de cualquier escalar , archivo o índice (tipo de tabla de datos), llamados archivos
    • Son similares en estructura para registros en lenguaje de tercera generación
    • No son los mismos como filas en una tabla de base de datos
    • Tarta una conexión de archivos como una unidad lógica
    • Son convenientes para ir a buscar una fila de datos desde una tabla para procesarlos
  • 122. Creando un archivo PL/SQL
    • Cuando field_declaration es:
    • Definiendo y declarando un registtro PL/SQL
    • En la sintaxis:
    • Type_name es el nombre del tipo de registro
    • Field_name es el nombre del campo dentro del registro
    • Field_type es el tipo de dato del campo
    • Expr es el field_type o un valor inicial
    • La restricción NOT NULL previene asignaciones nulas a estos campos. Debe estar seguro de inicializar campos NOT NULL
    SINTAXIS: TYPE type_name IS RECORD (field_declaration [, field_declaration]…); Identifier type_name; Field_name {field_type | variable%TYPE | table.column%TYPE | table %ROWTYPE} [[NOT NULL] {:= | DEFAULT} expr]
  • 123. Creando un registro PL/SQL
    • Declare variables para para almacenar el nombre, trabajo y salario de un nuevo empleado
    • Ejemplo
    … TYPE emp_record_type IS RECORD (last_name VARCHAR2(25), job_id VARCHAR2(10), salary NUMBER(8,2)); Emp_record emp_record_type; …
  • 124. Estructura de registros PL/SQL Field 1 (data type) Field2(data type) Field3 (data type) Ejemplo: Field 1 (data type) Field2(data type) Field3 (data type) Employee_id number(6) last_name varchar2(25) job_id varchar2(10) 100 King AD_PRES
  • 125. El atributo %ROWTYPE
    • Declara un variable de acuerdo a una colección de columnas en una tabla de base de datos
    • El prefijo %ROWTYPE con la tabla de base de datos
    • Campos en el registro toma sus nombres y tipos de datos desde la columna de las tablas o vistas.
  • 126. Declarando registros con el atributo %ROWTYPE
    • Sintaxis
    Asignando valores y registros Usted puede asignar una lista de valores comunes a un registro usando sentencias SELECT o FETCH. Asegúrese que el nombre de columnas aparezcan en el mismo orden como los campos en su registro. Usted también puede asignar un registroa otro si ellos tienen el mismo tipo de datos. DECLARE identifier reference%ROWTYPE; Where : identifier es el nombre escogido por el registro como un todo reference es el nombre
  • 127. Ventajas de usar %ROWTYPE
    • El numero de tipo de datos de la columnas de base de datos subrayada necesita ser conocida
    • El numero y tipo de datos de las columnas de la base de datos subrayada debe cambiarse en tiempo de ejecución
    • El atributo es aprovechable cuando se recupera una fila con la sentencia SELECT.
  • 128. Los atributos %ROWTYPE
    • Ejemplos:
    • Declare una variable para guardar la información acerca de un departamento de la tabla departamentos.
    • Declare una variable para guardar la información acerca de un empleado de la tabla employees.
    Dept_record departtments%ROWTYPE; Emp_record demployees%ROWTYPE;
  • 129. Índices por tablas
    • Son compuestos por dos componentes:
      • Llave primaria o tipo de dato BINARY_INTEGER
      • Columna o escalar o tipo de dato registro
    • Puede incrementan en tamaño dinámicamente porque ellos son sin restricción
  • 130. Creando un índice por tabla
    • Sintaxis:
    Declare un índice por tabla para almacenar nombres Ejemplo: TYPE type_name IS TABLE OF {column_type | variable%TYPE | table.column%TYPE} [NOT NULL] | table.%ROWTYPE [INDEX BY BINARY_INTEGER]; Identifier type_name; … TYPE ename_table_type IS TABLE OF employees.last_name%TYPE INDEX BY BINARY_INTEGER; Ename_table ename_table_type;
  • 131. Índice por estructura de la tabla Identificador Único Columna Binary_Integer Scalar … 1 2 3 … … Jones Smith Maduro …
  • 132. Creando un Índice por Tabla
    • DECLARE
    • TYPE ename_table_type IS TABLE OF
    • employees.las_name%TYPE
    • INDEX BY BINARY_INTEGER;
    • TYPE hiredate_table_type IS TABLE OF DATE
    • INDEX BY BINARY_INTEGER;
    • ename_table ename_table_type;
    • hiredate_table hiredate_table_type;
    • BEGIN
    • ename_table (1) := ‘CAMERON’;
    • hiredate_table(8) :=SYSDATE + 7;
    • IF ename_table.EXIST(1) THEN
    • INSERT INTO …
    • END;
    • /
  • 133. Usando Métodos de índice por tabla
    • Los siguientes métodos hacen un índice por tablas mas fácil de usar:
        • EXISTS. Retorna Verdadero si el elemento en PL/SQL existe
        • COUNT. Retorna el numero de elementos que la tabla contiene
        • FIRST AND LAST. Retorna el primer y ultimo índice
        • PRIOR. Retorna el numero del índice que precede al índice n
        • NEXT. Retorna el numero del índice que sucede al índice n
        • TRIM. Remueve un elemento del el final de la tabla PL/SQL
        • DELETE. Elimina todos los elementos de la tabla PL/SQL
  • 134. Índices por tablas de registros
    • Define una tabla variable con un tipo de dato PL/SQL permitido.
    • Declara una variable PL/SQL para mantener información del departamento
    • Ejemplo:
    DECLARE TYPE dept_table_type IS TABLE OF departments%ROWTYPE INDEX BY BINARY_INTEGER; Dept_table dept_table_type; -- cada elemento de dep_table es un registro
  • 135. Ejemplo de índices por tabla de Registros
    • SET SERVEROUTPUT ON
    • DECLARE
    • TYPE emp_table_type IS TABLE OF
    • employees.%ROWTYPE
    • INDEX BY BINARY_INTEGER;
    • my_emp_table emp_table_type;
    • v_count NUMBER(3):= 104;
    • BEGIN
    • FOR i IN 100 .. V_count
    • LOOP
    • SELECT * INTO my_emp_table(I) FROM employees;
    • WHERE employee_id = i;
    • END LOOP;
    • FOR i IN my_emp_table.FIRST.. My_emp_table.LAST
    • LOOP
    • DBMS_OUTPUT.PUT_LINE (my_emp_table(i).last_name);
    • END LOOP;
    • END;
    • /
  • 136. Resumen
    • En esta lección, usted debió haber aprendido a :
      • Definir y referenciar las variables PL/SQL de tipos de datos compuestos:
        • Registros PL/SQL
        • Índices por tablas
        • Índices por tabla de registros
    • Definir un registro PL/SQL usando el atributo %ROWTYPE
  • 137.
    • CAPITULO 6
  • 138.
    • ESCRIBIR CURSORES EXPLICITOS
  • 139. Objetivos
    • Después de completar esta lección, usted deberá estar en la capacitad de hacer lo siguiente:
      • Distinguir entre un cursor implícito y un explicito
      • Discutir cuándo y por qué usar un cursor explicito
      • Usar una variable de registro PL/SQL
      • Escribe un cursor de ciclo FOR
  • 140. Acerca de los Cursores
    • Cada sentencia SQL ejecutada por el servidor SQL tiene un cursor individual asociado con este:
      • Cursores implícitos: Declarados para todas las sentencias SELECT DML y PL/SQL.
      • Cursores Explícitos: Declarados y nombrados por el programador
  • 141. Funciones de cursores Explícitos
    • Cursores explícitos
    • Use cursores explícitos para procesos individuales, cada fila retornada por múltiples filas con la sentencia SELECT.
    • El grupo de filas retornado por las consultas a filas múltiples es llamada el conjunto activo.
    • Las funciones de los cursores explícitos son :
        • Pueden procesar mas allá de la primera fila retornada por la consulta, fila por fila
        • Mantiene el rastro de cuales filas están siendo procesadas
        • Permite al programador el control manual de los cursores explícitos el bloque PL/SQL
    Conjunto Activo Cursor
    • 100 King AD_PRES
    • Kochar AD_VP
    • .
    • .
    • 140 Patel ST_CLERK
  • 142. Controlando cursores explícitos
    • Controlando cursores explícitos
    • Declare el cursor nombrándolo y definiendo la estructura de la consulta a ser ejecutada dentro de este.
    • Abrir el cursor, la sentencia OPEN ejecuta la consulta y une variables que son referenciadas. Las filas definidas por la consulta son llamadas grupo activo y ahora están habilitadas para el fetching.
    • Los datos Fetch del cursor. En el diagrama de flujo se meuestra enla diapositiva, despues de cada fetch, ustred prueba el cursor para la existencia de cada fila si hay o no mas filas para procesar, luego se debe cerrar el cursor.
    • Cerrar el cursor. La sentencia Close libera los grupos activos de filas, esto es ahora posible para reabrir el cursor para establecer un grupo activo actual
    declare open fetch close Crea un área SQL Identifica el conjunto activo Carga la fila actual dentro de las variable Prueba las filas existente Retorna a fetch si las filas son encontradas EMPTY? Libera el conjunto activo No Si
  • 143. Controlando cursores explícitos
    • Abrir el cursor
    • Fetch una fila
    • Cerrar el cursor
          • Abrir el cursor
    Cursor puntero
  • 144. Controlando cursores explícitos
    • Abrir el cursor
    • Ir a buscar una fila
    • Cerrar el cursor
          • Ir a buscar el cursor
    Puntero del cursor Continua hasta quedarse vacio
  • 145. Controlando cursores explícitos
    • Abrir el cursor
    • Ir a buscar la fila
    • Cerrar el cursor
    Cerrar el cursor . Puntero del cursor .
  • 146. Declarando el cursor
    • Sintaxis:
    CURSOR cursor_name IS Select_statement;
    • No incluye la clausula INTO en la declaración del cursor
    • Si las filas se procesan en una secuencia especifica es requerido, usar la clausula ORDER BY en una consulta
  • 147. Declarando un cursor
    • DECLARE
    • CURSOR emp_cursor IS
    • SELECT employee_id, last_name
    • FROM employees;
    • CURSOR dept_cursor IS
    • SELECT *
    • FROM departments
    • WHERE locarion_id = 170;
    • BEGIN
  • 148. Abriendo el cursor
    • Sintaxis
    OPEN cursor_name;
    • Abrir el cursor para ejecutar la consulta e identificar el conjunto activo
    • Si la consulta no retorna filas, ninguna excepción es levantada
    • Usar atributos del cursor para probar el resultado después de un fetch
  • 149. Datos fetching de el cursor
    • Sintaxis
    FETCH cursor_name INTO [variable1, variable2, …] |record_name];
    • Recuperar los valores de la fila actual en variables
    • Incluir el mismo numero de variables
    • Corresponder cada variable a la columna posicionalmente
    • Probar y ver si el cursor contiene filas
  • 150. Buscando datos desde el cursor
    • Ejemplo:
    • LOOP
    • FETCH emp_cursor INTO v_empno, v_ename;
    • EXIT WHEN …;
    • --- Process the retrieve data
    • END LOOP;
  • 151. Cerrando el cursor
    • Sintaxis
    CLOSE cursor_name;
    • Cerrar el cursor después de completar el procesamiento de las filas
    • Reabrir el cursor si se lo requiere
    • No Intentar ir a buscar los datos desde un cursor después de que haya sido cerrado
  • 152. Atributos explícitos de los cursores
    • Obtener el estado de información acerca del cursor
    Atributo Tipo Descripción %ISOPEN Booleana Evaluar VERDADERO si el cursor el abierto %NOTFOUND Booleana Evaluar V si el mas reciente fetch no retorna una fila %FOUND Booleana Evalúa Verdadero si el mas reciente fetch retorna una fila; complementa %NOTFOUND %ROWCOUNT Numeral Evalúa el numero total de filas retornadas a distancia
  • 153. El atributo %ISOPEN
    • Se va a buscar filas solo si el cursor esta abierto
    • Se usa el atributo %ISOPEN antes de ejecutar un fetch para probar si el cursor es abierto.
    • Ejemplo:
    IF NOT emp_cursor%ISOPEN THEN OPEN emp_cursor; END IF ; LOOP FETCH emp_cursor …
  • 154. Controlando fetches múltiples
    • Procesar varias filas desde un cursor explicito usando un ciclo cerrado.
    • Ir a buscar una fila con cada iteración
    • Usar atributos de un cursor explicito para probar el acierto de cada fetch.
  • 155. Los atributos %NOTFOUND y % ROWCOUNT
    • Usar el atributo del cursor %ROWCOUNT para recuperar un numero exacto de filas
    • Use el atributo del cursor %NOTFOUND para determinar cuando existe el ciclo.
  • 156. Ejemplo:
    • DECLARE
    • v_empno employees.employee_id%TYPE;
    • v_ename employees.last_name% TYPE;
    • CURSOR emp_cursor IS
    • SELECT employee_id last_name
    • from employees
    • BEGIN
    • OPEN emp_cursor;
    • LOOP
    • FETCH emp_cursor into v_empno, v_ename;
    • EXIT WHEN emp_cursor %ROWCOUNT >10 OR
    • emp_cursor %ROWFOUND ;
    • DBMS_OUTPUT. PUT_LINE(TO_CHAR(vempno)||”” || v_ename);
    • END LOOP;
    • CLOSE emp_cursor;
    • END
  • 157. CURSORES Y REGISTROS
    • Procesar las filas del conjunto activo buscando valores de un archivo PL/SQL.
    • DECLARE
    • CURSOR emp_cursor IS
    • SELECT employee_id last_name
    • FROM employees;
    • emp_record emp_cursor %ROWTYPE;
    • BEGIN
    • OPEN emp_cusor;
    • LOOP
    • FETCH emp_cursor int emp_record;
    emp_record Employee_id last_name 100 King
  • 158. Ciclos LOOP de Cursores
    • Sintaxis
    FOR record_name IN cursor_name LOOP statement1; Statement2; … END LOOP;
    • El ciclo For es un atajo al proceso explicito de cursores
    • Implicito Open, fetch, exit, y close ocurre
    • El registro es declarado implícitamente
  • 159. Ciclos FOR para cursores
    • Imprime una lista de empleados los cuales trabajan para el departamento de ventas
    DECLARE CURSOR emp_cursor IS SELECT last_name, department_id last_name FROM employees BEGIN FOR emp_record IN emp_cursor LOOP -- implicit open and implicit fetch occur IF emp_record.department_id = 80 THEN … END LOOP; -- implicit close occurs END;
  • 160. Ciclos FOR para cursores usando subconsultas
    • No se necesita declarar el cursor
    • Ejemplo:
    BEGIN FOR emp_record IN (SELECT last_name, department_id FROM employees) LOOP IF emp_record.department_id = 80 THEN … END LOOP; -- implicit close occurs END;
  • 161. Resumen
    • En esta lección, usted debió haber aprendido a:
      • Distinguir tipos de cursores:
        • Cursores implícitos: usados por todas las sentencias DML y consultas a filas simples
        • Cursores explícitos: usados por consultas de cero, uno, o mas filas
    • Manipular cursores explicitos
    • Evaluar estados del cursor usando atributos del cursor
    • Usar cursores con ciclos FOR
  • 162.
    • CAPITULO 7
  • 163.
    • CONCEPTOS AVANZADOS DE CURSORES EXPLICITOS
  • 164. Objetivos
    • Después de completar esta lección, usted deberá ser capaz de hacer lo siguiente:
      • Escribir un cursor cuando es requerida una actualización FOR en el cursor .
      • Determinar cuando una clausura de actualización FOR en un cursor es requerida.
      • Determinar cuando usar la sentencia WHERE CURRENT OF
      • Escribir un cursor que usa subconsultas
  • 165. Cursores con parámetros
    • Sintaxis:
    CURSOR cursor_name [(parameter_name datatype, …)] IS Select_statement;
    • Pasar valores de los parámetros a un cursor cuando el cursor es abierto y la consulta es ejecutada.
    • Abrir un cursor explicito algunas veces con un diferente conjunto activo cada vez
    OPEN cursor_name (parameter_value, . . .);
  • 166. Cursores con parametros
    • Pasar el numero de departamento y titulo de trabajo a la sentencia where, en el cursor o sentencia SELECT
    DECLARE CURSOR emp_cursor (p_deptno NUMBER, p_job VARCHAR2) IS SELECT employee_id, last_name FROM employees WHERE department_id = p_deptno AND job_id = p_job; BEGIN OPEN emp_cursor (80, ‘SA_REP’); … CLOSE emp_cursor; OPEN emp_cursor (60, ‘IT_PROG’); … END;
  • 167. La clausula FOR UPDATE
    • Sintaxis:
    SELECT… FROM FOR UPDATE [OF column_reference] [NOWAIT];
    • Use trabas explicitas para denegar acceso para la duración de la transacción.
    • Cerrar las filas antes de la actualización o eliminación
  • 168. La clausula FOR UPDATE
    • Recuperar los empleados que trabajen en el departamento 80 y actualice sus salario
    DECLARE CURSOR emp_cursor IS SELECT employees_id, last_name, department_name FROM employees , departments WHERE employees, departments_id = departments.department_id AND employees.department_id =80 FOR UPDATE OF salary NOWAIT;
  • 169. La clausula WHERE CURRENT OF
    • Syntaxis:
    WHERE CURRENT OF cursor:
    • Use cursores para actualizar o eliminar la fila actual.
    • Incluya la sentencia FOR UPDATE en la consulta del cursor para bloquear primero las filas.
    • Use la clausula WHERE CURRENT OF para referenciar la fila actual de un cursor explicito.
  • 170. La clausula WHERE CURRENT OF DECLARE CURSOR sal_cursor IS SELECT e.department_id, employee_id, last_name, salary FROM employees e, departments d WHERE d.department.id c = e. department_id AND d.department id ca =60 FOR UPDATE OF salary NOWAIT; BEGIN FOR emp_record in sal_cursor LOOP if emprecord.salary <5000 THEN UPDATE employees SET salary = emp_record.salary * 1.10 WHERE CURRENT OF sal_cursor; AND IF END LOOP; END
  • 171. Cursores con SUBCONSULTAS
    • Ejemplo:
    DECLARE CURSOR my_cursor IS SELECT t1.department_id, t1.department_name, t2.staff FROM departments t1,(select departmen_id,COUNT(*) AS STAFF FROM employees GROUP BY department_id) t2 WHERE t1.department_id =t2.department_id AND t2.stuff >=3; …
  • 172. RESUMEN
    • En esta leccion debiste haber aprendido a:
    • Retornar diferentes conjuntos activos usando cursores con parametros.
    • Definir cursores con subconsultas y subconsultas correlacionados.
    • Manipular cursores explicitos con comandos usando las:
    • Clausula FOR UPDATE
    • Clausula WHERE CURRENT OF
  • 173. La clausula FOR UPDATE
    • Recuperar los empleados que trabajen en el departamento 80 y actualice sus salario
    DECLARE CURSOR emp_cursor IS SELECT employees_id, last_name, department_name FROM employees , departments WHERE employees, departments_id = departments.department_id AND employees.department_id =80 FOR UPDATE OF salary NOWAIT;
  • 174.
    • CAPITULO 8
  • 175.
    • MANIPULANDO EXCEPCIONES
  • 176. Objetivos
    • Despues de completar esta leccion, sera capaza de hacer lo siguiente:
      • Definir excepciones PL/SQL
      • Reconocer excepciones que no son manipulables
      • Listar diferentes tipos de excepciones manejables PL/SQL
      • Atrapar errores no anticipados
      • Describir los efectos de la propagación de excepciones en cloques anidados
      • Adaptar mensajes de excepciones PL/SQL
  • 177. Manejando excepciones con PL/SQL
    • Una excepción es un identificador en PL/SQL que es levantada durante la ejecución.
    • Como es levantada?
      • Un error Oracle ocurre
      • Se levanta explícitamente
    • Como se los manipula?
      • Atraparlo con un manipulador
      • Propagarlo en un entorno de invocación
  • 178. Manejando excepciones
  • 179. Tipos de Excepciones
    • Implícitamente levantado
    • Predefinir el servidor Oracle
    • No predefinir el servidor Oracle
    • Explícitamente levantado
    • Usuario definido
  • 180. Atrapando excvepciones
    • Sintaxis:
    EXCEPTION WHEN exception1 [OR exception2 . . . ] THEN statement1; statement2; … [WHEN exception3 [OR exception4 …] THEN statement1; statement2; … ] [WHEN OTHERS THEN statement1; statement2; … ]
  • 181. Atrapando excepciones con líneas de guías
    • La palabra reservada EXCEPTION empieza la sección exception-handling
    • Algunos manejadores de excepciones son permitidas
    • Solo un manejador es procesado antes de dejar el bloque
    • WHEN OTHERS es la ultima clausula
  • 182. Atrapando errores predefinidos en el servidor Oracle
    • Referencia el nombre estándar en la rutina de manejo de excepciones
    • Probar excepciones predefinidas:
      • NO_DATA_FOUND
      • TOO_MANY_ROWS INVALID_CURSORS ZERO_DIVIDE DUP_VAL_ON_INDEX
  • 183. Excepciones predefinidas
    • Sintaxis:
    BEGIN … EXCEPTION WHEN NO DATA FOUND THEN statement1; statement2; WHEN TOO_MANY_ROWS THEN statement1; WHEN NO OTHERS THEN statement1; statement2; statement3; END;
  • 184. Atrapando errores no predefinidos del Servidor Oracle
    • Nombrar la excepción Codificar el pragma Manejar el levantamiento de la EXCEPTION_INIT excepcion
    Sección de declaración Seccion Exception-handling Declare Associate reference
  • 185. Errores no predefinidos
    • Atrapar los errores del servidor Oracle numero -2292, una violación de integridad
    DEFINE p_deptno = 10 DECLARE e_emps_remaining EXCEPTION; PRAGMA EXCEPTION_INIT (e_emps_remaining, -2292); BEGIN DELETE FROM departments WHERE department_id = &p_deptno; COMMIT; EXCEPTION WHEN e_emps_remaining THEN DBMS_OUTOPUT.PUT_LINE (‘no puede eliminmar dept’ ||) TO_CHAR (&p_deptno ) || ‘. Employees existe. ’); END;
  • 186. Funciones para atrapar excepciones
    • SQLCODE: regresa el valor numérico por el código de error
    • SQLERRM: regresa el mensaje asociado con el número de error
  • 187. Funciones para atrapar excepciones DECLARE v_error_code NUMBER; v_error_message VARCHAR2(255); BEGIN … EXCEPTION … WHEN OTHERS THEN ROLLBACK; v_error_code := SQLCODE; v_error_mesage := SQLERRM; INSERT INTO errors VALUES (v_error_code , v_error_message); END;
  • 188. Atrapando excepciones User-defined Sección ejecutable Sección de declaración Seccion Exception-handling Declare Raise reference Nombre de la excepción Levantar explícitamente La excepción usando la Sentencia RAISE Manipular la excepción De levantamiento
  • 189. Excepciones user-defined DEFINE p_departmente_desc = ‘Information tecnologhy’ DEFINE p_departmente_number= 300 DECLARE e_invalid_department EXCEPTION; BEGIN UPDATE departments; SET department_name = ‘&p_department_desc’ WHERE department_id = &p_department_number; IF SQL%NOTFOUND THEN RAISE e_invalid_department; END IF; COMMIT; EXCEPTIO WHEN e_invalid_department THEN DBMS_OUTPUT.PUT_LINE (‘no such department id’); END;
  • 190. Llamando entornos iSQL *Plus Despliega el numero de error y mensaje a la pantalla Constructor de procedimiento Despliega el numero de error y mensaje a la pantalla Formas del desarrollador de Oracle Accesa al numero de error y mensaje en un trigger Aplicación Precompilada Accesa al numero de error a traves de la estructura de datos SQLCA Un Bloque PL/SQL incluído Atrapa excepciones en routinas de exeption-handling del bloque incluído
  • 191. Propagando excepciones DECLARE e_no_rows EXCEPTION; e_integrity EXCEPTION; PRAGMA EXCEPTION_INIT (e_integrity, -2292) BEGIN FOR c_record IN emp_cursor LOOP BEGIN SELECT … UPDATE … IF SQL%NOTFOUND THEN RAISE e_no_rows; END IF; END; END LOOP; EXCEPTION WHEN e_integrity THEN … WHEN e_no_rows THEN … END;
  • 192. Procedimiento RAISE_APLICATION_ERROR
    • Sintaxis:
    Raise_aplication_error (erroe_number, message [, {TRUE | FALSE } ]);
    • Usted puede usar este procedimiento para publicar mensajes de error de subprogramas almacenados.
    • Usted puede reportar errores a su aplicación y permitir el retorno de excepciones no manejables
  • 193. Procedimiento RAISE_APLICATION_ERROR
    • Se usan en dos diferentes lugares:
      • Sección Ejecutable
        • Sección de excepción
    • Retorna condiciones de error al usuario en manera consistente con otros errores del servidor Oracle
  • 194. RAISE_APLICATION_ERROR
    • Sección ejecutable:
    BEGIN … DELETE FROM EMPLOYEES WHERE manager_id = v_mgr; IF SQL%NOTFOUND THEN RAISE APLICATION_ERROR (-20202, ‘este no es un manejador valido’); END IF; …
    • Sección de excepción:
    … EXCEPTION WHEN NO_DATA_FOUND THEN RAISE_APPLICATION ERROR(-20201, ‘el administrador no es empleado valido’); END;
  • 195. Resumen
    • En esta lección, usted debió haber aprendido que :
      • Tipos de excepciones:
          • Error predefinido por el servidor Oracle
          • Error no predefinido por el servidor Oracle
          • Error definido por el usuario
      • Atrapar excepciones
      • Manejar excepciones:
          • Atrapar la excepción dentro del bloque PL/SQL
          • Propagar la excepción
  • 196. CAPITULO 9
  • 197. Objetivos
    • Después de completar esta lección, usted será capaz de hacer lo siguiente:
      • Distinguir bloques anónimos PL/SQL de bloques PL/SQL con nombre (subprogramas)
      • Describir subprogramas
      • Listar los beneficios de usar subprogramas
      • Listar los diferentes entornos de donde los subprogramas pueden ser envocados.
  • 198. objetivos
    • Después de completar esta lección, usted será capaz de hacer lo siguiente:
      • Ddescribir bloques PL/SQL y subprogramas
      • Describir los usos de procedimientos
      • Crear procedimeintos
      • Diefrenciar entre parametros formales y actuales
      • Crear procedimientos si parametros
      • Invocar un procedimeinto
      • Manejar excepciones en procedimeintos
      • Eliminar un procedimiento
  • 199. Vista general de subprogramas
    • Un subprograma:
      • Es un bloque con nombre PL/SQL que puede aceptar parametros y ser invocado desde una llamada del entorno
        • Es de dos tipos:un procedimiento que ejecuta una accion
        • Una funcion que calcula un valor
      • Es basado en estructutras estandar de bloques PL/SQL
      • Provee modularidad, reusabilidad, extensibilidad y manetnimeinto.
      • Provee facil mantenimiento, mejora la seguridad de datos , integridad, funcionamiento y claridad del codigo