Oracle

Programacin de Bases de Datos Oracle
Juan Ruiz de Miras Andrs Molina Aguilar

Universidad de Jan 2001
Universidad de Jan Departamento de Informtica

Prof. Juan Ruiz de Miras Doctor en Informtica Prof. Andrs Molina Aguilar Doctor en Informtica
Prlogo
El objetivo fundamental que nos hemos marcado los autores de estos apuntes, vuestros profesores de Bases de Datos, es proporcionar un material autocontenido que os permita por un lado entender y preparar las prcticas de las diferentes asignaturas de Bases de Datos que debis cursar en los estudios de I.T. en Informtica de Gestin, y tambin que os sirva de base y gua para vuestro desarrollo en uno de los campos claves dentro de la Informtica de Gestin: la Programacin de Bases de Datos. No es objetivo de estos apuntes servir de manual detallado de las herramientas que se estudian, ya que para ello existen los correspondientes manuales de programacin, listados en la bibliografa, de los cuales nosotros hemos extrado la informacin necesaria, intentando proporcionar un texto lo ms didctico y fcil de seguir posible, y quedando de esta forma estos manuales como referencias obligadas para una profundizacin ms detallada en los diferentes aspectos tratados en los diferentes captulos que componen estos apuntes. Persiguiendo que las tcnicas adquiridas y las herramientas utilizadas fueran lo suficientemente amplas para cubrir tanto los conceptos tericos introducidos en las diferentes asignaturas, como tiles para vuestro futuro desempeo laboral, el software elegido ha sido el gestor relacional de bases de datos Oracle y su entorno de programacin Developer/2000. De esta forma dispondremos de un software de amplia difusin profesional que nos permitir implementar aplicaciones completas de acceso a datos: desde el diseo y programacin del servidor de datos, hasta el desarrollo e implementacin de aplicaciones clientes apoyadas en estas bases de datos. En concreto, en primer lugar estudiaremos el lenguaje estndar SQL, que nos permite crear, almacenar, modificar y consultar la informacin almacenada en una base de datos, as como su extensin procedural en Oracle, conocido como PL/SQL, que nos permitir la programacin de disparadores y procedimientos almacenados en el servidor de bases de datos. Finalmente veremos cmo desarrollar aplicaciones clientes en entorno Windows de acceso a bases de datos, utilizando las herramientas propias de Oracle para desarrollo de formularios (FORMS) y de informes (REPORTS) integradas dentro del paquete Developer/2000.
Los autores.
ndice
INTRODUCCIN ................................................................................................................................... 1 1. 2. 3. 4. 5. 5.1. 5.2. INTRODUCCIN.............................................................................................................................. 3 EL RDBMS ORACLE ........................................................................................................................ 3 NOCIONES BSICAS DE SQL*PLUS .................................................................................................. 4 USUARIOS DE LA BASE DE DATOS, CAMBIO DE CONTRASEA............................................................ 4 EL DICCIONARIO DE DATOS DE ORACLE ........................................................................................... 5 TABLAS DEL DICCIONARIO DE DATOS.......................................................................................... 5 LAS VISTAS DEL DICCIONARIO DE DATOS .................................................................................... 6
SQL: LENGUAJE DE CONSULTA ESTRUCTURADO........................................................................ 9 1. INTRODUCCIN............................................................................................................................ 11 2. TIPOS DE DATOS Y CONVERSIN ENTRE TIPOS .............................................................................. 12 3. EXPRESIONES Y OPERADORES CONDICIONALES ............................................................................ 13 4. CREACIN, MODIFICACIN Y DESTRUCCIN DE TABLAS............................................................... 15 4.1. CREACIN DE TABLAS .......................................................................................................... 15 4.2. MODIFICACIN DE TABLAS .................................................................................................... 17 4.2.1. HABILITACIN/DESHABILITACIN DE RESTRICCIONES DE INTEGRIDAD ...................................... 18 4.3. ELIMINACIN DE TABLAS....................................................................................................... 18 5. INSERCIN, MODIFICACIN Y ELIMINACIN DE DATOS.................................................................. 19 5.1. INSERCIN DE DATOS ............................................................................................................. 19 5.2. MODIFICACIN DE DATOS ....................................................................................................... 19 5.3. ELIMINACIN DE DATOS .......................................................................................................... 20 6. CONSULTAS SOBRE LA BASE DE DATOS ........................................................................................ 20 6.1. CONCEPTOS BSICOS RELATIVOS AL COMANDO SELECT ........................................................ 21 6.2. OTROS USOS DEL COMANDO SELECT .................................................................................... 27 6.2.1. CONSULTA DE INFORMACIN AGRUPADA .............................................................................. 30 6.2.2. SUBCONSULTAS .................................................................................................................. 34 6.2.3. VARIABLES DE TUPLA Y CONSULTAS SINCRONIZADAS ............................................................ 35 6.2.4. OPERACIONES ENTRE CONJUNTOS ...................................................................................... 36 7. VISTAS ....................................................................................................................................... 39 7.1. CONCEPTO DE VISTA............................................................................................................... 39 7.2. DEFINICIN DE VISTAS EN ORACLE .......................................................................................... 40 7.3. EJEMPLOS DE UTILIZACIN DE VISTAS ...................................................................................... 41 8. EJERCICIOS RESUELTOS ............................................................................................................. 43 8.1. CREACIN DE TABLAS ............................................................................................................. 43 8.2. MODIFICACIN DE TABLAS ....................................................................................................... 44 8.3. INSERCIN DE TUPLAS ............................................................................................................ 44 8.4. ACTUALIZACIN Y BORRADO DE TUPLAS................................................................................... 46 8.5. CONSULTAS ........................................................................................................................... 46 8.6. VISTAS ................................................................................................................................... 48
PL/SQL: PROGRAMACIN DEL SERVIDOR...................................................................................... 49 1. INTRODUCCIN.............................................................................................................................. 51 1.1. TABLAS PARA LOS EJEMPLOS ......................................................................................................... 52 2. ESTRUCTURA DE LOS BLOQUES PL/SQL ........................................................................................ 52 3. DECLARACIONES ........................................................................................................................... 53 4. ELEMENTOS DEL LENGUAJE ........................................................................................................... 54 5. MANEJO DE CURSORES ................................................................................................................. 56 6. MANEJO DE EXCEPCIONES ............................................................................................................ 58 7. PROCEDIMIENTOS Y FUNCIONES .................................................................................................... 60 8. DISPARADORES (TRIGGERS).......................................................................................................... 63 VISIN GENERAL ...................................................................................................................... 63 8.1. ESTRUCTURA DE LOS DISPARADORES ........................................................................................ 63 8.2. EJEMPLOS DE DISPARADORES ................................................................................................... 65 8.3. PROGRAMACIN DE DISPARADORES .......................................................................................... 67 8.4. MAS SOBRE DISPARADORES ...................................................................................................... 69 8.5.
DEVELOPER/2000: FORMS. PROGRAMACIN DEL CLIENTE........................................................ 71 1. 1.1. 1.2. 2. 3. 3.1. 3.2. 3.3. 4. 4.1. 4.2. 4.3. 5. 6. 7. 7.1. INTRODUCCIN.............................................................................................................................. 73 DESIGNER ................................................................................................................................ 73 RUNFORM................................................................................................................................. 74 ESTRUCTURACIN DE UN FORMATO................................................................................................ 74 EL PROCESO DE DESARROLLO DE UN FORMATO .............................................................................. 76 CREACIN DE UN FORMATO POR DEFECTO ................................................................................. 76 MANIPULACIN DEL FORMATO ................................................................................................... 78 CREACIN DE UN FORMATO GENERAL ........................................................................................ 81 TIPOS DE ITEMS ............................................................................................................................ 83 LIST ITEMS................................................................................................................................ 83 RADIO GROUP ........................................................................................................................... 85 CHECK BOX .............................................................................................................................. 87 LISTAS DE VALORES CALCULADAS EN TIEMPO DE EJECUCIN ........................................................... 88 FORMATOS MAESTRO - DETALLE ................................................................................................... 90 AADIENDO CDIGO A LA APLICACIN: PL/SQL + DISPARADORES .................................................. 93 REFERENCIAS A OBJETOS: OBJETOS DE LA PARTE CLIENTE Y OBJETOS DE LA PARTE SERVIDOR DE LA APLICACIN ...................................................................................................... 94 TIPOS DE DISPARADORES ......................................................................................................... 95 7.2. EL LENGUAJE DE LOS DISPARADORES: PL/SQL.......................................................................... 99 7.3. EJEMPLOS DE DISPARADORES FORMS ............................................................................... 100 7.3.1. 8. CREACIN DE MENS................................................................................................................ 105
DEVELOPER/2000: REPORTS. PROGRAMACIN DEL CLIENTE ................................................. 109 1. 2. 3. 4. 4.1. 4.2. 5. 5.1. 5.2. INTRODUCCIN............................................................................................................................ 111 CONCEPTOS BSICOS.................................................................................................................. 111 EL ENTORNO DE DESARROLLO DEL INFORME ................................................................................. 112 CREACIN DE INFORMES ............................................................................................................. 113 CREACIN DE UN INFORME CON ESTILO TABULAR POR DEFECTO ............................................... 113 MEJORANDO EL ASPECTO DEL INFORME ................................................................................... 116 OTROS ESTILOS DE INFORMES ..................................................................................................... 123 INFORME CON ESTILO MAESTO - DETALLE ................................................................................ 123 INFORME CON ESTILO MATRIZ.................................................................................................. 125
BIBLIOGRAFA ................................................................................................................................. 129
1 Introduccin
Introduccin
1. Introduccin
Las prcticas de las asignaturas de Bases de Datos se van a realizar utilizando el Sistema de Gestin de Bases de Datos Relacional (RDBMS) ORACLE. Varias son las razones que justifican la imparticin de estas prcticas utilizando ORACLE. En primer lugar, ORACLE es un producto comercial ampliamente extendido y utilizado, que cuenta con una importante cuota de mercado dentro del mundo de las bases de datos, estando disponible para prcticamente la totalidad de plataformas posibles (Windows, MAC, UNIX, LINUX, ...) con la ventaja de que las aplicaciones realizadas para una plataforma concreta pueden ser portadas de forma automtica a cualquiera de las otras plataformas. ORACLE permite almacenar gran cantidad de informacin y su posterior manejo de forma rpida y segura, destacando adems su valor educativo, ya que la herramienta que utiliza ORACLE para acceder a la base de datos es el lenguaje no procedural SQL, y este lenguaje es relacionalmente completo, es decir, implementa prcticamente toda la funcionalidad y caractersticas del modelo relacional terico.
2. El RDBMS ORACLE
ORACLE como todo sistema de base de datos est constituido por los datos, esto es, un conjunto de ficheros que contienen la informacin que forma la base de datos, y por un software encargado de manipular la base de datos llamado RDBMS. Pero, adems, ORACLE proporciona una serie de herramientas para trabajar con la base de datos, algunas de ellas son: SQL*PLUS: es una herramienta de programacin y consulta que permite a los usuarios la manipulacin directa de la informacin de la base de datos usando el lenguaje SQL. DEVELOPER/2000: es un conjunto de programas clientes que se ejecutan bajo plataforma WINDOWS y que permiten crear de una manera cmoda y rpida aplicaciones clientes ejecutables bajo WINDOWS para acceder, manipular y mostrar la informacin almacenada en un servidor ORACLE. Precompiladores: es un conjunto de utilidades que permiten insertar dentro de programas escritos en lenguajes de programacin tradicionales (C, PASCAL, COBOL, ...) sentencias SQL y bloques PL/SQL (lenguaje estructurado de Oracle). SQL*DBA: es la utilidad que permite realizar las tareas de administracin de la base de datos. En los captulos posteriores se van a estudiar, en primer lugar el lenguaje de programacin SQL, estndar para el acceso a base de datos; posteriormente ampliaremos las posibilidades de programacin del servidor ORACLE mediante el estudio del lenguaje PL/SQL que permite una programacin avanzada a travs de la utilizacin de disparadores y prodecimientos almacenados; Universidad de Jan
Introduccin
finalmente se desarrollar un estudio a modo de tutorial de parte de DEVELOPER/2000, en concreto de FORMS 4.5 y REPORTS 2.5, lo que permitir desarrollar cualquier aplicacin clsica de gestin de bases de datos en entorno cliente/servidor y dentro del marco de las herramientas proporcionadas por Oracle.
3. Nociones bsicas de SQL*Plus

PLUS31 es un cliente SQL para bases de datos Oracle. El servidor Oracle se encuentra instalado en un servidor aparte. En este servidor reside el RDBMS Oracle (software + base de datos fsica) y el software de red (SQL*Net). Una vez ejecutado el programa aparece en pantalla la ventana LOG ON, la cual pide los parmetros necesarios para realizar la conexin al servidor Oracle. Estos parmetros son el nombre de usuario, el password y la cadena de conexin que establece el protocolo de comunicacin que se va a utilizar, la direccin de la mquina que corre el servidor Oracle y el nombre de la base de datos a la que se quiere acceder (a partir de SQL*Net v. 2 esta cadena de conexin queda enmascarada con un alias que se establece en el fichero tnsnames.ora que debe aparecer tanto en el servidor como en cada cliente). Existen dos comandos bsicos de SQL*Plus, no de SQL, que son host y start. El comando HOST sirve para ejecutar comandos del sistema operativo sin necesidad de abandonar ORACLE. Un ejemplo de este comando sera host dir. Si se ejecuta el comando host sin ningn argumento, se abre una ventana shell del sistema operativo que se cerrar al ejecutar exit. El comando START (se puede abreviar utilizando el smbolo @) permite ejecutar ficheros que contengan conjuntos de comandos SQL SQL*Plus, ahorrando el tener que volver a introducirlos uno a uno. Para editar estos ficheros de comandos se puede utilizar cualquier editor de textos. Estos ficheros de comandos suelen llevar la extensin .SQL.
4. Usuarios de la base de datos, cambio de contrasea

Oracle es un RDBMS multiusuario, lo que significa que para poder acceder a una base de datos Oracle se debe tener cuenta en ella. Cada usuario dentro de la base de datos tiene un nombre de usuario (username) y una palabra clave (password). La creacin de usuarios dentro de la base de datos es una de las tareas del DBA (Administrador de la Base de Datos). Cuando el DBA aade un usuario a la base de datos, establece su username y su password, aunque el nuevo usuario puede posteriormente cambiar el password utilizando el comando SQL ALTER USER. La forma de aadir usuarios a la base de datos y establecer los privilegios de que van a gozar es mediante el comando SQL GRANT. Una manera sencilla de crear un nuevo usuario con nombre de usuario user1, password pp100 y con privilegios de conexin y de creacin de objetos es: GRANT connect, resource TO user1 IDENTIFIED BY pp100; Para tener un control ms detallado (asignacin de quotas, recursos, privilegios, ...) de la creacin de usuarios se utiliza el comando CREATE USER. En un momento determinado puede interesar eliminar algn privilegio de un usuario concreto, para ello se utiliza el comando de SQL REVOKE. Universidad de Jan 4
Introduccin
Si el usuario con username user1 quiere cambiar su password establecindolo como pp453, debe ejecutar el siguiente comando SQL desde SQL*Plus: ALTER USER user1 IDENTIFIED BY pp453;
5. El Diccionario de Datos de ORACLE

El diccionario de datos (DD) de ORACLE es uno de los componentes ms importantes del DBMS ORACLE. Contiene toda la informacin sobre las estructuras y objetos de la base de datos as como de las tablas, columnas, usuarios, ficheros de datos, etc. Los datos guardados en el diccionario de datos son tambin llamados metadatos. Aunque el DD es usualmente del dominio del administrador de base de datos (DBA), es una valiosa fuente de informacion para los usuarios y desarrolladores. El DD consta dos niveles: nivel interno: contiene todas las tablas base que son utilizadas por el SGBD y que no son normalmente accesibles para el usuario, nivel externo: proporciona numerosas vistas de estas tablas base para acceder a la informacin sobre objetos y estructuras a diferentes niveles con detalle.
5.1. Tablas del Diccionario de Datos

La instalacin de una base de datos ORACLE siempre incluye la creacin de tres usuarios standard ORACLE: SYS: este es el propietario de todas las tablas del DD y de las vistas. Esta utilidad tiene el enorme privilegio de manejar objetos y estructuras de una base de datos ORACLE as como crear nuevos usuarios. SYSTEM: es el propietario de las tablas usadas por las diferentes herramientas como SQL*Forms, SQL*Reports etc. PUBLIC: este es un usuario dominante en una base de datos ORACLE. Todos los privilegios asignados a este usuario son automticamente asignados a todos los usuarios que se conocen en la base de datos. Las tablas y vistas que proporciona el DD contienen informacin sobre: Usuarios y sus privilegios Tablas, columnas de tabla y sus tipos de datos, restricciones de integridad e ndices Estadsticas sobre tablas e ndices usados Privilegios concedidos a los objetos de la BD Estructuras de almacenamiento de la BD El comando SQL SELECT * FROM DICTIONARY;
lista todas las tablas y vistas del diccionario de base de datos que son accesibles para el usuario. La 5 Universidad de Jan
Programacin de Bases de Datos Oracle informacin seleccionada incluye el nombre y una corta descripcin de cada tabla y vista. La consulta SELECT * FROM TABS;
Introduccin
recupera los nombres de todas las tablas pertenecientes al usuario que emite este comando. La consulta SELECT * FROM COL; devuelve toda la informacin sobre las columnas de algunas tablas. Cada operacin SQL requiere de varios accesos directos a las tablas y vistas del DD. Puesto que el diccionario de datos en s mismo consiste en tablas, ORACLE tiene que generar numerosas sentencias SQL para chequear si el comando SQL emitido por el usuario es correcto y puede ser ejecutado. Por ejemplo, la consulta SQL SELECT * FROM EMPLEADO WHERE SALARIO> 2000; requiere la verificacin de si (1) la tabla EMPLEADO existe, (2) el usuario tiene el privilegio de acceder a esta tabla, (3) la columna SALARIO est definida en esta tabla, etc.
5.2. Las vistas del Diccionario de Datos

El nivel externo del DD proporciona un interface para acceder a la informacin relevante para los usuarios. Este nivel tiene numerosas vistas (en ORACLE7 aproximadamente 540) que representan (una porcin de) los datos de las tablas base del DD de un modo legible y entendible. Estas vistas pueden utilizarse en consultas SQL como si fueran tablas normales. Las vistas proporcionadas por el DD se dividen en tres grupos: USER, ALL y DBA. Los nombres de los grupos construyen el prefijo para cada nombre de tabla. Para algunas vistas, hay sinonimos asociados (descritos en las tablas adjuntas). USER_: las tuplas en la vista USER contienen informacin sobre objetos pertenecientes al usuario que realiza la consulta SQL (usuario actual). USER_TABLES USER_CATALOG USER_COL_COMMENTS USER_CONSTRAINTS USER_INDEXES USER_OBJECTS USER_TAB_COLUMNS USER_TAB__COMMENTS USER_TRIGGERS USER_USERS USER_VIEWS Todas las tablas con su nombre, numero de columnas, informacin almacenada, etc. (TABS) Tablas, vistas y sinnimos (CAT) Comentarios en columnas Definiciones de restricciones para tablas Informacin sobre indices creados para las tablas (IND) Todos los objetos de la BD propiedad del usuario(OBJ) Columnas de las tablas y vistas propiedad del usuario (COLS) Comentarios sobre tablas y vistas Disparadores definidos por el usuario Informacin sobre el usuario actual Vistas definidas por el usuario
Universidad de Jan
Introduccin
ALL_: las filas de las vistas ALL contienen idntica informacin que las vistas USER pero de todos los usuarios. La estructura de estas vistas es anloga a la estructura de las vistas USER. ALL_TABLES ALL_CATALOG ALL_OBJECTS ALL_TRIGGERS ALL_USERS ALL_VIEWS Propietario, nombre de todas las tablas accesibles Propietario, tipo y nombre de todas las tablas accesibles, vistas y sinnimos. Propietario, tipo y nombre de todos los objetos accesibles de la BD . . .
DBA_: Las vistas DBA incluyen informacin sobre todos los objetos de la BD sin tener a los propietarios de dichos objetos. Slo los usuarios con privilegios DBA pueden acceder a estas vistas.
DBA_TABLES DBA_CATALOG DBA_OBJECTS DBA_DATA_FILES DBA_USERS
Tablas de todos los usuarios de la BD Tablas vistas y sinnimos definidos en la BD Objetos de todos los usuarios Informacin sobre los ficheros de datos Informacin sobre los usuarios de la BD
Universidad de Jan
2 SQL: Lenguaje de Consulta Estructurado
SQL
1. Introduccin
SQL (Structured Query Language, Lenguaje de Consulta Estructurado) es un lenguaje de programacin estndar para el acceso a bases de datos. La mayora de bases de datos comerciales permiten ser accedidas mediante SQL, siendo mnimas las diferencias entre las distintas implementaciones. El lenguaje SQL que va a ser estudiado es el implementado en la versin 7 del RDBMS Oracle. A diferencia de otros lenguajes de programacin, programar en SQL es relativamente sencillo, debido principalmente a que es un lenguaje no procedural, es decir, se dice QU es lo que se quiere hacer pero no CMO hacerlo; adems de la sencillez conceptual del modelo relacional en que se basa SQL. SQL, como cualquier lenguaje de base de datos, se divide bsicamente en: Lenguaje de Definicin de Datos (DDL): proporciona rdenes para definir, modificar o eliminar los distintos objetos de la base de datos (tablas, vistas, ndices...). Lenguaje de Manipulacin de Datos (DML): proporciona rdenes para insertar, suprimir y modificar tuplas de las tablas de la base de datos. Lenguaje de Control de Datos (DCL): que permite establecer derechos de acceso de los usuarios sobre los distintos objetos de la base de datos. Existen bsicamente dos formas de utilizar SQL para acceder a una base de datos: a travs de un intrprete SQL conectado a la base de datos (como por ejemplo SQL*Plus de Oracle), o bien insertando cdigo SQL dentro de programas escritos en otros lenguajes como C o COBOL. A este ltimo SQL se le denomina SQL empotrado y requiere de un preproceso que convierta los comandos SQL en llamadas a libreras propias de ese lenguaje de programacin. Evidentemente no es el objetivo de esta publicacin dar un manual completo del lenguaje, sino estudiar los comandos fundamentales que permitan implementar cualquier aplicacin estndar. En la bibliografa se proponen varios libros que profundizan en todos los detalles del lenguaje.
NOTA: la notacin utilizada para la especificacin de los comandos de SQL es la siguiente: palabras clave en maysculas, los corchetes [] indican opcionalidad, las llaves {} delimitan alternativas separadas por | de las que se debe elegir una, los puntos suspensivos ... indican repeticin varias veces de la opcin anterior.
11
Universidad de Jan
SQL
2. Tipos de datos y conversin entre tipos

Los tipos de datos principales de ORACLE son los siguientes: VARCHAR(n): dato de tipo carcter, de n caracteres de longitud. NUMBER: dato de tipo numrico de un mximo de 40 dgitos, adems del signo y el punto decimal. Se puede utilizar notacin cientfica (1.273E2 es igual a 127.3). NUMBER(n,d): dato de tipo numrico con n dgitos en total como mximo y d dgitos decimales como mucho. NUMBER(4,2) tiene como mximo valor 99.99. DATE: datos de tipo fecha.
Cadenas de caracteres (VARCHAR(n)): Se delimitan utilizando comillas simples: Hola, Una cadena. Adems de los operadores de comparacin e igualdad (<, >, =, !=, ...) otras funciones tiles para trabajar con cadenas son: cad || cad : concatena dos cadenas. LENGTH(cad): devuelve la longitud de la cadena. LOWER(cad): convierte todas las letras de la cadena a minsculas. UPPER(cad): dem a maysculas. SUBSTR(cad, comienzo [, cuenta]): extrae la subcadena de cad empezando en la posicin comienzo y con longitud (la subcadena) cuenta. El primer caracter de la cadena tiene como ndice el nmero 1.
Nmeros (NUMBER): Adems de las operaciones tpicas con valores numricos (+, -, *, /), otras funciones tiles son: ABS(num): devuelve el valor absoluto. SQRT(num): devuelve la raz cuadrada. POWER(b,e): devuelve la potencia be. GREATEST(num1, num2, ...): devuelve el mayor valor de la lista de valores. LEAST(num1, num2, ...): devuelve el menor valor de la lista. Existen otras funciones para grupos de valores (suma, media, mximo, ...) que se vern en apartados posteriores.
Universidad de Jan
12
SQL Fechas (DATE):
El formato de una valor de tipo DATE es: dd-mmm-yy, donde tanto el da como el ao tiene formato numrico y el mes se indica con las tres primeras letras del nombre del mes en el idioma soportado por el servidor ORACLE. Ejemplos: 1-JAN-96, 28-jul-74. Adems de esta informacin, un valor de tipo fecha almacena tambin la hora en formato hh:mm:ss. Las fechas se pueden comparar con los operadores tpicos de comparacin (<, >, !=, =, ...). La funcin SYSDATE devuelve la fecha actual (fecha y hora). Con las fechas es posible realizar operaciones aritmticas como sumas y restas de fechas, teniendo en cuenta que a una fecha se le suman das y que la diferencia entre dos fechas se devuelve tambin en das. Por ejemplo SYSDATE + 1 devuelve la fecha de maana. Oracle permite tanto la conversin de tipos implcita como la explcita. La conversin de tipos implcita significa que cuando Oracle encuentra en un lugar determinado (por ejemplo en una expresin) un dato de un tipo diferente al esperado, entonces aplica una serie de reglas para intentar convertir ese dato al tipo esperado. Por ejemplo, si un atributo de una tabla determinada es de tipo NUMBER y se intenta introducir el valor de tipo caracter '1221', entonces automticamente se convierte en su valor numrico equivalente sin producirse ningn error. La conversin de tipos explcita se realiza bsicamente con las siguientes funciones: Conversin nmero-cadena: TO_CHAR(nmero [, formato]). Conversin cadena-nmero: TO_NUMBER(cadena [,formato]). Conversin fecha-cadena: Conversin cadena-fecha: TO_CHAR(fecha [, formato]). TO_DATE(cadena [, formato]).
La opcin formato permite especificar un modelo de formato o mscara consistente en una cadena de caracteres que describe el formato en el que se quiere obtener el resultado o en el que se da el parmetro. Algunos ejemplos de la utilizacin de estas funciones son: TO_CHAR('25-dec-98', 'YY') devuelve '98'. TO_CHAR(123.34,'09999.999') devuelve '00123.340'.
3. Expresiones y operadores condicionales

Las condiciones son expresiones lgicas (devuelven verdadero o falso) que se sitan normalmente junto a una clusula SQL que utilizan muchos comandos, la clusula WHERE. La clusula WHERE selecciona un subconjunto de tuplas, justo aquellas que cumplen la condicin especificada. Una condicin tambin puede aparecer en otras clusulas de determinados comandos SQL, como por ejemplo en la clusula CHECK que sirve para establecer condiciones sobre los valores almacenados en una tabla. Las condiciones se construyen utilizando los operadores de comparacin y los operadores lgicos. A continuacin se describen los operadores ms importantes junto con ejemplos de su utilizacin. =, <>, <=, >=, < y >. Ejemplos: horas >= 10.5 13 Universidad de Jan
Programacin de Bases de Datos Oracle nombre = 'PEPE' fecha < 1-ene-93
SQL
[NOT] IN lista_valores: Comprueba la pertenencia a la lista de valores. Generalmente, los valores de la lista se habrn obtenido como resultado de un comando SELECT (comando de consulta). Ejemplo: nombre NOT IN ('PEPE', 'LOLA') oper {ANY | SOME} lista_valores: Comprueba que se cumple la operacin oper con algn elemento de la lista de valores. oper puede ser <, >, <=, >=, <>. Ejemplo: nombre = ANY ('PEPE', 'LOLA') oper ALL lista_valores: Comprueba que se cumple la operacin oper con todos los elementos de la lista de valores. oper puede ser <, >, <=, >=, <>. Ejemplo: nombre <> ALL ('PEPE', 'LOLA') [NOT] BETWEEN x AND y: Comprueba la pertenencia al rango x - y. Ejemplo: horas BETWEEN 10 AND 20 que equivale a horas >= 10 AND horas <= 20 [NOT] EXISTS lista_valores: Comprueba si la lista de valores contiene algn elemento. Ejemplos: EXISTS ('ALGO') devuelve verdadero. NOT EXISTS ('ALGO') devuelve falso. [NOT] LIKE: Permite comparar cadenas alfanumricas haciendo uso de smbolos comodn. Estos smbolos comodn son los siguientes: _ : sustituye a un nico carcter. %: sustituye a varios caracteres. Ejemplos: nombre LIKE 'Pedro%' codigo NOT LIKE 'cod1_' Si dentro de una cadena se quieren utilizar los caracteres '%' o '_' tienen que ser escapados utilizando el smbolo '\'. IS [NOT] NULL: Cuando el valor de un atributo, o es desconocido, o no es aplicable esa informacin, se hace uso del valor nulo (NULL). Para la comparacin de valores nulos se utiliza el operador IS [NOT] NULL. Universidad de Jan 14
SQL
Ejemplo: telefono IS NULL Los operadores lgicos junto con el uso de parntesis permiten combinar condiciones simples obteniendo otras ms complejas. Los operadores lgicos son: OR: nombre = 'PEPE' OR horas BETWEEN 10 AND 20 AND: horas > 10 AND telefono IS NULL NOT: NOT (nombre IN ('PEPE','LUIS'))
4. Creacin, modificacin y destruccin de TABLAS

Los tres comandos SQL que se estudian en este apartado son CREATE TABLE, ALTER TABLE y DROP TABLE, pertenecientes al DDL. Estos comandos permiten respectivamente crear y modificar la definicin de una tabla y eliminarla de la base de datos.
4.1. Creacin de TABLAS

Para la creacin de tablas con SQL se utiliza el comando CREATE TABLE. Este comando tiene una sintaxis ms compleja de la que aqu se expone, pero se van a obviar aquellos detalles que quedan fuera del mbito de esta publicacin.
La sintaxis del comando es la siguiente: CREATE TABLE nombre_tabla ( {nombre_columna tipo_datos [restriccin_columna] ... | restriccin_tabla} [,{nombre_columna tipo_datos [restriccin_columna] ... | restriccin_tabla}] ... ); Donde restriccin_columna tiene la sintaxis: [CONSTRAINT nombre_restriccin] {[NOT] NULL | {UNIQUE | PRIMARY KEY} | REFERENCES nombre_tabla [(nombre_columna)] [ON DELETE CASCADE] | CHECK (condicin) }
15
Universidad de Jan
Programacin de Bases de Datos Oracle y restriccin_tabla tiene la sintaxis: [CONSTRAINT nombre_restriccin] {{UNIQUE | PRIMARY KEY} (nombre_columna [,nombre_columna] ...) | FOREIGN KEY (nombre_columna [,nombre_columna] ...) REFERENCES nombre_tabla [(nombre_columna [,nombre_columna] ...)] [ON DELETE CASCADE] } El significado de las distintas opciones es:
SQL
UNIQUE: impide que se introduzcan valores repetidos para ese atributo. No se puede utilizar junto con PRIMARY KEY. NOT NULL: evita que se introduzcan tuplas con valor NULL para ese atributo. PRIMARY KEY: establece ese atributo como la llave primaria de la tabla. CHECK (condicin): permite establecer condiciones que deben cumplir los valores introducidos en ese atributo. La condicin puede ser cualquier expresin vlida que sea cierta o falsa. Puede contener funciones, atributos (de esa tabla) y literales. Si un CHECK se especifica como una restriccin de columna, la condicin slo se puede referir a esa columna. Si el CHECK se especifica como restriccin de tabla, la condicin puede afectar a todas las columnas de la tabla. Slo se permiten condiciones simples, por ejemplo, no est permitido referirse a columnas de otras tablas o formular subconsulas dentro de un CHECK. Adems las funciones SYSDATE y USER no se pueden utilizar dentro de la condicin. En principio estn permitidas comparaciones simples de atributos y operadores lgicos (AND, OR y NOT). PRIMARY KEY lista_columnas: sirve para establecer como llave primaria un conjunto de atributos. FOREIGN KEY: define una llave externa de la tabla respecto de otra tabla. Esta restriccin especifica una columna o una lista de columnas como de clave externa de una tabla referenciada. La tabla referenciada se denomina tabla padre de la tabla que hace la referencia llamada tabla hija. En otras palabras, no se puede definir una restriccin de integridad referencial que se refiere a una tabla antes de que dicha tabla haya sido creada. Es importante resaltar que una clave externa debe referenciar a una clave primaria completa de la tabla padre, y nunca a un subconjunto de los atributos que forman esta clave primaria. ON DELETE CASCADE: especifica que se mantenga automticamente la integridad referencial borrando los valores de la llave externa correspondientes a un valor borrado de la tabla referenciada (tabla padre). Si se omite esta opcin no se permitir borrar valores de una tabla que sean referenciados como llave externa en otras tablas. En la definicin de una tabla pueden aparecer varias clusulas FOREIGN KEY, tantas como llaves externas tenga la tabla, sin embargo slo puede existir una llave primaria, si bien esta llave primaria puede estar formada por varios atributos. La utilizacin de la clusula CONSTRAINT nombre_restriccin establece un nombre determinado para la restriccin de integridad, lo cual permite buscar en el Diccionario de Datos de la base de datos con posterioridad y fcilmente las restricciones introducidas para una determinada tabla. Ejemplo: CREATE TABLE coches (
Universidad de Jan
16
SQL mat marca an_fab );
Programacin de Bases de Datos Oracle VARCHAR(8) CONSTRAINT pk_coches PRIMARY KEY, VARCHAR(15), NUMBER(2)
En los ejercicios de este tema se pueden encontrar ms ejemplos del comando CREATE TABLE correspondientes a las tablas que van a ser utilizadas para ejemplificar los distintos conceptos introducidos en los temas relativos a Oracle. El comando de SQL*PLUS describe nombre_tabla permite ver la definicin de una tabla concreta de la base de datos. En esta descripcin aparecern los nombres de los atributos, el tipo de datos de cada atributo y si tiene o no permitidos valores NULL. Toda la definicin y restricciones de una tabla creada con el comando CREATE TABLE pueden ser consultadas a travs de las siguientes tablas y vistas del Diccionario de Datos de Oracle: USER_TABLES: almacena toda la informacin de almacenamiento fsico relativa a una tabla. USER_CONSTRAINTS: almacena todas las restricciones de integridad definidas por un usuario concreto. USER_CONS_COLUMNS: almacena las restricciones de integridad definidas sobre cada atributo.
4.2. Modificacin de TABLAS

Para modificar la definicin de una tabla se utiliza el comando ALTER TABLE. Las posibles modificaciones que se pueden hacer sobre la definicin de una tabla son aadir un nuevo atributo o modificar uno ya existente. Estas dos operaciones se podrn realizar pero teniendo en cuenta una serie de restricciones que posteriormente se detallarn. La sintaxis que a continuacin se expone es tambin restringida, por las mismas razones expuestas para CREATE TABLE. ALTER TABLE nombre_tabla [ADD { nombre_columna tipo [restriccin_columna] ... | restriccin_tabla ...}] [MODIFY {nombre_columna [tipo] [restriccin_columna] ...];
La opcin ADD permite aadir un nuevo atributo a la tabla, con un valor NULL inicial para todas las tuplas. MODIFY cambia la definicin del atributo que ya existe en la tabla. Las restricciones a tener en cuenta son las siguientes: restriccin_columna slo puede ser NOT NULL. Se puede cambiar el tipo del atributo o disminuir su tamao slo si todas las tuplas tienen en ese atributo el valor NULL. Un atributo NOT NULL nicamente se puede aadir a una tabla sin tuplas. Un atributo ya existente slo se puede hacer NOT NULL si todas las tuplas tiene en ese atributo un valor distinto de NULL. Cuando se modifica un atributo, todo lo no especificado en la modificacin se mantiene tal y como estaba.
17
Universidad de Jan
Programacin de Bases de Datos Oracle Ejemplos: ALTER TABLE coches ADD (modelo VARCHAR(15)); ALTER TABLE coches MODIFY (an_fab VARCHAR(4));
SQL
4.2.1.
Habilitacin/deshabilitacin integridad
de
restricciones
de
Si una restriccin de integridad se define mediante el comando CREATE TABLE o se aade con el comando ALTER TABLE, la condicin se habilita automticamente. Una restriccin puede ser posteriormente deshabilitada con el comando ALTER TABLE: ALTER TABLE nombre_tabla DISABLE {CONSTRAINT nombre_constraint | PRIMARY KEY | UNIQUE [lista_columnas] } [CASCADE]; Para deshabilitar una clave primaria, han de deshabilitarse previamente todas las restricciones de clave externa que dependan de esa clave primaria. La clusula CASCADE deshabilita automticamente las restricciones de clave externa que dependen de la (deshabilitada) clave primaria. Ejemplo: Deshabilitar la clave primaria de la tabla coches: ALTER TABLE coches DISABLE PRIMARY KEY CASCADE; Para habilitar las restricciones de integridad, se utiliza la clusula ENABLE en lugar de DISABLE. Una restriccin puede ser habilitada de forma satisfactoria slo si no hay ninguna tupla que viole la restriccin que se desea habilitar. En el caso de esto ocurra, aparece un mensaje de error. Ntese que para habilitar/deshabilitar una restriccin de integridad es importante haber dado nombre a todas las restricciones.
4.3. Eliminacin de TABLAS

Para eliminar una tabla de la base de datos se utiliza el comando: DROP TABLE nombre_tabla [CASCADE CONSTRAINTS]; La opcin CASCADE CONSTRAINTS permite eliminar una tabla que contenga atributos referenciados por otras tablas, eliminando tambin todas esas referencias. Evidentemente, toda la informacin almacenada en la tabla desaparecer con ella. Si la llave primaria de la tabla es una llave externa en otra tabla y no utiliza la opcin CASCADE CONSTRAINTS, entonces no se podr eliminar la tabla. Ejemplo: DROP TABLE coches; Universidad de Jan 18
SQL
5. Insercin, modificacin y eliminacin de DATOS

Una vez que se ha creado de forma conveniente las tablas, el siguiente paso consiste en insertar datos en ellas, es decir, aadir tuplas. Durante la vida de la base de datos ser necesario, adems, borrar determinadas tuplas o modificar los valores que contienen. Los comandos de SQL que se van a estudiar en este apartado son INSERT, UPDATE y DELETE. Estos comandos pertenecen al DML.
5.1. Insercin de Datos

El comando INSERT de SQL permite introducir tuplas en una tabla o en una vista (estudiadas posteriormente) de la base de datos. La sintaxis del comando es la siguiente: INSERT INTO {nombre_tabla | nombre_vista} [(nombre_columna [, nombre_columna] ...)] {VALUES (valor [, valor] ...) | sub_consulta }; Con el comando INSERT se aade una tupla a la tabla o a la vista. Si se da una lista de columnas, los valores deben emparejar uno a uno con cada una de estas columnas. Cualquier columna que no est en la lista recibir el valor NULL. Si no se da esta lista de columnas, se debern dar valores para todos los atributos de la tabla y en el orden en que se definieron con el comando CREATE TABLE. Si se elige la opcin de sub_consulta, se introducirn en la tabla las tuplas resultantes de la subconsulta expresada como un comando SELECT que ser estudiado posteriormente. Ejemplos: INSERT INTO coches VALUES (M2030KY,RENAULT,1995,CLIO); INSERT INTO coches (mat,marca,modelo,an_fab) VALUES (M2030KY,RENAULT,CLIO,1995);
5.2. Modificacin de Datos

Para la modificacin de tuplas dentro de una tabla o vista se utiliza el comando UPDATE. La sintaxis del comando es la siguiente: UPDATE {nombre_tabla | nombre_vista} SET {nombre_col = expresin [, nombre_col = expresin, ...] | nombre_col [, nombre_col, ...] = (sub_consulta) } [WHERE condicin]; Este comando modifica los valores de los atributos especificados en SET para aquellas tuplas que verifican condicin (si existe). La subconsulta puede seleccionar de la tabla o vista que se est modificando (o de otras tablas o vistas), aunque debe devolver una nica tupla. Si no se utiliza la clusula WHERE, se modificarn todas las tuplas de la tabla o vista. Si se utiliza la clusula WHERE slo 19 Universidad de Jan
SQL
se modificarn aquellas tuplas que verifiquen la condicin. Hay que tener en cuenta que las expresiones se van evaluando segn se va ejecutando el comando UPDATE. Ejemplos: El siguiente comando modifica el ao de fabricacin del coche con matrcula 'M2030KY': UPDATE coches SET an_fab = 1996 WHERE mat =M2030KY; Para modificar el ao de fabricacin de todos los coches aadindoles una unidad: UPDATE coches SET an_fab = an_fab + 1;
5.3. Eliminacin de Datos

Por ltimo, se va a estudiar el comando que permite eliminar tuplas concretas de una tabla o vista determinada, el comando DELETE. Su sintaxis es la siguiente: DELETE FROM {nombre_tabla | nombre_vista} [WHERE condicin]; Si se omite la clusula WHERE, este comando borrar todas las tuplas de la tabla o vista indicada, aunque sta seguir existiendo, pero sin ninguna tupla. Si se introduce la clusula WHERE, slo se borrarn aquellas tuplas que verifiquen la condicin. Ejemplos: DELETE FROM coches WHERE an_fab < 1910; DELETE FROM coches; NOTA: a partir de este punto se supone creada la base de datos con las tablas y datos corrrespondientes a las soluciones de los ejercicios 1 a 4 (ver apartado 8).
6. Consultas sobre la base de datos

En este apartado se va a estudiar el comando SELECT de SQL. Se puede decir que SELECT es el comando principal del SQL, ya que tiene como objetivo prioritario el obtener la informacin precisa de la base de datos. Esta informacin se obtendr de una o ms tablas o vistas. El comando SELECT, adems, se utiliza dentro de otros comandos, como por ejemplo en CREATE TABLE, INSERT, UPDATE, ...
Universidad de Jan
20
SQL
6.1. Conceptos bsicos relativos al comando SELECT

La sintaxis fundamental del comando SELECT es la siguiente: SELECT [ALL, DISTINCT]{[*|tabla.*],expresin[,expresin,...]} FROM tabla [, tabla, ...] [WHERE condicin] [ORDER BY {expresin | posicin} [ASC | DESC] [expresin | posicin} [ASC | DESC] , ...]] [GROUP BY expresin [, expresin, ...]] [HAVING condicin];
Las distintas opciones tienen el siguiente significado: ALL: significa que se devolvern todas las tuplas que satisfagan las distintas condiciones, esta opcin es la que se toma por defecto. DISTINCT: significa que se devolvern valores o conjuntos de valores nicos, es decir, no repetidos. *: indica que se realizar la proyeccin por todos los atributos de la/s tabla/s o vista/s indicadas en la clusula FROM. Si se quiere que slo se proyecte por los atributos de una tabla se utiliza tabla.*. expresin: se puede sustituir por: nombre de un atributo expresin conteniendo atributos y/o funciones. Si en el listado de la consulta debe aparecer un nombre distinto al del atributo o al de la expresin se puede utilizar un ALIAS, que consiste en una cadena de caracteres encerrada entre comillas dobles y situada junto a la expresin que sustituir en el listado de la consulta. Otro tipo de alias es el que se utiliza para las tablas en la clusula FROM. Estos alias se ponen junto al nombre de la tabla y se pueden utilizar en cualquier punto del comando SELECT sustituyendo as al nombre de la tabla. Las condiciones de las clusulas WHERE y HAVING son cualquiera de las vistas en el apartado 3 de este captulo (expresiones que devuelven verdadero o falso), adems de algunas nuevas que se vern en el siguiente apartado. En la clusula ORDER BY, posicin sirve para referenciar un atributo que ocupa esa posicin dentro de la clusula SELECT.
Desde el punto de vista de las operaciones abstractas de consulta del modelo relacional, la clusula SELECT corresponde a la operacin de proyeccin; la clusula FROM corresponde a la operacin de producto cartesiano (nos permitir hacer el JOIN); y la clusula WHERE corresponde a la condicin de la operacin de seleccin.
21
Universidad de Jan
Programacin de Bases de Datos Oracle Una tpica consulta: SELECT FROM WHERE a1, a2, ..., an r1, r2 p;
SQL
equivale a la expresin en trminos de operaciones abstractas: Proyeccina1, a2, ..., an (Seleccinp (r1 X r2)), donde X es el producto cartesiano. El resultado de un comando SELECT es siempre una tabla, lo que permite construir consultas complejas anidando varios SELECT. A continuacin se explica el significado del resto de clausulas del comando SELECT viendo sus tpicos usos. Obtener toda la informacin contenida en una tabla: SELECT * FROM nombe_tabla ; El asterisco indica que se quieren seleccionar todas la columnas de la tabla, y al no especificarse ninguna condicin, todas la tuplas son seleccionadas. Ejemplo: Obtener toda la informacin almacenada en la tabla COCHES: SQL> SELECT * FROM coches; MAT -------M3020KY J1234Z GR4321A B4444AC CA0000AD GR1111AK J9999AB MARCA AN_FAB MODELO --------------- --------- --------------TOYOTA 1996 CARINA RENAULT 1997 MEGANE RENAULT 1978 5 PEUGEOT 1978 504 PEUGEOT 1996 205 PEUGEOT 1998 207 VW 1998 BEATTLE
Seleccionar nicamente algunas de las columnas, se deben especificar cules son estas columnas en la clusula SELECT: SELECT lista_nombre_columnas FROM nombre_tabla ; Esta operacin es equivalente a la operacin proyeccin. Ejemplo: Obtener, para cada coche, su marca y modelo: SQL> SELECT marca,modelo FROM coches; MARCA --------------TOYOTA RENAULT RENAULT PEUGEOT PEUGEOT PEUGEOT VW MODELO --------------CARINA MEGANE 5 504 205 207 BEATTLE
Universidad de Jan
22
SQL
Para consultar slo determinadas tuplas de una tabla se hace uso en el comando SELECT de la clusula WHERE condicin, donde la condicin podr venir expresada segn lo visto en el punto 3 de este tema. Ejemplos: Coches que no son fueron fabricados entre 1990 y 1999: SQL> SELECT * FROM coches WHERE an_fab NOT BETWEEN 1990 AND 1999; MAT -------GR4321A B4444AC MARCA AN_FAB MODELO --------------- --------- --------------RENAULT 1978 5 PEUGEOT 1978 504
Marca y modelo de los coches de Granada: SQL> SELECT marca,modelo FROM coches WHERE UPPER(SUBSTR(mat,1,2))='GR'; MARCA --------------RENAULT PEUGEOT MODELO --------------5 207
Para consultar informacin usando operaciones, en los comandos SELECT se pueden utilizar expresiones tales como operaciones aritmticas, operaciones con cadenas de caracteres. Ejemplos: Obtener las dos primeras fechas de revisin ITV para los coches. SQL> SELECT mat,an_fab, an_fab+5"Primera revision", an_fab+7"Segunda revision" FROM coches; MAT AN_FAB Primera revision Segunda revision -------- --------- ---------------- ---------------M3020KY 1996 2001 2003 J1234Z 1997 2002 2004 GR4321A 1978 1983 1985 B4444AC 1978 1983 1985 CA0000AD 1996 2001 2003 GR1111AK 1998 2003 2005 J9999AB 1998 2003 2005 Obtener el nmero de caracteres que suman la marca y el modelo de cada coche. SQL> SELECT marca,modelo, LENGTH(marca || modelo)"Numero caracteres" FROM coches;
23
Universidad de Jan
Programacin de Bases de Datos Oracle MARCA --------------TOYOTA RENAULT RENAULT PEUGEOT PEUGEOT PEUGEOT VW MODELO Numero caracteres --------------- ----------------CARINA 12 MEGANE 13 5 8 504 10 205 10 207 10 BEATTLE 9
SQL
Para obtener la informacin de una forma ordenada, en los comandos SELECT se puede especificar el orden en que debe aparecer el resultado, este orden se consigue usando la opcin: ORDER BY {columna, posicin} {ASC, DESC} La ordenacin puede hacerse por nombre de columna o por la posicin de esa columna dentro de la clusula SELECT. Ejemplos: Obtener los coches ordenados por marca: SQL> SELECT * FROM coches ORDER by marca; MAT -------B4444AC CA0000AD GR1111AK J1234Z GR4321A M3020KY J9999AB MARCA AN_FAB MODELO --------------- --------- --------------PEUGEOT 1978 504 PEUGEOT 1996 205 PEUGEOT 1998 207 RENAULT 1997 MEGANE RENAULT 1978 5 TOYOTA 1996 CARINA VW 1998 BEATTLE
Obtener los coches ordenados descendentemente por marca y para la misma marca ordenados ascendentemente por ao de fabricacin: SQL> SELECT * FROM coches ORDER by marca DESC, an_fab ASC; MAT -------J9999AB M3020KY GR4321A J1234Z B4444AC CA0000AD GR1111AK MARCA AN_FAB MODELO --------------- --------- --------------VW 1998 BEATTLE TOYOTA 1996 CARINA RENAULT 1978 5 RENAULT 1997 MEGANE PEUGEOT 1978 504 PEUGEOT 1996 205 PEUGEOT 1998 207
Obtener los coches ordenados por el nmero de caracteres que suman la marca y el modelo. SQL> SELECT marca,modelo, LENGTH(marca || modelo)"Numero caracteres" FROM coches ORDER by 3;
Universidad de Jan
24
SQL
MARCA --------------RENAULT VW PEUGEOT PEUGEOT PEUGEOT TOYOTA RENAULT
MODELO Numero caracteres --------------- ----------------5 8 BEATTLE 9 504 10 205 10 207 10 CARINA 12 MEGANE 13
Para consultar informacin relacionada almacenada en varias tablas hay que implementar la operacin JOIN. Se pueden realizar consultas donde intervengan ms de una tabla de la base de datos, especificando las relaciones entre las distintas tablas en la clusula WHERE. Menos para el caso en el que se quiera realizar un producto cartesiano, CUANDO SE PONEN VARIAS TABLAS EN LA CLAUSULA FROM DEL COMANDO SELECT, DEBEN APARECER EN LA CLAUSULA WHERE LAS CORRESPONDIENTES CONDICIONES DE IGUALDAD QUE UNAN LAS DISTINTAS TABLAS (ESTO ES LO QUE REALIZA VERDADERAMENTE EL JOIN), adems, pueden aparecer las condiciones que se requieran para realizar una consulta concreta. Supongamos que las tablas COCHES y TRABAJOS tienen los siguientes datos: COCHES: MAT -------M3020KY GR4321A TRABAJOS: MAT -------M3020KY M3020KY GR4321A M3020KY DNI HORAS FECHA_REP --------- --------- --------1111 1 23-FEB-96 2222 2.5 23-FEB-96 3333 2.1 01-JAN-98 5555 2 23-FEB-96 MARCA AN_FAB MODELO --------------- --------- --------------TOYOTA 1996 CARINA RENAULT 1978 5
Si slo se ponen las dos tablas en la clasula FROM, entonces lo que se est realizando es un producto cartesiano, no un JOIN. Es decir, se generan nuevas tuplas combinando cada tupla de coches con cada tupla de trabajos, pero sin existir relacin alguna en cada combinacin: SQL> SELECT c.mat,c.marca,c.modelo,t.mat,t.dni,t.horas FROM coches c,trabajos t; MAT -------M3020KY GR4321A M3020KY GR4321A M3020KY GR4321A M3020KY GR4321A 25 MARCA ---------TOYOTA RENAULT TOYOTA RENAULT TOYOTA RENAULT TOYOTA RENAULT MODELO ---------CARINA 5 CARINA 5 CARINA 5 CARINA 5 MAT -------M3020KY M3020KY M3020KY M3020KY GR4321A GR4321A M3020KY M3020KY DNI HORAS --------- --------1111 1 1111 1 2222 2.5 2222 2.5 3333 2.1 3333 2.1 5555 2 5555 2 Universidad de Jan
SQL
Donde R.x indica que se refiere al atributo x de la tabla cuyo alias es R.
En la mayora de los casos, cuando se requiere obtener informacin relacionada de varias tablas es necesario establecer la condicin de unin entre ellas (JOIN). De esta manera lo que se est consiguiendo es recuperar la informacin inicial que fue particionada en tablas. Para el ejemplo anterior, como en la tabla TRABAJOS slo se dispone de la matrcula de los coches, el JOIN con la tabla COCHES consigue aadir la informacin adicional de cada coche (tuplas en negrita en el resultado del producto cartesiano). Pero para ello es necesario indicar la condicin de unin que es la que verdaderamente realiza el JOIN. Esta condicin de unin se establece en la clasula WHERE, y en la mayora de los casos son condiciones de igualdad entre llaves primarias y llaves externas. Para el ejemplo anterior, la consulta que realiza correctamente el JOIN de COCHES y TRABAJOS y que por tanto obtiene slo las tuplas en negrita del ejemplo anterior es: SQL> SELECT c.mat,c.marca,c.modelo,t.mat,t.dni,t.horas FROM coches c,trabajos t WHERE c.mat = t.mat; MAT -------M3020KY M3020KY GR4321A M3020KY MARCA ---------TOYOTA TOYOTA RENAULT TOYOTA MODELO ---------CARINA CARINA 5 CARINA MAT -------M3020KY M3020KY GR4321A M3020KY DNI HORAS --------- --------1111 1 2222 2.5 3333 2.1 5555 2
En los siguientes ejemplos, las condiciones de la clusula WHERE que implementan el JOIN aparecen en negrita.
Ejemplos: Obtener todos los trabajos incluyendo los datos del mecnico que realiza el trabajo: SQL> SELECT * FROM mecanicos,trabajos WHERE mecanicos.dni=trabajos.dni;
DNI --------1111 2222 4444 2222 3333 3333 3333 5555 6666 5555 2222 1111 3333 3333 5555 NOMBRE ---------ANTONIO LUIS LOLA LUIS PEPE PEPE PEPE LUISA EMILIO LUISA LUIS ANTONIO PEPE PEPE LUISA PUESTO --------------CHAPA MOTOR CHAPA MOTOR AMORTIGUACION AMORTIGUACION AMORTIGUACION AMORTIGUACION CHAPA AMORTIGUACION MOTOR CHAPA AMORTIGUACION AMORTIGUACION AMORTIGUACION P 1 0 1 0 0 0 0 1 0 1 0 1 0 0 1 MAT -------M3020KY M3020KY J1234Z J1234Z GR4321A B4444AC CA0000AD M3020KY J9999AB J9999AB J9999AB J1234Z GR1111AK J9999AB GR1111AK DNI HORAS FECHA_REP --------- --------- ------1111 1 23-FEB-96 2222 2.5 23-FEB-96 4444 7 19-MAR-97 2222 3 19-MAR-97 3333 2.1 01-JAN-98 3333 3.2 23-APR-96 3333 8 23-APR-96 5555 2 23-FEB-96 6666 1.2 05-MAR-98 5555 .7 05-MAR-98 2222 1 05-MAR-98 1111 2.2 19-MAR-97 3333 5.5 01-JAN-98 3333 7.7 05-MAR-98 5555 2.5 01-JAN-98
Universidad de Jan
26
SQL Obtener parejas de mecnicos del mismo puesto:
SQL> SELECT m1.nombre,m1.puesto,m2.nombre,m2.puesto FROM mecanicos m1,mecanicos m2 WHERE m1.puesto=m2.puesto AND m1.nombre < m2.nombre; NOMBRE ---------LUISA ANTONIO ANTONIO EMILIO PUESTO --------------AMORTIGUACION CHAPA CHAPA CHAPA NOMBRE ---------PEPE EMILIO LOLA LOLA PUESTO --------------AMORTIGUACION CHAPA CHAPA CHAPA
Obtener las marcas y modelos de los coches reparados de CHAPA: SQL> SELECT distinct marca,modelo FROM coches c, trabajos t,mecanicos m WHERE c.mat=t.mat AND t.dni=m.dni AND puesto='CHAPA'; MARCA --------------RENAULT TOYOTA VW MODELO --------------MEGANE CARINA BEATTLE
6.2. Otros usos del comando SELECT

En este apartado se estudiarn algunos aspectos algo ms avanzados del comando SELECT, pudiendo de esta forma generar consultas algo ms complejas. Existen una serie de funciones especiales, que no fueron tratadas en el apartado anterior, y que van a permitir trabajar con informacin relativa a no slo una nica tupla, sino a varias. Estas funciones se conocen con el nombre de funciones agregadas o funciones de grupos de valores. Un dato a tener en cuenta es que estas funciones agregadas ignoran el valor NULL y calculan resultados a pesar de su existencia. A continuacin se exponen algunas de las principales funciones de grupo: COUNT: devuelve el nmero de tuplas. Su formato es el siguiente: COUNT ({* | [DISTINCT | ALL] columna}) COUNT (*): cuenta todas las tuplas de la tabla, aunque tengan valores NULL (incluso en todos los atributos). COUNT (DISTINCT columna): devuelve el nmero de valores distintos para la columna, no incluyendo los nulos. COUNT (ALL columna): devuelve el nmero de valores de la columna, no incluyendo los NULL.
27
Universidad de Jan
Programacin de Bases de Datos Oracle Ejemplos: Contar el nmero de tuplas de la tabla COCHES: SQL> SELECT COUNT(*) FROM coches; COUNT(*) --------7 Contar el nmero de puestos distintos en la tabla MECANICOS: SQL> SELECT COUNT(distinct puesto) "Numero de puestos" FROM mecanicos; Numero de puestos ----------------3 SUM: devuelve la suma de un conjunto de valores. El formato es: SUM ([DISTINCT] columna | expresin)
SQL
Devuelve la suma de los valores de la columna o de los devueltos por expresin. La columna o expresin, evidentemente, debe ser numrica. Ejemplos: Obtener el total de horas trabajadas por los mecnicos de CHAPA: SQL> SELECT SUM(horas) "Horas de CHAPA" FROM mecanicos,trabajos WHERE puesto='CHAPA' AND mecanicos.dni=trabajos.dni; Horas de CHAPA -------------11.4 Obtener la cantidad facturada por los mecnicos de CHAPA suponiendo que el precio de la hora de trabajo es 1000 para el ao 96 y cada ao se incrementa en un 5%: SQL> SELECT SUM(horas*1000* POWER(1.05,TO_CHAR(fecha_rep,'YY')-96)) "Total CHAPA" FROM mecanicos,trabajos WHERE mecanicos.dni=trabajos.dni AND puesto='CHAPA'; Total CHAPA ----------11983 AVG: calcula la media aritmtica de un conjunto de valores. Su formato es: AVG ([DISTINCT] columna | expresin) Devuelve la media aritmtica de los valores de la columna o de los devueltos por la expresin. La Universidad de Jan 28
SQL columna o expresin debe ser numrica. Ejemplos:
Obtener la media de horas trabajadas con los coches RENAULT: SQL> SELECT AVG(horas) FROM coches,trabajos WHERE coches.mat=trabajos.mat AND marca='RENAULT'; AVG(HORAS) ---------3.575 Obtener la media del nmero de caracteres formados por la marca y el modelo de cada coche: SQL> SELECT AVG(LENGTH(marca||modelo)) FROM coches; AVG(LENGTH(MARCA||MODELO)) -------------------------10.285714 MAX: calcula el mximo de un conjunto de valores. Su formato es: MAX ([DISTINCT] columna | expresin) Devuelve el valor mximo de la columna o la expresin.
Ejemplos: Obtener el nmero mximo de horas trabajadas sobre un coche: SQL> SELECT MAX(horas) FROM trabajos; MAX(HORAS) ---------8 Obtener el precio del trabajo ms caro: SQL> SELECT MAX(horas*1000* POWER(1.05,TO_CHAR(fecha_rep,'YY')-96)) "Maximo trabajo" FROM trabajos; Maximo trabajo -------------8489.25 MIN: calcula el mnimo de un conjunto de valores. Su formato es: MIN ([DISTINCT] columna | expresin) Devuelve el valor mnimo de la columna o la expresin. 29 Universidad de Jan
SQL
Ejemplos: Obtener la mitad del nmero mnimo de horas trabajadas en un coche: SQL> SELECT MIN(horas)/2 FROM trabajos; MIN(HORAS)/2 -----------.35
6.2.1.
Consulta de informacin agrupada
SQL permite obtener una tabla agrupada que contenga una fila con informacin resumen para cada grupo. Para obtener esta informacin agrupada se hace uso de la clusula GROUP BY del comando SELECT. La clusula GROUP BY tiene la siguiente sintaxis: GROUP BY expresin [, expresin, ...] donde expresin puede ser un atributo o una expresin conteniendo atributos. Ejemplos: SQL> SELECT mat,SUM(horas) FROM trabajos GROUP by mat ORDER by mat; MAT SUM(HORAS) -------- ---------B4444AC 3.2 CA0000AD 8 GR1111AK 8 GR4321A 2.1 J1234Z 12.2 J9999AB 10.6 M3020KY 5.5 Este comando devuelve para cada coche, su matrcula y la suma de horas trabajadas en dicho coche. Los trabajos se agrupan por matrcula y a cada grupo se le calcula la suma del atributo horas. Finalmente se devuelve una tupla por grupo, conteniendo la informacin de la matrcula y la suma de horas trabajadas.
En la siguiente tabla se muestra el proceso de generacin del resultado anterior. En esta tabla se muestran las matrculas y las horas de cada trabajo ordenadas por matrcula. El proceso consiste por tanto en juntar las horas de los trabajos de igual matrcula (GROUP BY mat) y sumar sus horas, devolviendo la matrcula y la suma calculada.
Universidad de Jan
30
SQL MAT HORAS -------- --------B4444AC 3.2 CA0000AD GR1111AK GR1111AK GR4321A J1234Z J1234Z J1234Z J9999AB J9999AB J9999AB J9999AB M3020KY M3020KY M3020KY 8 5.5 2.5 2.1 2.2 3 7 1 7.7 .7 1.2 1 2.5 2
SUM(horas) = 3.2 SUM(horas) = 8 SUM(horas) = 8 SUM(horas) = 2.1
SUM(horas) = 12.2
SUM(horas) = 10.6
SUM(horas) = 5.5
Consultar el nmero de trabajos realizados a cada coche: SQL> SELECT mat,COUNT(*) FROM trabajos GROUP by mat ORDER by mat; MAT COUNT(*) -------- --------B4444AC 1 CA0000AD 1 GR1111AK 2 GR4321A 1 J1234Z 3 J9999AB 4 M3020KY 3 Consultar el nmero medio de horas trabajadas por puesto clasificados por tipo de contrato ( atributo parcial): SQL> SELECT parcial,puesto,AVG(horas) FROM trabajos,mecanicos WHERE trabajos.dni=mecanicos.dni GROUP by parcial,puesto; PARCIAL ------0 0 0 1 1 PUESTO AVG(HORAS) --------------- ---------AMORTIGUACION 5.3 CHAPA 1.2 MOTOR 2.1666667 AMORTIGUACION 1.7333333 CHAPA 3.4
31
Universidad de Jan
SQL
Lo que hace este comando es obtener una tupla con la informacin resumen de cada grupo de tuplas con el mismo valor para la pareja (parcial, puesto). La forma en que se agrupan las tuplas para obtener la informacin resumen es la que se muestra en la siguiente tabla. PARCIAL ------0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 PUESTO HORAS --------------- --------AMORTIGUACION 2.1 AMORTIGUACION 3.2 AMORTIGUACION 5.5 AMORTIGUACION 8 AMORTIGUACION 7.7 CHAPA MOTOR MOTOR MOTOR AMORTIGUACION AMORTIGUACION AMORTIGUACION CHAPA CHAPA CHAPA 1.2 2.5 3 1 2 2.5 .7 1 7 2.2
AVG(horas)=5.3 AVG(horas)=1.2
AVG(horas)=2.1666667
AVG(horas)=1.7333333
AVG(horas)=3.4
Obtener el nmero de trabajos realizados a grupos de coches con igual nmero de caracteres sumando la marca y el modelo: SQL> SELECT LENGTH(marca||modelo), COUNT(*) FROM coches,trabajos WHERE coches.mat=trabajos.mat GROUP by LENGTH(marca||modelo) ORDER by LENGTH(marca||modelo); LENGTH(MARCA||MODELO) COUNT(*) --------------------- --------8 1 9 4 10 4 12 3 13 3 Obtener el nmero mximo de horas en total trabajadas sobre un coche: SQL> SELECT MAX(SUM(horas)) FROM trabajos GROUP by mat; MAX(SUM(HORAS)) --------------12.2
De forma anloga a la clusula WHERE, se pueden establecer restricciones sobre qu grupos aparecern en el resultado de la consulta. Esto se realiza mediante la clusula HAVING del comando SELECT.
Universidad de Jan
32
SQL
Ejemplo: Obtener los coches en los que se ha trabajado ms de 10 horas: SQL> SELECT mat,SUM(horas) FROM trabajos GROUP by mat HAVING SUM(horas)>10; MAT SUM(HORAS) -------- ---------J1234Z 12.2 J9999AB 10.6
Si en una misma consulta aparecen las clusulas WHERE y HAVING, primero se aplica la condicin de la clusula WHERE. Las tuplas que la satisfacen son colocadas en grupos por la clusula GROUP BY, despus se aplica la clusula HAVING a cada grupo, y los grupos que satisfacen la condicin de la clusula HAVING son utilizados por la clusula SELECT para generar tuplas del resultado de la consulta. Ejemplo: Obtener los mecnicos de CHAPA o AMORTIGUACION que han reparado ms de dos coches: SQL> SELECT mecanicos.dni, COUNT(distinct mat) "Numero de coches" FROM mecanicos,trabajos WHERE mecanicos.dni=trabajos.dni AND puesto in('CHAPA','AMORTIGUACION') GROUP by mecanicos.dni HAVING COUNT(distinct mat)>2; DNI Numero de coches --------- ---------------3333 5 5555 3
Un detalle importante a tener en cuenta es que las expresiones que se pongan en la clusula SELECT sern, o valores constantes, o funciones agregadas, o bien alguna expresin incluida en la clusula GROUP BY. Esto es debido a que las funciones como COUNT, SUM, AVG, etc., devuelven valores sobre grupos de tuplas, no sobre tuplas individuales. En la clusula HAVING slo se podrn utilizar funciones agregadas. Por ejemplo, si se quiere obtener el dni y el nombre de los mecnicos junto con las horas que han trabajado, la consulta: SQL> SELECT m.dni,nombre,SUM(horas) FROM trabajos t,mecanicos m WHERE t.dni=m.dni GROUP by m.dni; producira el siguiente error: SELECT M.DNI,NOMBRE,SUM(HORAS) * ERROR AT LINE 1: ORA-00979: NOT A GROUP BY EXPRESSION Universidad de Jan
33
SQL
indicando que la columna nombre no es ninguna de las expresiones incluidas en la clusula GROUP BY del comando.
6.2.2.
Subconsultas
Una subconsulta es una consulta dentro de otra, es decir, un SELECT anidado en la clusula WHERE de otro SELECT. Esta anidacin permite realizar consultas complejas, que no sera posible, o poco eficiente realizar haciendo consultas simples a base de JOINS. El formato de la subconsulta es el siguiente: SELECT columnas FROM tabla WHERE {columna | expresin} operador ( SELECT columna | expresin FROM ...) ; El operador a utilizar depender del nmero de valores que se van a obtener en la subconsulta. Las subconsultas pueden aparecer en cualquier lugar en el que se pueda colocar la clusula WHERE, es decir en los comandos SELECT, INSERT y UPDATE. Ejemplos: Obtener los mecnicos que pertenecen al mismo puesto que EMILIO; SQL> SELECT nombre FROM mecanicos WHERE puesto = (
SELECT puesto FROM mecanicos WHERE nombre = 'EMILIO') AND nombre!='EMILIO';
NOMBRE --------------ANTONIO LOLA Esta consulta se puede hacer tambin con un nico SELECT que implemente un producto cartesiano entre tuplas de la tabla de mecnicos: SQL> SELECT m2.nombre FROM mecanicos m1,mecanicos m2 WHERE m1.nombre='EMILIO' AND m2.puesto=m1.puesto AND m2.nombre!='EMILIO' Obtener los coches reparados por algn mecnico de CHAPA: SQL> SELECT mat FROM trabajos WHERE dni IN ( SELECT dni FROM mecanicos WHERE puesto = 'CHAPA'); Universidad de Jan
34
SQL
MAT -------M3020KY J1234Z J9999AB J1234Z
Ntese como cuando el resultado de la subconsulta es un conjunto de valores NO se puede utilizar el operador de igualdad, sino el de inclusin.
6.2.3.
Variables de tupla y consultas sincronizadas
SQL toma prestada la notacin de variables de tupla del clculo relacional orientado a tuplas. Una variable de tupla en SQL debe estar asociada a una tabla determinada. Las variables de tupla se definen en la clusula FROM del comando SELECT, situndolas junto a la tabla asociada. Las variables de tupla son variables que van tomando como valores tuplas de una determinada tabla. Hasta el momento se han utilizado variables de tupla para ahorrar trabajo, dar mayor claridad al escribir las consultas y evitar ambigedades. Una variable de tupla se coloca despus del nombre de la relacin y separada por uno o ms espacios en blanco. Cuando una consulta tiene subconsultas anidadas, se aplica la siguiente regla de mbito para las variables de tuplas: en un subconsulta, est permitido usar slo variables de tupla definidas en la misma subconsulta o en cualquier consulta que contenga a la subconsulta. Si existen dos variables de tupla con el mismo nombre se tiene en cuenta la ms interior a la subconsulta. Las variables de tupla son muy tiles para comparar dos tuplas de la misma relacin. Por ejemplo, si se quieren obtener las parejas de mecnicos con el mismo tipo de contrato: SQL> SELECT m1.nombre,m2.nombre, m1.parcial"Contrato parcial?" FROM mecanicos m1,mecanicos m2 WHERE m1.parcial=m2.parcial AND m1.nombre<m2.nombre NOMBRE --------------EMILIO LUIS EMILIO ANTONIO ANTONIO LOLA NOMBRE Contrato parcial? --------------- ----------------LUIS PEPE PEPE LOLA LUISA LUISA
0 0 0 1 1 1
Las consultas sincronizadas utilizan tanto subconsultas como variables de tupla. La consulta: dar los mecnicos que reparan tres o ms coches, se podra resolver de la siguiente forma: SQL> SELECT * FROM mecanicos m WHERE 3 <= ( SELECT COUNT(distinct mat) FROM trabajos t WHERE t.dni = m.dni);
35
Universidad de Jan
Programacin de Bases de Datos Oracle DNI --------2222 3333 5555 NOMBRE --------------LUIS PEPE LUISA PUESTO --------------MOTOR AMORTIGUACION AMORTIGUACION P 0 0 1
SQL
El hecho de llamarse sincronizadas se refiere a que se irn sustituyendo valores en m.dni en la subconsulta de forma sincronizada a como se van tratando en la consulta principal. Es decir, la consulta principal va analizando tupla a tupla y la subconsulta coge el valor de la tupla que se est analizando en ese momento. De esta forma, para cada mecnico, la subconsulta obtiene el nmero de coches que ha arreglado.
6.2.4.
Operaciones entre conjuntos
A los resultados de las consultas (que se implementan como tablas temporales) se les pueden aplicar tambin los operadores tradicionales de conjuntos (unin, interseccin y diferencia), obteniendo nuevas tablas. Los operadores de conjuntos son: UNION: Realiza la operacin de unin eliminando las tuplas duplicadas. Las dos tablas que se unen deben tener el mismo nmero de atributos (aunque no es necesario que tengan los mismos nombres) y stos deben tener el mismo tipo de datos.
Ejemplo: SQL> (SELECT * FROM mecanicos WHERE nombre = 'PEPE') UNION (SELECT * FROM mecanicos WHERE puesto = 'AMORTIGUACION'); NOMBRE --------------PEPE LUISA PUESTO --------------AMORTIGUACION AMORTIGUACION P 0 1
DNI --------3333 5555
Como se puede apreciar, PEPE slo aparece una vez en el resultado de la consulta, aunque pertenece a los dos conjuntos.
Universidad de Jan
36
SQL INTERSECT:
Realiza la operacin de interseccin de conjuntos. Las condiciones son las descritas anteriormente. Ejemplo: SQL> (SELECT * FROM mecanicos WHERE nombre = 'PEPE') INTERSECT (SELECT * FROM mecanicos WHERE puesto = 'AMORTIGUACION') DNI NOMBRE PUESTO P --------- --------------- --------------- 3333 PEPE AMORTIGUACION 0 MINUS: Realiza la operacin resta de conjuntos. Es decir, A - B son las tuplas que estn en A y no estn en B. La operacin de resta no es conmutativa, como muestra el siguiente ejemplo. Ejemplo: SQL> (SELECT * FROM mecanicos WHERE nombre = 'PEPE') MINUS (SELECT * FROM mecanicos WHERE puesto = 'AMORTIGUACION') no rows selected
SQL> (SELECT * FROM mecanicos WHERE puesto = 'AMORTIGUACION') MINUS (SELECT * FROM mecanicos WHERE nombre = 'PEPE'); DNI NOMBRE PUESTO P --------- --------------- --------------- 5555 LUISA AMORTIGUACION 1
Generalmente estos comandos no se utilizan ya que se pueden escribir de forma ms simplificada introduciendo una nueva condicin en la clusula WHERE, haciendo, adems, que la consulta sea ms eficiente. Aunque, en algunos casos, resuelven consultas complicadas de forma bastante elegante, como es el caso del siguiente ejemplo, en donde se utilizan dos subconsultas sincronizadas adems de operaciones entre conjuntos.
37
Universidad de Jan
Programacin de Bases de Datos Oracle Ejemplo: Encontrar los mecnicos que han reparado todos los coches de alguna marca:
SQL
SQL> SELECT distinct nombre,marca FROM mecanicos m,coches c /* no se hace JOIN ya que se quiere comprobar cada mecnico con todas las marcas */ WHERE not exists ( (SELECT distinct mat FROM coches WHERE marca = c.marca) /* obtiene los coches de cada marca */ MINUS (SELECT distinct mat FROM trabajos t WHERE t.dni = m.dni) /* obtiene los coches reparados por cada mecnico */ ); NOMBRE --------------ANTONIO EMILIO LUIS LUIS LUISA LUISA PEPE PEPE MARCA --------------TOYOTA VW TOYOTA VW TOYOTA VW PEUGEOT VW
Esta consulta funciona de la siguiente manera: el SELECT inicial va obteniendo parejas dni-marca, y para cada pareja la primera subconsulta obtiene todos los coches reparados de esa marca y la segunda subconsulta obtiene todos los coches reparados por ese mecnico, de tal forma que cuando ambos conjuntos sean iguales (el mecnico ha reparado todos los coches de esa marca) su diferencia devuelve el conjunto vaco, verificndose la condicin del WHERE del SELECT inicial.
Universidad de Jan
38
SQL
7. Vistas
En este ltimo apartado dedicado a SQL se va a estudiar el concepto de VISTA, viendo su utilidad, cmo se crean y cmo se destruyen.
7.1. Concepto de vista

Se puede definir una vista como una tabla lgica que permite acceder a los datos de otras tablas. Las tablas sobre las cuales la vista se crea se denominan tablas base. El que una vista sea una tabla lgica significa que las vistas no contienen datos en s mismas. Una vista puede ser entendida como una tabla virtual que no tiene datos propios, sino que se nutre de datos de otra(s) tabla(s). Las vistas son muy tiles ya que permiten establecer accesos selectivos a diferentes partes de la base de datos: Una vista puede proporcionar acceso a determinadas columnas de la(s) tabla(s) que definen la vista. Por ejemplo, se puede definir una vista de la tabla MECANICOS que slo muestre los atributos DNI y NOMBRE, pero no el atributo PARCIAL. Una vista puede proporcionar seguridad de la informacin contenida en la(s) tabla(s) que la definen. Se puede definir una vista que muestre slo determinadas tuplas de las tablas asociadas, por ejemplo, una vista que muestre slo el sueldo del usuario que accede a ella, pero no el resto de sueldos de los empleados de la empresa. En una base de datos, las vistas son utilizadas con los siguientes propsitos: Para proporcionar un nivel adicional de seguridad sobre las tablas, restringiendo el acceso a un predeterminado conjunto de tuplas o atributos de una tabla base. Para ocultar la complejidad de los datos. Por ejemplo, una vista puede ser utilizada para actuar como una nica tabla, mientras que varias tablas se usan para construir el resultado. Para presentar los datos desde otra perspectiva. Por ejemplo, las vistas proporcionan la posibilidad de renombrar los atributos sin necesidad de cambiar la definicin de la tabla base. Para obligar al RDBMS a realizar algunas operaciones, tales como los joins, sobre la base de datos que contiene la vista, en lugar de en otras posibles bases de datos referenciadas en la misma sentencia SQL. Una vista, una vez definida, puede ser utilizada en cualquier lugar (incluso en la definicin de otra vista) en donde se pueda utilizar una tabla en cualquiera de los siguientes comandos SQL: DELETE INSERT UPDATE SELECT
39
Universidad de Jan
SQL
7.2. Definicin de vistas en Oracle

La sintaxis del comando SQL para la creacin de vistas es la siguiente: CREATE [OR REPLACE] [FORCE | NOFORCE] VIEW nombre_vista [(alias [,alias]...)] AS subconsulta [WITH READ ONLY ] [WITH CHECK OPTION ] ; donde: OR REPLACE: crea de nuevo la vista si sta ya existe. FORCE: crea la vista sin tener en cuenta si las tablas base de la vista existen y sin tener en cuenta si el propietario del esquema que contiene la vista tiene los privilegios suficientes sobre dichas tablas. Ntese que estas dos condiciones tienen que ser ciertas antes de usar los comandos SELECT, INSERT, UPDATE o DELETE sobre la vista. NOFORCE: crea la vista slo si las tablas base existen y el propietario de la vista tiene privilegios sobre ellas. La opcin por defecto es NOFORCE. nombre_vista: es el nombre de la vista. alias: especifica nombres para las expresiones seleccionadas por la subconsulta de la vista (sern los nombres de los atributos de la vista). El nmero de alias debe coincidir con el nmero de expresiones seleccionadas por la subconsulta. Estos alias deben ser nicos dentro de la vista. Si se omiten los alias, Oracle los deriva de las columnas o de los alias de las columnas seleccionados en la subconsulta. Por esta razn se deben utilizar alias si la subconsulta de la vista contiene expresiones en lugar de slo nombres de columnas. AS subconsulta: identifica los atributos y tuplas de la(s) tabla(s) en las que se basa la vista, es decir, establece el contenido de la vista. Esta subconsulta puede ser cualquier sentencia SELECT que no contenga la clusula ORDER BY. WITH READ ONLY: especifica que no se pueden realizar borrados, inserciones o actualizaciones a travs de la vista. WITH CHECK OPTION: especifica que las inserciones y las actualizaciones realizadas sobre la vista deben dar como resultado tuplas que la vista pueda seleccionar. La opcin CHECK OPTION no garantiza esto si, a su vez, existe alguna subconsulta en la subconsulta de la vista o si la vista se basa a su vez en otra vista. La restriccin ms importante que existe sobre las vistas es que si la subconsulta contiene alguno de los siguientes elementos, no se podrn realizar inserciones, actualizaciones o borrados sobre la vista: operaciones JOIN operadores de conjuntos funciones agregadas la clusula GROUP BY el operador DISTINCT Ntese que si la vista contiene expresiones, slo se podr actualizar la vista con una sentencia UPDATE que no se refiera a ninguna de las expresiones.
Universidad de Jan
40
SQL
Para borrar una vista se utiliza el siguiente comando: DROP VIEW nombre_vista;
donde nombre_vista es el nombre de la vista que se quiere borrar.
Para ver las vistas que ha creado un usuario y sus subconsultas asociadas se puede consultar el Diccionario de Datos a travs de la vista USER_VIEWS.
7.3. Ejemplos de utilizacin de vistas

Crear una vista llamada CHAPA que muestre los mecnicos de CHAPA y las horas que han trabajado: SQL> CREATE OR REPLACE VIEW chapa AS SELECT dni, SUM(horas) "Total horas" FROM mecanicos m,trabajos t WHERE m.dni=t.dni AND puesto='CHAPA' GROUP BY m.dni,nombre;
Ntese que en la declaracin de la vista no se necesita definir un nombre para el atributo basado en la expresin SUM(horas) debido a que la subconsulta utiliza un alias de atributo ("Total horas") para la expresin. Una vez creada la vista se puede utilizar como si fuera una tabla: SQL> SELECT * FROM chapa; DNI Total horas --------- ----------1111 3.2 4444 7 6666 1.2 Crear una vista actualizable llamada Tiempo_parcial conteniendo los atributos indispensables de los mecnicos que estn a tiempo parcial. SQL> CREATE VIEW Tiempo_parcial (dni,contrato) AS SELECT dni,parcial FROM mecanicos WHERE parcial='1' WITH CHECK OPTION;
Debido al CHECK OPTION, no se pueden insertar nuevas tuplas en Tiempo_parcial si el nuevo mecnico no tiene un contrato a tiempo parcial:
41
Universidad de Jan
Programacin de Bases de Datos Oracle SQL> INSERT INTO Tiempo_parcial VALUES ('7777','0'); INSERT INTO Tiempo_parcial VALUES ('7777','0') * ERROR at line 1: ORA-01402: view WITH CHECK OPTION WHERE-clause violation
SQL
Si se inserta un nuevo mecnico a travs de la vista, como no se han incluido los atributos NOMBRE y PUESTO de la tabla mecnicos, tomarn valor NULL, siendo esto posible ya que cuando se creo la tabla de mecnicos no se especific la restriccin NOT NULL para estos campos: SQL> INSERT INTO Tiempo_parcial VALUES ('7777','1'); 1 row created. SQL> SELECT * FROM mecanicos; DNI --------1111 2222 3333 4444 5555 6666 7777 NOMBRE --------------ANTONIO LUIS PEPE LOLA LUISA EMILIO PUESTO --------------CHAPA MOTOR AMORTIGUACION CHAPA AMORTIGUACION CHAPA P 1 0 0 1 1 0 1
Si en vez de haber utilizado la clusula WITH CHECK OPTION se hubiera utilizado WITH READ ONLY, entonces no estaran permitidas las operaciones de insercin, borrado o actualizacin sobre la vista. Obtener el total de horas trabajadas por los mecnicos de chapa que tienen un contrato a tiempo parcial: SQL> SELECT c.dni,c."Total horas" FROM chapa c,tiempo_parcial tp WHERE c.dni=tp.dni;
DNI Total horas --------- ----------1111 3.2 4444 7
Universidad de Jan
42
SQL
8. Ejercicios Resueltos
8.1. Creacin de tablas

COCHES: mat marca an_fab (matricula del coche, 8 caracteres y llave primaria) (15 caracteres) (ao de fabricacion, nmero de 2 dgitos)
MECANICOS: dni (9 caracteres, llave primaria) nombre (15 caracteres) puesto (15 caracteres) parcial (1 caracter) TRABAJOS: mat dni horas fecha_rep
(la matrcula del coche, llave externa respecto de COCHES), (el dni del mecnico), (nmero de 3 cifras con 1 decimal, debe ser mayor de 0.5) (tipo fecha)
Solucin: CREATE TABLE coches ( mat VARCHAR(8) CONSTRAINT pk_coches PRIMARY KEY, marca VARCHAR(15), an_fab NUMBER(2) ); CREATE TABLE mecanicos ( dni VARCHAR(9) CONSTRAINT pk_mecanicos PRIMARY KEY, nombre VARCHAR(15), puesto VARCHAR(15), parcial VARCHAR(1) ); CREATE TABLE trabajos ( mat VARCHAR(8), dni VARCHAR(9), horas NUMBER(3,1) CONSTRAINT ck_trabajo CHECK (horas>=0.5), fecha_rep DATE, CONSTRAINT fk1_trabajos FOREIGN KEY (mat) REFERENCES coches );
43
Universidad de Jan
SQL
8.2. Modificacin de tablas

Aadir a la tabla COCHES el atributo modelo (15 caracteres) Establecer los atributos mat y dni como la llave primaria de TRABAJOS. Establecer el atributo dni de TRABAJOS como llave externa respecto a MECANICOS. Ampliar a 4 la longitud del atributo an_fab de la tabla COCHES. Solucin: ALTER TABLE coches ADD modelo VARCHAR(15); ALTER TABLE trabajos ADD CONSTRAINT pk_trabajos PRIMARY KEY (mat,dni); ALTER TABLE trabajos ADD CONSTRAINT fk2_trabajos FOREIGN KEY (dni) REFERENCES mecanicos; ALTER TABLE coches MODIFY an_fab NUMBER(4);
8.3. Insercin de tuplas

Realizar la insercin de valores de forma que las tablas queden de la siguiente forma:
MAT M3020KY J1234Z GR4321A B4444AC CA0000AD GR1111AK J9999AB
COCHES MARCA MODELO TOYOTA CARINA RENAULT MEGANE RENAULT 5 PEUGEOT 504 PEUGEOT 205 PEUGEOT 207 VW BEATTLE
AN_FAB 1996 1997 1978 1978 1996 1998 1998
DNI 1111 2222 3333 4444 5555 6666 7777
NOMBRE ANTONIO LUIS PEPE LOLA LUISA EMILIO ANGEL
MECANICOS PUESTO MOTOR MOTOR AMORTIGUACION CHAPA AMORTIGUACION CHAPA CHAPA
PARCIAL 1 0 0 1 1 0 0
Universidad de Jan
44
SQL TRABAJOS HORAS 1 2.5 7 3 2.1 3.2 8 2 1 0.6 0.9 2.2 5.5 6.7 2.5 1
MAT M3020KY M3020KY J1234Z J1234Z GR4321A B4444AC CA0000AD M3020KY J9999AB J9999AB J9999AB J1234Z GR1111AK J9999AB GR1111AK GR1111AK
DNI 1111 2222 4444 2222 3333 3333 3333 5555 6666 5555 2222 1111 3333 3333 5555 7777
FECHA_REP 23-FEB-96 23-FEB-96 19-MAR-97 19-MAR-97 1-JAN-98 23-APR-96 23-APR-96 23-FEB-96 5-MAR-98 5-MAR-98 5-MAR-98 19-MAR-97 1-JAN-98 5-MAR-98 1-JAN-98 1-JAN-98
Solucin: INSERT INTO coches (MAT,MARCA,MODELO,AN_FAB) VALUES ('M3020KY','TOYOTA','CARINA',1996); INSERT INTO coches (MAT,MARCA,MODELO,AN_FAB) VALUES ('J1234Z','RENAULT','MEGANE',1997); INSERT INTO coches (MAT,MARCA,MODELO,AN_FAB) VALUES ('GR4321A','RENAULT','5',1978); ... INSERT INTO MECANICOS VALUES ('1111','ANTONIO','MOTOR','1'); INSERT INTO MECANICOS VALUES ('2222','LUIS','MOTOR','0'); INSERT INTO MECANICOS VALUES ('3333','PEPE','AMORTIGUACION','0'); ... INSERT INTO TRABAJOS VALUES ('M3020KY','1111',1,'23-FEB-96'); INSERT INTO TRABAJOS VALUES ('M3020KY','2222',2.5,'23-FEB-96'); INSERT INTO TRABAJOS VALUES ('J1234Z','4444',7,'19-MAR-97'); ...
45
Universidad de Jan
SQL
8.4. Actualizacin y borrado de tuplas

Modificar a 'CHAPA' el puesto de 'ANTONIO'. Borrar a 'ANGEL' de la base de datos. Aumentar las horas de los trabajos hechos el '5-MAR-98' en un 15%.
Solucin: UPDATE mecanicos SET puesto='CHAPA' WHERE nombre='ANTONIO'; Como la llave externa DNI en TRABAJOS no se ha definido con la opcin ON DELETE CASCADE, entonces primero se deben borrar todos los trabajos de ngel para posteriormente eliminarle a l de la base de datos. DELETE FROM trabajos WHERE dni = ( SELECT dni FROM mecanicos WHERE nombre='ANGEL'); DELETE FROM mecanicos WHERE nombre='ANGEL'; UPDATE trabajos SET horas = horas * 1.15 WHERE fecha_rep='5-MAR-98';
8.5. Consultas
Parejas de coches de distintas marcas fabricados el mismo ao y reparados ambos de AMORTIGUACIN: SQL> SELECT c1.marca,c1.modelo,c2.marca,c2.modelo FROM coches c1,coches c2 WHERE c1.an_fab=c2.an_fab AND c1.marca>c2.marca AND NOT EXISTS ((SELECT mat FROM coches WHERE mat IN (c1.mat,c2.mat)) MINUS (SELECT mat FROM trabajos t,mecanicos m WHERE t.dni=m.dni AND m.puesto='AMORTIGUACION')); MARCA --------------RENAULT TOYOTA VW MODELO --------------5 CARINA BEATTLE MARCA --------------PEUGEOT PEUGEOT PEUGEOT MODELO --------------504 205 207
Universidad de Jan
46
SQL
Esta misma consulta pero sin utilizar subconsultas sincronizadas: SQL> SELECT distinct c1.marca,c1.modelo,c2.marca,c2.modelo FROM coches c1,coches c2,trabajos t1,trabajos t2, mecanicos m1,mecanicos m2 WHERE c1.mat=t1.mat AND t1.dni=m1.dni AND c2.mat=t2.mat AND t2.dni=m2.dni AND c1.an_fab=c2.an_fab AND c1.marca>c2.marca AND m1.puesto='AMORTIGUACION' AND m2.puesto='AMORTIGUACION';
Obtener los coches que NO son reparados por 'PEPE': SQL> SELECT mat,marca,modelo FROM coches WHERE mat not in (SELECT mat FROM trabajos t,mecanicos m WHERE t.dni=m.dni AND m.nombre='PEPE'); MAT -------M3020KY J1234Z MARCA --------------TOYOTA RENAULT MODELO --------------CARINA MEGANE
Obtener los mecnicos que no han reparado ningn coche RENAULT: SQL> SELECT nombre FROM mecanicos m WHERE not exists ( (SELECT distinct mat FROM coches WHERE marca = 'RENAULT') INTERSECT (SELECT distinct mat FROM trabajos t WHERE t.dni = m.dni)); NOMBRE --------------EMILIO LUISA Otras posibles formas de resolver esta consulta son: SQL> (SELECT distinct nombre FROM mecanicos m,trabajos t,coches c WHERE m.dni=t.dni AND t.mat=c.mat AND c.marca!='RENAULT') MINUS (SELECT distinct nombre FROM mecanicos m,trabajos t,coches c WHERE m.dni=t.dni AND t.mat=c.mat AND c.marca='RENAULT'); SQL> SELECT nombre FROM mecanicos WHERE dni not in (SELECT dni FROM trabajos t,coches c WHERE t.mat=c.mat AND c.marca='RENAULT');
47
Universidad de Jan
SQL
8.6. Vistas
Crear una vista que contenga la marca y el modelo de cada coche, el puesto en que fue reparado y el total de horas invertidas en ese puesto: SQL> CREATE OR REPLACE VIEW total_coche_puesto as SELECT marca,modelo,puesto,SUM(horas) "total horas" FROM mecanicos m, coches c,trabajos t WHERE m.dni=t.dni AND c.mat=t.mat GROUP by marca,modelo,puesto; SQL> SELECT * FROM total_coche_puesto; MARCA --------------PEUGEOT PEUGEOT PEUGEOT RENAULT RENAULT RENAULT TOYOTA TOYOTA TOYOTA VW VW VW MODELO --------------205 207 504 5 MEGANE MEGANE CARINA CARINA CARINA BEATTLE BEATTLE BEATTLE PUESTO total horas --------------- ----------AMORTIGUACION 8 AMORTIGUACION 8 AMORTIGUACION 3.2 AMORTIGUACION 2.1 CHAPA 9.2 MOTOR 3 AMORTIGUACION 2 CHAPA 1 MOTOR 2.5 AMORTIGUACION 8.4 CHAPA 1.2 MOTOR 1
Universidad de Jan
48
3 PL/SQL Programacin del servidor
PL/SQL
1. Introduccin
El desarrollo de una aplicacin de BD requiere normalmente la utilizacin de estructuras alternativas, repetitivas, de declaracin de datos. similares a las que se pueden encontrar en lenguajes procedurales tales como C, C++, o Pascal. Esta construccin es necesaria para implementar tipos complejos de datos y algoritmos. El principal problema con el que se encuentra el lenguaje declarativo SQL es la ausencia de dicho tipo de estructuras, lo que impide que muchas tareas puedan llevarse a cabo. Para superar este inconveniente fue creado PL/SQL (Procedural Language/SQL). PL/SQL es una extensin procedural de Oracle-SQL que ofrece un lenguaje de construccin similar a los lenguajes de programacin imperativos. PL/SQL permite al usuario y al diseador desarrollar aplicaciones de BD complejas que requieren el uso de estructuras de control y elementos procedurales tales como procedimientos, funciones y mdulos. La construcciin bsica en PL/SQL es el bloque (block). Los bloques permiten al diseador combinar sentencias SQL en unidades. En un bloque, pueden ser declaradas constantes y variables, y las variables pueden ser utilizadas para almacenar resultados de consultas. Las sentencias en un bloque PL/SQL pueden incluir: Estructuras de control repetitivas (loops) Sentencias condicionales (if-then-else) Manejo de excepciones (exception hadling) Llamadas a otros bloques PL/SQL Los bloques PL/SQL que especifican procedimientos y funciones pueden ser agrupados en paquetes (packages) similares a mdulos. Oracle presenta varios paquetes predefinidos: rutinas input/output, ficheros handling, de planificacin de trabajos, etc. Otra caracterstica importante de PL/SQL es que presenta un mecanismo para procesar los resultados de las consultas orientado a tuplas (tuple-oriented way), es decir, de tupla en tupla, mediante la definicin de los cursores (cursors). Un cursor es bsicamente un puntero a un resultado de una consulta y es utilizado para leer valores de atributos de tuplas seleccionadas. Un cursor se utiliza habitualmente en combinacin con una estructura repetitiva de modo que cada tupla que sea leda por el cursor puede ser procesada individualmente. En resumen, los objetivos del PL/SQL son: Hacer ms expresivo el SQL Procesar los resultados de consultas orientado a tuplas (tuple-oriented way) Optimizar la combinacin de sentencias SQL Desarrollar programas de aplicacin de base de datos modulares Reutilizar el cdigo del programa Reducir el coste por mantenimiento y cambio de aplicaciones
51
Universidad de Jan
Programacin de Bases deDatos Oracle
PL/SQL
1.1. Tablas para los ejemplos

Los ejemplos que ilustran los conceptos presentados en este captulo utilizan las siguientes tablas: EMPLEADO (NUM_EMP, NOMBRE_EMP, TAREA, JEFE, FECHA_ALTA, SALARIO, NUM_DPTO) NUM_EMP NOMBRE_EMP TAREA JEFE FECHA_ALTA SALARIO NUM_DPTO Nmero identificador del empleado Nombre del empleado Tarea o puesto que desempea el empleado en la empresa Nmero identificador del jefe del empleado Fecha de entrada del empleado en la empresa Salario mensual Nmero identificador del departamento en el que empleado trabaja
DPTO (NUM_DPTO, NOMBRE_DPTO, LOCALIDAD) NUM_DPTO NOMBRE_DPTO LOCALIDAD Nmero identificador del departamento Nombre del departamento Nombre de la localidad en la que se ubica el departamento
NIVEL (ID_NIVEL, SAL_MIN, SAL_MAX) ID_NIVEL SAL_MIN SAL_MAX Nmero identificativo del nivel del empleado Tope mnimo salarial del nivel Tope maximo salarial del nivel
PROYECTO (NUM_PRO, NOMBRE_PRO, JEFE_PRO, NUM_PER, PRESUPUESTO,FECHA_INI, FECHA_FIN) NUM_PRO NOMBRE_PRO JEFE_PRO NUM_PER PRESUPUESTO FECHA_INI FECHA_FIN Nmero identificador del proyecto Nombre del proyecto Nmero identificador del jefe del proyecto Nmero de personas que integrados en el proyecto Presupuesto del proyecto Fecha de inicio del proyecto Fecha de conclusin de proyecto
2. Estructura de los bloques PL/SQL

PL/SQL es un lenguaje estructurado en bloques. Cada bloque es una unidad de programa que puede ser o no etiquetada mediante una cabecera de bloque, siendo posible la existencia de bloques anidados. Los bloques que crean un procedimiento, una funcin, o un paquete deben ser etiquetados. Un bloque PL/SQL consta de dos secciones: una seccin declarativa opcional y una seccin que contiene sentencias PL/SQL. Dentro de esta ltima podemos incluir una parte opcional para el manejo de excepciones (exception-handling). La sintaxis de un bloque PL/SQL es la siguiente:
Universidad de Jan
52
PL/SQL [<Cabecera de Bloque>] [DECLARE <Constantes> <Variables> <Cursores> <Excepciones definidas por el usuario>] BEGIN <Sentencias PL/SQL> [EXCEPTION <Manejo de excepciones>] END;
La cabecera del bloque especifica si el bloque PL/SQL es un procedimiento, una funcin o un paquete. Si no se especifica cabecera, se dice que el bloque es annimo (anonymous block). En los bloques anidados el mbito de las variables declaradas es anlogo al mbito de las variables en lenguajes de programacin tales como C o Pascal.
3. Declaraciones
Las constantes, variables, cursores y excepciones que son usadas en un bloque PL/SQL deben ser declaradas en su seccin declarativa. Las variables y constantes deben ser declaradas como sigue: <nombre de variable> [CONSTANT] <tipo de dato> [NOT NULL] [:= <expresin>]; Los tipos de datos validos son los mimo que en SQL. Los datos booleanos pueden ser solo verdadero, falso, o nulo. La clusula NOT NULL requiere que la variable declarada tenga un valor diferente de nulo. <expresin> es utilizada para inicializar una variable. Si no hay ninguna expresin especificada el valor null es asignado a la variable. La clusula [CONSTANT] hace que una vez que el valor ha sido asignado a la variable, ste no puede ser modificado (la variable se convierte en una constante). Ejemplo: DECLARE Fecha_contrato DATE; /*inicializacin implcita a null*/ Nombre_tarea VARCHAR2(80):=VENDEDOR; Emp_encontrado BOOLEAN; /*inicializacin implcita a null*/ Incremento_sal CONST NUMBER(3,2):= 1.5; /*constante/ . . . BEGIN . . . END; En lugar de declarar directamente una variable con un tipo de dato SQL (varchar, number, ), es posible declarar el tipo de una variable asignndole a sta, el tipo de dato asignado previamente a una columna de la tabla. Esta declaracin se denomina declaracin anclada (anchored). Por ejemplo EMPLEADO.NUM_EMP%TYPE se refiere al tipo de dato de la columna NUM_EMP en la tabla EMPLEADO. De la misma forma que una variable puede ser definida mediante una declaracin anclada, tambin podemos declarar conjuntos de atributos que pueda almacenar una tupla completa de una tabla dada (o un resultado de una consulta). Por ejemplo, el tipo de dato DPTO%ROWTYPE especifica un registro apropiado para almacenar todos los valores de los atributos de una fila completa de la tabla DPTO. Normalmente, los registros as definidos se utilizan en combinacin con un cursor. Se puede acceder a un campo en un registro utilizando <nombre registro>.<nombre columna>. De este modo realizamos la siguiente declaracin: DECLARE reg_dpto DPTO%ROWTYPE;
53
Universidad de Jan
Programacin de Bases deDatos Oracle el numero del departamento se referencia como REG_DPTO.NUM_DPTO.
PL/SQL
Una declaracin de un cursor especifica un conjunto de tuplas resultado de una consulta, que pueden ser procesadas secuencialmente tupla a tupla (tuple-oriented way) utilizando la sentencia fetch. Una declaracin de un cursor tiene la forma CURSOR <nombre de cursor> [(<lista de parmetros>)] IS <sentencia SELECT>; El nombre del cursor es un identificador no declarado, no pudiendo ser el nombre de ninguna variable PL/SQL. Un parmetro tiene la forma <nombre de parmetro> <tipo de parmetro>. Los tipos de parmetros posibles son CHAR, VARCHAR, NUMBER, DATE y BOOLEAN as como sus subtipos correspondientes tal como INTEGER. Los parmetros son utilizados para asignar valores a las variables que utilizan las sentencias SELECT. Ejemplo: queremos recuperar (tuple_oriented way) los valores de los atributos nombre del trabajo y el nombre de los empleados contratados despus de una fecha dada y cuyo sueldo sea mayor a un valor. CURSOR empleado_cur (fecha_inical DATE, dno NUMBER) IS SELECT tarea, nombre_emp FROM empleado e WHERE fecha_alta> fecha_inicial AND EXITSTS (SELECT * FROM empleado WHERE e.jefe = num_emp AND num_dpto = dno); Si alguna de las tuplas seleccionadas fuera modificada en el bloque PL/SQL, la clusula FOR UPDATE[(<columna(s)>)] debera ser aadida al final de la declaracin del cursor. En este caso, las tuplas seleccionadas son bloqueadas y no pueden ser accedidas por otros usuarios hasta que sea ejecutado un comando COMMIT. Antes de utilizar un cursor declarado previamente, ste debe estar abierto. Una vez procesadas las tuplas definidas en l, debe de ser cerrado. Discutiremos con mas detalle el uso del cursor ms adelante. Las excepciones son utilizadas para procesar de forma controlada los errores y advertencias que ocurren durante la ejecucin de sentencias PL/SQL. Algunas excepciones, como ZERO_DIVIDE, son definidas internamente. Otras excepciones pueden ser especificadas por el usuario al final de un bloque PL/SQL. Para que el usuario defina las excepciones necesita declararlas utilizando <nombre de excepcion> EXCEPTION Discutiremos el manejo de las excepciones en el apartado 6.
4. Elementos del lenguaje

Adems de la declaracin de variables, constantes y cursores, PL/SQL presenta varias elementos como la asignacin de valores a variables, estructuras repetitivas (loops), estrucuturas alternativas (ifthen-else), llamadas a procedimientos y funciones, etc. Sin embargo, PL/SQL no permite comandos del lenguaje de definicin de datos DDL (data definition language) tales como la creacin de tablas (create table). Adems, PL/SQL utiliza una modificacin en la sentencia SELECT que requiere que una tupla sea asignada a un registro (o una lista de variables). En PL/SQL hay varias alternativas para la asignacn de un valor a una variable. El camino ms sencillo para asignar un valor a una variable es
Universidad de Jan
54
PL/SQL DECLARE contador INTEGER:=0; . . . BEGIN contador:=contador + 1;
Los valores asignados a una variable tambin pueden ser recuperados de la base de datos usando la sentencia SELECT. SELECT <columna(s)> INTO <lista de variables> FROM <tabla(s)> WHERE <condicin>; Es muy importante asegurar que la sentencia SELECT recupera a lo sumo una tupla. Si no ocurre esto, no es posible asignar los valores del atributo a la lista de variables especificada y se producira un error de ejecucin. Si el SELECT recupera mas de una tupla, en lugar de ste, deber ser utilizado un cursor. Adems, los tipos de datos de las variables especificadas deben concordar con los valores de atributo recuperados. Para la mayora de los tipos de datos, PL/SQL realiza una conversin automtica (ej., de entero a real). Tras la palabra reservada into, en lugar de una lista de variables podemos incluir un registro. Este caso, la sentencia SELECT debe recuperar como mximo una nica tupla. DECLARE REG_EMPLEADO EMPLEADO%ROWTYPE; MAXSAL EMPLEADO.SALARIO%TYPE; BEGIN SELECT NUM_EMP, NOMBRE_EMP, TAREA, JEFE, SALARIO, FECHA_ALTA, NUM_DPTO INTO REG_EMPLEADO FROM EMPLEADO WHERE NUM_EMP=5698; SELECT MAX (SALARIO) INTO MAXSAL FROM EMPLEADO; . . . END;
PL/SQL incluye bucles WHILE, dos estucturas de bucles FOR, y bucles continuos. Mas adelante utilizaremos algunos de ellos en combinacin con cursores. Todos los tipos de bucles son utilizados para ejecutar multiples veces una secuencia de sentencias. La especificacin de bucles se realiza de la misma forma que en los lenguajes de programacin imperativos como C y Pascal.
La sintaxis de un bucle WHILE es la siguiente: [<nombre de etiqueta>] WHILE <condicion> LOOP <secuencia de sentencias>; END LOOP [<nombre de etiqueta>]; En general, el etiquetado del bucle es opcional, aunque cuando se presentan varios bucles continuos (incondicionales) anidados, resulta obligatorio el etiquetado, ya que es necesario incluir la sentencia EXIT <nombre de etiqueta>;
Por tanto, el numero de iteraciones a travs de un bucle WHILE no es conocido hasta que el bucle finaliza. El numero de iteraciones a travs del bucle FOR puede ser precisado utilizando dos nmeros enteros.
55
Universidad de Jan
PL/SQL
[<nombre de etiqueta>] FOR <ndice> IN [REVERSE] <limite inferior>...<limite superior> LOOP <secuencia de sentencias>; END LOOP [<nombre de etiqueta>];
El contador de bucle <ndice> esta implcitamente declarado. El mbito del contador del bucle es slo el bucle FOR. Esto anula el alcance de algunas variables que tienen el mismo nombre fuera del bucle. Dentro el bucle FOR, <ndice> puede ser referenciado como una constante. <ndice> puede aparecer en expresiones, pero no es posible asignarle valores. El uso de la palabra reservada REVERSE, provoca in incremento negativo del ndice, desde el limite superior (<lmite superior>) hasta el inferior (<lmite inferior>).
5. Manejo de Cursores
Antes de que un cursor pueda ser utilizado, debe ser abierto usando la sentencia OPEN. OPEN <nombre de cursor> INTO [<lista de parmetros>]; La sentencia SELECT asociada es entonces procesada, y el cursor hace referencia (apunta) a la primera tupla seleccionada. Las tuplas seleccionadas pueden ser entonces procesadas una a una usando el comando FETCH. FETCH <nombre de cursor> INTO <lista de variables>;
El comando FETCH asigna los valores de los atributos seleccionados de la tupla actual a la lista de variables. Despus de ejecutar el comando FETCH, el cursor avanza a la siguiente tupla del conjunto seleccionado. Hemos de tener en cuenta las variables en la lista deben de tener los mismos tipos de datos que los valores seleccionados. Despus de que todas las tuplas hayan sido procesadas, el cursor debe de ser deshabilitado mediante el comando CLOSE. CLOSE <nombre de cursor>;
El siguiente ejemplo muestra como un cursor es utilizado junto a un bucle: DECLARE CURSOR EMP_CUR IS SELECT * FROM EMPLEADO; REG_EMP EMPLEADO%ROWTYPE; SAL_EMP EMPLEADO.SALARIO%TYPE; BEGIN OPEN EMP_CUR; LOOP FETCH EMP_CUR INTO REG_EMP; EXIT WHEN EMP_CUR%NOTFOUND; SAL_EMP := REG_EMP.SAL; <SECUENCIA DE SENTENCIAS> END LOOP; CLOSE EMP_CUR; . . . END;
Universidad de Jan
56
PL/SQL
Cada bucle puede ser completado incondicionalmente usando la clusula EXIT. EXIT [<etiqueta de bloque>] [WHEN <condicin>]
El uso de EXIT sin una etiqueta de bloque causa el fin de la ejecucin del bucle que contiene la sentencia exit. La condicin puede ser una simple comparacin de valores. En la mayora de los casos, la condicin se refiere a un cursor. En el ejemplo anterior, %NOTFOUND es un operador que se evala como falso si el ltimo comando FETCH ejecutado ha ledo una tupla. Si no ha sido posible leer una tupla al haber sido ya todas procesadas, %NOTFOUND devuelve falso. El valor de <nombre de cursor>%NOTFOUND es nulo antes de que la primera tupla sea procesada con un FETCH. El operador %FOUND es la oposicin lgica de %NOTFOUND. El cursor de los bucles FOR puede ser usado para simplificar el uso del cursor: <nombre de etiqueta>] FOR <nombre registro> IN <nombre cursor> [(<lista parametros>)] LOOP <secuencia de sentencias> END LOOP [<nombre de etiqueta>]; Con esta sintaxis, se declara de forma implcita el registro apropiado para almacenar una tupla del cursor. Adems, este bucle ejecuta implcitamente un FETCH en cada iteracin, as como un OPEN antes de que se entre en el bucle y un CLOSE despus de que el bucle finalice. Si se intenta ejecutar un bucle con un cursor que no ha seleccionado ninguna tupla, ste finaliza automticamente. Esto es igualmente posible al especificar una consulta en lugar de <nombre de cursor> en un bucle FOR: FOR <nombre de registro> IN (<sentencia select>) LOOP <secuencia de sentencias> END LOOP; Es decir, un cursor no necesita ser especificado antes de entrar el bucle, pero es definido en la sentencia SELECT. Ejemplo: FOR REG_SAL IN (SELECT SALARIO+COMM ...; END LOOP; TOTAL FROM EMPLEADO) LOOP
TOTAL es un alias para la expresin en la sentencia SELECT. As, en cada iteracin slo se procesa una nica tupla. El registro REG_SAL, que est implcitamente definido, contiene slo una entrada a la que podemos acceder con REG_SAL.TOTAL. Los alias, por supuesto, no son necesarios si son seleccionado atributos exclusivamente, es decir, si la sentencia SELECT no contiene ni operadores aritmticos ni funciones agregadas. Para las estructuras de control alternativas, PL/SQL ofrece la estructura IF-THEN-ELSE IF <condicin> THEN <secuencia de sentencias> [ELSIF] <condicin> THEN <secuencia de sentencias> ... [ELSE] <secuencia de sentencias> END IF; Empezando con la primera condicin, si sta es verdadera, su correspondiente secuencia de sentencias son ejecutadas, de otra forma el control pasara a la prxima condicin. As la conducta de este tipo de sentencias PL/SQL es anloga a las sentencias IF-THEN-ELSE en los lenguajes de programacin imperativos.
57
Universidad de Jan
PL/SQL
Excepto en los comandos DDL (data definition lanbguaje) como CREATE TABLE, todos los tipos de sentencias SQL pueden ser utilizadas en los bloques PL/SQL, en particular DELETE, INSERT, UPDATE, y COMMIT. Notese que en PL/SQL slo se permite la sentencia SELECT del tipo SELECT <column(s)> INTO <variable list>, es decir, los valores de atributo seleccionados slo pueden ser asignados a variables. El uso de la sentencia SELECT SQL provoca un error de sintaxis. Si las sentencias UPDATE o DELETE se utilizan en combinacin con un cursor, estos comandos pueden ser restringidos a la tupla en proceso (fetched). Para ello, se aade la clausula WHERE CURRENT OF <nombre de cursor>, tal y como se muestra en el siguiente ejemplo. Ejemplo: El siguiente bloque PL/SQ ejecuta las siguientes modificaciones: Todos los empleados que tengan como jefe a JIMENEZ incrementarn su salario en un 5%. DECLARE MANAGER EMPLEADO.JEFE%TYPE; CURSOR EMP_CUR (NUM_JEFE NUMBER) IS SELECT SALARIO FROM EMPLEADO WHERE JEFE = NUM_JEFE FOR UPDATE OF SALARIO; BEGIN SELECT NUM_EMP INTO MANAGER FROM EMPLEADO WHERE NOMBRE_EMP = JIMENEZ; FOR REG_EMP IN EMP_CUR(MANAGER) LOOP UPDATE EMPLEADO SET SALARIO = REG_EMP.SALARIO * 1.05 WHERE CURRENT OF EMP_CUR; END LOOP; COMMIT; END;
6. Manejo de Excepciones
Un bloque PL/SQL puede contener sentencias que especifique rutinas de manejo de excepciones. Cada error o advertencia (warning) durante la ejecucin del bloque PL/SQL genera una excepcin. Podemos distinguir dos tipos de excepciones: Excepciones definidas por el sistema. Excepciones definidas por el usuario (que deben ser declaradas por ste en la parte del bloque donde la excepcin es usada/ implementada) Las excepciones definidas por el sistema son automticamente generadas cuando se produce un error o advertencia. Por el contrario, las excepciones definidas por el usuario, deben ser generadas implcitamente mediante una secuencia de sentencias utilizando la clusula RAISE <nombre de excepcin>. Las rutinas del manejo de excepciones son implementadas por el usuario al final del bloque y tras la palabra reservada EXCEPCTION: WHEN <nombre de excepcin> THEN <secuencia de sentencias>;
Los errores ms comunes que pueden darse durante la ejecucin de los programas PL/SQL son manejados por excepciones definidas por sistema. La siguiente tabla muestra algunos de sus nombres y descripciones cortas.
Universidad de Jan
58
PL/SQL
Nombre de la excepcin CURSOR_ALREADY_OPEN INVALID_CURSOR NOT_DATA_FOUND TOO_MANY_ROWS ZERO_DIVIDE
Principales excepciones del sistema. Numero Observaciones ORA-06511 Se ha intentado abrir un cursor que est ya abierto. ORA-01001 Se ha intentado hacer un fetch sobre un cursor cerrado. ORA-01403 Una sentencia select ... into o fetch no devuelve ninguna tupla. ORA-01422 Una sentencia select ... into o fetch no devuelve ms de uan tupla. ORA-01476 Se ha intentado dividir un numero entre 0.
Ejemplo: DECLARE SAL_EMP EMPLEADO.SALARIO%TYPE; N_EMP EMPLEADO.NUM_EMP%TYPE SALARIO_DEMASIADO_ALTO EXCEPCION; BEGIN SELECT NUM_EMP, SALARIO INTO N_EMP, SAL_EMP FROM EMPLEADO WHERE NOMBRE_EMP = GOMEZ; IF SAL_EMP * 1.05 > 4000 THEN RAISE SALARIO_DEMASIADO_ALTO ELSE UPDATE EMPLEADO SET SQL. . . END IF; EXCEPCTION WHEN NO_DATA_FOUND NO SE SELECCIONAN TUPLAS THEN ROLLBACK; WHEN SALARIO_DEMASIADO_ALTO THEN INSERT EMP_SAL_ALTOS VALUES( N_EMP); COMMIT; END; Tras la palabra reservada WHEN, podemos incluir una lista de nombres de excepciones conectados con el operador relacional OR. La ltima clusula WHEN en la parte de EXCEPTION puede contener la excepcin OTHERS. sta presenta la excepcin por defecto de la rutina de manejo, por ejemplo, un ROLLBACK. Si un programa PL/SQL es ejecutado desde la shell del SQL*Plus, las rutinas de manejo de excepciones pueden contener sentencias que muestren errores o mensaje de advertencias en la pantalla mediante el procedimiento RAISE_APPLICATION_ERROR. Este procedimiento tiene dos parmetros <numero de error> y <texto del mensaje>. <numero de error> es un entero negativo definido por el usuario y cuyo rango esta entre 20000 y 20999. <mensaje de error> es un string con una longitud no superior a 2048 caracteres. El operador de concatenacin de caracteres || puede ser utilizado para concatenar cadenas de caracteres simples a una cadena de caracteres. Para mostrar variables numricas, stas deben de ser convertidas a strings usando la funcin TO_CHAR. Si RAISE_APPLICATION_ERROR es llamado por un bloque PL/SQL, la ejecucin de dicho bloque finaliza y todas las modificaciones realizafdas sobre la BD son anuladas. Dicho de otro modo, se desarrolla un ROLLBACK implcito adems de mostrar el mensaje de error. Ejemplo: IF SAL_EMP * 1.05 > 4000 THEN RAISE_APPLICATION_ERROR (-20010, El incremento salarial para el empleado nmero || TO_CHAR (N_EMP) || es demasiado alto );
59
Universidad de Jan
PL/SQL
7. Procedimientos y Funciones
PL/SQL proporciona un lenguaje sofisticado para construir procedimientos y funciones de programa que pueden ser invocados por otros bloques PL/SQL y por otros procedimientos y funciones. La sintaxis para la definicin de procedimientos es CREATE [OR REPLACE] PROCEDURE <nombre de procedimiento> (<lista de parmetros>)] IS <declaracin> BEGIN <secuencia de sentencias> [EXCEPTION <rutinas de manejo de excepciones>] END [<nombre de procedimiento>];
Una funcin puede ser especificada de una forma parecida: CREATE [OR REPLACE] FUNCTION <nombre de funcin> [(<lista de parmetros>)] BEGIN <secuencia de sentencias> [EXCEPTION <rutinas de manejo de excepciones>] END [<nombre de funcin>];
La clusula opcional OR REPLACE vuelve a crear el procedimiento o funcin. Un procedimiento o funcin puede ser borrado respectivamente con los comandos DROP PROCEDURE <nombre de procedimiento> DROP FUNCTION <nombre de funcin> Al contrario que en los bloques PL/SQL annimos, la clausula DECLARE no puede ser utilizada en las funciones/procedimientos definidos. Los parmetros vlidos incluyen todos los tipos de datos. Sin embargo, para los tipos CHAR, VARCHAR2 Y NUMBER no deben de especificar longitud ni escala. Por ejemplo, el parmetro NUMBER(6) da un error de compilacin y debe ser reemplazado por NUMBER. Los tipos implcitos del tipo %TYPE y %ROWTYPE pueden ser utilizados sin ninguna restriccin. Los parmetros se especifican de la siguietne forma: <nombre de parmetro> [IN | OUT | IN OUT] <tipo de dato> [{:= |DEFAULT } <expresin>] Las clusulas IN, OUT, y IN OUT especifican el modo en que es utilizado el parmetro. Por defecto, los parmetros son de modo IN. IN significa que el parmetro puede estar referenciado dentro del cuerpo del procedimiento, pero no puede ser cambiado. OUT significa que al parmetro se le puede asignar un valor, pero el valor del parmetro no puede ser referenciado. IN OUT permite ambas cosas, asignar valores a los parmetros y referenciarlos. Normalmente basta con usar el modo por defecto (IN). Ejemplo: El siguiente procedimiento incrementa el salario de todos los empleados que trabajan en un departamento dado como parmetro de entrada al procedimiento. El porcentaje del incremento de salario tambin es un parmetro de entrada (por defecto 0.5). Universidad de Jan 60
PL/SQL
CREATE PROCEDURE INCREMENTO_SALARIAL (DNO NUMBER, PORCENTAJE NUMBER DEFAULT 0.5) IS CURSOR EMP_CUR (N_DPTO NUMBER) IS SELECT SALARIO FROM EMPLEADO WHERE NUM_DPTO = N_DPTO FOR UPDATE OF SALARIO SAL_EMP NUMBER (8); BEGIN OPEN EMP_CUR (DNO); - - ASIGNAMOS DNO A N_DPTO LOOP FETCH EMP_CUR INTO SAL_EMP; EXIT WHEN EMP_CUR%NOTFOUND; UPDATE EMPLEADO SET SALARIO = SAL_EMP*((100+PORCENTAJE) /100) WHERE CURRENT OF EMP_CUR; END LOOP; CLOSE EMP_CUR; COMMIT; END INCREMENTO_SALARIAL; Este procedimiento puede ser invocado desde la shell SQL*Plus usando el comando EXECUTE INCREMENTO_SALARIAL(10,3); Si el procedimiento es llamado slo con el valor 10, se entiende que el valor del parmetro porcentaje es el declarado por defecto: 0.5. Si un procedimiento es llamado desde el bloque PL/SQL la utilizacin de EXECUTE es omitida. Las funciones tienen la misma estructura que los procedimientos. La nica diferencia es que las funciones devuelven un valor de un tipo que debe ser declarado, no existiendo ninguna restriccin para ello. CREATE FUNCTION SALARIO_TOTAL_DPTO (DNO NUMBER) R ETURN NUMBER IS SALARIO_TOTAL NUMBER;. BEGIN SALARIO_TOTAL := 0; FOR SAL_EMP IN (SELECT SALARIO FROM EMPLEADO WHERE NUM_DPTO = DNO AND SALARIO IS NOT NULL) LOOP SALARIO_TOTAL := SALARIO_TOTAL + SAL_EMP.SALARIO; END LOOP; RETURN SALARIO_TOTAL; END SALARIO_TOTAL_DPTO; Para llamar a una funcin desde la shell de SQL*Plus es necesario en primer lugar definir la variable en la que se almacenar el valor devuelto. En SQL*Plus una variable puede ser definida utilizando el comando VARIABLE <nombre de variable> <tipo de variable>; por ejemplo, VARIABLE sueldo NUMBER. utilizando el comando EXECUTE: EXECUTE La funcin anterior puede ser entonces llamada
:SUELDO := SALARIO_TOTAL_DPTO(20);
Tengase en cuenta que el simbolo : debe ponerse delante de la variable.
61
Universidad de Jan
PL/SQL
Utilizando el comando HELP en SQL*Plus puede obtenerse ms informacin sobre los procedimientos y funciones, por ejemplo HELP [CREATE] FUNCTION, HELP SUBPROGRAM, HELP STORED SUBPROGRAMS.
Universidad de Jan
62
PL/SQL
8. Disparadores (Triggers)
8.1. Visin General

Los diferentes tipos de restricciones de integridad vistos, estn muy lejos de proporcionar un mecanismo declarativo para asociar condiciones simples a tablas tal como ocurre con las restricciones de llave primaria, llave fornea o de dominio. Las restricciones complejas de integridad que se refieren a varias tablas y atributos no pueden ser especificadas en la definicin de la tabla. Los disparadores, por lo contrario, proporcionan una tcnica procedural para especificar y mantener las restricciones de integridad. Los disparadores incluso permiten a los usuarios especificar las condiciones de integridad ms complejas, ya que un disparador es esencialmente un procedimiento PL/SQL (asociado con una tabla) que es automticamente llamado por el SGBD cuando ocurre alguna modificacin (evento) en la tabla. Las modificaciones de la tabla pueden incluir operaciones INSERT, UPDATE, Y DELETE.
8.2. Estructura de los disparadores

La definicin de un disparador consta de los siguientes componentes (opcionales): Nombre del disparador CREATE [OR REPLACE] TRIGGER <nombre de disparador> Tiempo o punto del disparador BEFORE | AFTER Eventos disparadores INSERT OR UPDATE [OF <columna(s)>] OR DELETE ON <tabla> Tipo de disparador (opcional) FOR EACH ROW Restricciones disparador (solo para disparador FOR EACH ROW ) WHEN (<condicin>) Cuerpo del disparador <Bloque PL/SQL>
63
Universidad de Jan
PL/SQL
La clusula REPLACE vuelve a crear una definicin de disparador con el mismo <nombre de disparador>. El nombre de un disparador puede ser elegido arbitrariamente, pero un buen estilo de programacin es usar un nombre de disparador que refleje al de la tabla y el evento(s), por ejemplo: UPD_INS_EMP. Un disparador puede ser invocado antes o despus del evento disparador (trigger event). Un evento simple es una sentencia INSERT, UPDATE o DELETE; los eventos pueden ser combinados usando la conectiva lgica OR. Si no se especifican columnas en un disparador UPDATE, el disparador es ejecutado cuando la tabla <tabla> es modificada. Si el disparador debe de ejecutarse cuando son actualizadas slo determinadas columnas, estas columnas deben de ser especificadas despus del evento UPDATE. Para programar disparadores de forma eficiente y correcta es esencial comprender la diferencia entre un disparador-fila o disparador a nivel de fila (row level trigger) y un disparador-sentencia o disparador a nivel de sentencia (statement level trigger). Un disparador a nivel de fila se define utilizando la clusula FOR EACH ROW. Si no aparece esta clusula en la definicin del disparador, se asume que es un disparador-sentencia. Un disparador-fila se ejecuta una vez por cada fila antes (o despus) del evento. Por el contrario, un disparador-sentencia se ejecuta una nica vez antes (o despus) del evento, independientemente del nmero de las filas afectadas por el evento. Por ejemplo, un disparador-fila con la especificacin de evento AFTER UPDATE es ejecutado una vez por cada fila afectada por la actualizacin. Por consiguiente, si la actualizacin afecta a 20 tuplas, el disparador es ejecutado 20 veces. En contraposicin, un disparador-sentencia es ejecutado slo una vez. Si combinamos los diferentes tipos de disparadores, hay doce posibles configuraciones que pueden ser definidas por la tabla: Tipos de disparadores. Punto del disparador Tipo de disparador BEFORE AFTER SENTENCIA FILA X X X X X X X X X X X X
Evento INSERT UPDATE DELETE
Los disparadores-fila tienen algunas caractersticas especiales de la que carecen los disparadoressentencias. Slo con un disparador-fila es posible acceder a los valores de los atributos de una tupla antes y despus de la modificacin (ya que el disparador es ejecutado una vez por cada tupla). Para un disparador UPDATE podemos acceder al valor que posee el atributo antes de disparo (valor antiguo) utilizando :OLD.<columna> y podemos acceder al valor de atributo tras el disparo (valor nuevo) utilizando :NEW.<columna>. Para un disparador INSERT slo puede ser utilizado :NEW.<columna> y para un disparador DELETE slo puede ser utilizado :OLD.<columna> (ya que en un borrado no existen valores nuevos, unicamente existen valores viejos de tupla). En estos casos, :NEW.<columna> se refiere a valores de atributos de <columna> en la tupla insertada, y :OLD.<columna> se refiere al valor de atributo de la columna de la tupla borrada. En un disparadorfila es posible especificar comparaciones entre un nuevo y antiguo valor de atributo en el bloque PL/SQL. Por ejemplo, IF :OLD.SALARIO := :OLD.SALARIO THEN... . Si un disparador-fila es especificado como BEFORE, es incluso posible modificar los nuevos valores de la fila, ej., :NEW.SALARIO:=:NEW * 1.05 or :NEW.SALARIO:=:OLD.SALARIO. Estas modificaciones no son posibles con disparadores-fila AFTER. En general, es aconsejable usar un disparador-fila AFTER si la nueva fila no es modificada en el bloque PL/SQL. Los disparadores-sentencia son usados generalmente en combinacion con AFTER. En una definicin de disparador, la clusula WHEN slo puede ser utilizada en combinacin con la opcin FOR EACH ROW. Esta clusula es utilizada para restringir cundo se ejecuta el disparador. Para la especificacin de la condicion en la clusula WHEN, se siguen las mismas normas que para la clausula CHECK. Las nicas excepciones son que las funciones SYSDATE y USER pueden ser utilizadas, y que es posible referirse al viejo/nuevo valor de atributo de la fila actual. En el caso anterior, el smbolo : no debe ser usado (OLD.<atributo> y NEW.<atributo>). Universidad de Jan 64
PL/SQL
El cuerpo del disparador consiste en un bloque PL/SQL. Todos los comandos PL/SQL pueden ser utilizados en un bloque disparador, a excepcin de las sentencias COMMIT y ROLLBACK. Adems, la utilizacin adicional de la estructura IF permite ejecutar ciertas partes del bloque PL/SQL dependiendo del evento disparador. Para ello, existen las tres construcciones IF INSERTING, IF UPDATING[(<columna>)], y IF DELETING, que pueden ser utilizadas de la forma que muestra el siguiente ejemplo: CREATE OR REPLACE TRIGGER COMPROBAR_EMPLEADO AFTER INSERT OR DELETE OR UPDATE ON EMPLEADO FOR EACH ROW BEGIN IF INSERTING THEN <BLOQUE PL/SQL> END IF; IF UPDATING THEN <BLOQUE PL/SQL> END IF; IF DELETING THEN <BLOQUE PL/SQL> END IF; END;
8.3. Ejemplos de disparadores

Supongamos que tenemos que mantener la siguiente restriccin de integridad: El salario de un empleado diferente del presidente no puede ser incrementado ni decrementado ms de un 10%. Adems, dependiendo del trabajo, cada salario debe estar dentro de un cierto rango. CREATE OR REPLACE TRIGGER COMPROBAR_INCREMENTO_SALARIO_EMPLEADO AFTER INSERT OR UPDATE OF SALARIO, TAREA ON EMPLEADO FOR EACH ROW WHEN (NEW.TAREA != PRESIDENTE) -- RESTRICCIN DE DISPARADOR DECLARE MINSAL, MAXSAL NIVEL.SAL_MAX%TYPE; BEGIN - RECUPERA EL SALARIO MXIMNO Y MNIMO PARA UNA TAREA SELECT SAL_MIN, SAL_MAX INTO MINSAL, MAXSAL FROM NIVEL WHERE TAREA = :NEW.TAREA; -- SI EL NUEVO SALARIO HA SIDO DECREMENTADO O NO EST DENTRO DE LOS LMITES, SE PRODUCE UNA EXCEPCIN IF ( :NEW.SALARIO < MINSAL OR :NEW.SALARIO > MAXSAL) THEN RAISE_APPLICATION_ERROR(-20230, EL SALARIO HA SIDO DECREMENTADO); ELSIF ( :NEW.SALARIO > 1.1 * :OLD.SALARIO) THEN RAISE_APPLICATION_ERROR(-20235, INCREMENTO SUPERIOR AL 10%); END IF; END;
65
Universidad de Jan
PL/SQL
Hemos usado un disparador AFTER ya que las filas insertadas y actualizadas no cambian dentro del bloque PL/SQL (ej., en caso de una violacin de una restriccin, podramos restaurar el valor antiguo del atributo). Tngase en cuenta que las modificaciones en la tabla NIVEL tambin pueden causar una violacin de restriccin. Para mantener una condicin completa definimos el siguiente disparador en la tabla NIVEL. En caso de una violacin por una modificacin UPDATE, nosotros no podemos invocar a una excepcin, pero podemos restaurar el valor antiguo del atributo. CREATE OR REPLACE TRIGGER COMPROBAR_SALARIO_NIVEL BEFORE UPDATE OR DELETE ON NIVEL FOR EACH ROW WHEN (NEW.SAL_MIN > OLD.SAL_MIN OR NEW.SAL_MAX < OLD.SAL_MAX) DECLARE TAREA_EMP NUMBER(3) := 0; BEGIN IF DELETING THEN --PUEDE UN EMPLEADO TENER ASIGNADA UNA TAREA BORRADA? SELECT COUNT(*) INTO TAREA_EMP FROM EMPLEADO WHERE TAREA = :OLD.TAREA; IF TAREA_EMP != 0 THEN RAISE_APPLICATION_ERROR(-20240, EXISTEN EMPLEADOS CON LA TAREA || :OLD.TAREA); END IF; END IF; IF UPDATING THEN -- HAY EMPLEADOS CUYO SALARIO EST FUERA DEL RANGO? SELECT COUNT(*) INTO TAREA_EMP FROM EMPLEADO WHERE TAREA = :NEW.TAREA AND SALARIO NOT BETWEEN :NEW.SAL_MIN AND :NEW.SAL_MAX; IF TAREA_EMP != 0 THEN - - RESTAURAR LOS ANTIGUOS RANGOS DE SALARIO :NEW.SAL_MIN := :OLD.SAL_MIN; :NEW.SAL_MAX:= :OLD.SAL_MAX; END IF; END IF; END;
En este caso hemos utilizado un disparador BEFORE para restaurar el valor antiguo de un atributo perteniciente a una fila actualizada. Supongamos que adems tenemos una columna PRESUPUESTO en nuestra tabla DPTO que es utilizada para almacenar el presupuesto del departamento. Asumamos la restriccin de integridad que establece que el total de los salarios de un departamento no puede exceder el presupuesto del departamento. Las operaciones criticas para la tabla EMPLEADO son la insercin de nuevas tuplas y la actualizacin de los atributos SALARIO o NUM_DPTO. CREATE OR REPLACE TRIGGER COMPROBAR_PRESUPUESTO_PROYECTO AFTER INSERT OR UPDATE OF SALARIO, NUM_DPTO ON EMPLEADO DECLARE CURSOR DPTO_CUR IS SELECT NUM_DPTO, PRESUPUESTO FROM DPTO; DNO DPTO.NUM_DPTO%TYPE; TOTAL_SALARIOS DPTO.PRESUPUESTO%TYPE, DPTO_SALARIOS NUMBER; Universidad de Jan 66
PL/SQL
BEGIN OPEN DPTO_CUR LOOP FETCH DPTO_CUR INTO DNO, TOTAL_SALARIOS; EXIT WHEN DPTO_CUR %NOTFOUND; SELECT SUM(SALARIO) INTO DPTO_SALARIOS FROM EMPLEADO WHERE NUM_DPTO = DNO; IF DPTO_SALARIOS > TOTAL_SALARIOS THEN RAISE_APPLICATION_ERROR(-20325, EL TOTAL DE LOS SALARIOS DEL DEPARTAMENTO. || EXCEDE DEL PRESUPUESTO); END IF; END LOOP; CLOSE DPTO_CUR; END;
|| TO_CHAR(DNO)
En este caso, utilizamos una sentencia disparador en la tabla EMPLEADO porque tenemos que aplicar una funcin agregada al salario de todos los empleados que trabajan en un departamento en particular. Para la tabla DPTO, debemos definir otro disparador, pero en este caso, puede ser definido como un disparador-fila.
8.4. Programacin de disparadores

A la hora de programar, los diparadores-fila son el tipo de disparador ms problemtico, ya que incluyen varias restricciones. Para asegurar la consistencia de lectura, Oracle realiza un bloqueo de la tabla desde el comienzo de las sentencias INSERT, UPDATE, o DELETE. Esto quiere decir, que otros usuarios no pueden acceder a esta tabla hasta que las inserciones/modificaciones/borrados se hayan completado satisfactoriamente. En este caso, la tabla sobre la que se realiza la operacin se denomina tabla mutante (mutating table). La nica forma de acceder a una tabla mutante en un disparador es utilizando :OLD.<columna> y :NEW.<columna> en conexin con una fila disparador. Ejemplo de un disparador-fila errneo: CREATE TRIGGER COMPROBAR_SALARIO_EMPLEADO AFTER UPDATE OF SALARIO ON EMPLEADO FOR EACH ROW DECLARE SUM_SAL NUMBER; BEGIN SELECT SUM(SALARIO) INTO SUM_SAL FROM EMPLEADO; . . .; END;
Si una sentencia UPDATE de la forma UPDATE EMPLEADO SET SALARIO = SALARIO * 1.1; es ejecutada en la tabla EMPLEADO, el disparador de arriba es ejecutado una vez por cada fila modificada. Mientras la tabla est siendo modificada por el comando UPDATE, no es posible acceder a Universidad de Jan
67
PL/SQL
todas las tuplas de la tabla usando el comando SELECT, porque este est cerrado. En este caso obtendremos los siguientes mensajes de error: ORA-04091: ORA-06512: ORA-04088: la tabla EMPLEADO es mutante, el disparador no debe ni leer ni modificar en la lnea 4 error durante la ejecucin del disparador comprobar_salario_empleado
La nica forma de acceder a la tabla, y ms concretamente a la tupla, es usar :OLD.<columna> y :NEW.<columna>. Se recomienda seguir las reglas de abajo para la definicin de integridad manteniendo disparadores:
Identificar operaciones y tablas criticas para cada restriccin de integridad Para cada tabla chequear If la restriccin puede ser comprobada a nivel de fila then If las filas comprobadas son modificadas dentro del disparador then usar disparador-fila tipo before else usar disparador-fila tipo after else usar disparador-sentencia tipo after
Los disparadores no son utilizados exclusivamente para el mantenimiento de la integridad. Pueden se utilizados tambin para: Control de acceso a los usuarios y modificaciones en ciertas tablas Monitorizacin de operaciones sobre tablas: CREATE TRIGGER LOG_EMP AFTER INSERT OR UPDATE OR DELETE ON EMPLEADO BEGIN IF INSERTING THEN INSERT INTO EMP_LOG VALUES (USER, INSERT , SYSDATE); END IF; IF UPDATING THEN INSERT INTO EMP_LOG VALUES(USER, UPDATE, SYSDATE); END IF; IF DELETING THEN INSERT INTO EMP_LOG VALUES(USER, DELETE, SYSDATE); END IF; END; La propagacin automtica de las modificaciones. Por ejemplo, si un jefe es transferido a otro departamento, puede ser definido un disparador que automticamente transfiera a los empleados del jefe al nuevo departamento.
Universidad de Jan
68
PL/SQL
8.5. Mas sobre disparadores

Si un disparador se define el SQL*Plus shell, la definicin debe terminar con un punto . en la ultima lnea. Una definicin disparador puede ser cargada desde un fichero utilizando el comando @. Tngase en cuenta que la ltima lnea del fichero debe contener un slash / Una definicin disparador no puede ser cambiada, slo puede ser recreada usando la clusula OR REPLACE.. El comando DROP TRIGGER <nombre de disparador> borra un disparador. Despus de que una definicin disparador haya sido compilada satisfactoriamente, el disparador es habilitado automticamente. El comando ALTER TRIGGER <nombre de disparador> DISABLE; es utilizado para deshabilitar un disparador. Todos los disparadores definidos en una tabla pueden ser (des)habilitados utilizando el comando ALTER TABLE <nombre de tabla> ENABLE | DISABLE ALL TRIGER; El diccionario de datos guarda informacin acerca de los disparadores en la tabla USER_TRIGGERS. La informacin incluye el nombre del disparador, tipo, tabla y el cdigo para el bloque PL/SQL.
69
Universidad de Jan
4 Developer/2000: Forms Programacin del cliente
Developer/2000: Forms
1. Introduccin
En este tema se va a realizar un estudio del conjunto de programas que constituyen la herramienta FORMS 4.5 (incluida en el paquete Developer/2000 de Oracle). La intencin no es proporcionar un manual exhaustivo de todas las caractersticas que proporciona la herramienta, sino dar una visin general de la misma, a modo de tutorial, que permita entender y practicar las tcnicas ms habituales del diseo bajo Developer. Oracle FORMS es una herramienta de desarrollo de aplicaciones de bases de datos en arquitectura cliente/servidor. FORMS es un conjunto de programas que permite la definicin y ejecucin de formatos (o formularios) interactivos de pantalla. Un formato ORACLE es la representacin en el ordenador de un formato de papel, utilizado para la introduccin de informacin en la base de datos. Los formatos creados por FORMS son aplicaciones interactivas en entorno WINDOWS a travs de las cuales un usuario final puede insertar, actualizar, borrar o consultar informacin de la base de datos. Realmente, un formato es un programa escrito en un lenguaje especial. Por esta razn, asociado a un formato existen varios ficheros, un fichero .FMT que es el fichero fuente, un fichero .FMB con el diseo en binario y uno .FMX que es el fichero objeto ejecutable. La existencia de los ficheros .FMT permiten el traslado de los formatos de unas plataformas a otras. La herramienta FORMS consta de tres programas: Designer: es el entorno de desarrollo de la aplicacin. Incluye un conjunto de herramientas visuales que permiten crear objetos, establecer sus propiedades y escribir el cdigo asociado a la aplicacin. Generate: genera los ficheros con el cdigo asociado al diseo (.FMT y .FMB) y el cdigo objeto para el runtime (.FMX). Runform: es un motor de tiempo de ejecucin que ejecuta un formato .FMX generado anteriormente.
1.1. Designer
Este es el programa que se utiliza para la creacin de los formatos, aunque, como ya se coment antes, permite llamar a los otros programas que constituyen FORMS 4.5. El programa Designer consiste en una serie de ventanas a travs de las cuales se irn diseando los distintos formatos. Los objetos creados con Designer se agrupan por funciones. Cada rea funcional de la aplicacin (que coinciden bsicamente con los niveles descritos en el punto anterior) se 73 Universidad de Jan
Programacin de Bases deDatos Oracle corresponde con un subrbol dentro de la jerarqua de objetos de Designer.
Al igual que en SQL*PLUS, lo primero que se debe hacer una vez ejecutado Designer es conectarse a la base de datos: FILE -> CONNECT, esto significa men FILE, opcin CONNECT. Una caracterstica fundamental de Designer es que el manejo de las aplicaciones creadas con l se pueden realizar o bien utilizando el men por defecto que se aade a toda aplicacin Forms, o bien a travs de teclas de funcin. Cada tecla de funcin tiene un nombre y lleva asociada una tecla o combinacin de teclas concretas y dependientes del terminal que se est utilizando. El conjunto de teclas de funcin se puede visualizar en cualquier momento (durante el diseo con CTRL+K y durante la ejecucin con CTRL+F1). Existen dos posibilidades de teclas de funcin: las teclas de funcin para el diseo y las teclas de funcin para la ejecucin. En la figura 1 se muestran parte de las teclas de funcin en diseo y en ejecucin para el caso del PC bajo WINDOWS.
Figura 1. Teclas de funcin modo DISEO.
Figura 2. Teclas de funcin modo EJECUCIN.
1.2. Runform
Es el programa encargado de ejecutar un fichero .FMX creado a travs del programa Generate. El formato ejecutado permanece activo hasta que se abandona o se produce un error irrecuperable. Se puede ejecutar el programa Runform desde Designer con FILE -> RUN. La ejecucin de un formato permite consultar y modificar en todos los sentidos (crear, borrar, editar, ...) la tuplas de las tablas asociadas a l. Estas acciones se llevan tambin a cabo mediante un conjunto de teclas de funcin y el manejo del cursor (con el ratn en la versin PC-WINDOWS, por ejemplo).
2. Estructuracin de un formato
Antes de pasar a ver ms en detalle el funcionamiento del programa FORMS, se debe asimilar la manera en la que se estructura un formato, ya que es fundamental para poder pasar a realizar su diseo.
Un formato es una ventana o conjunto de ventanas (aplicacin cliente) a travs de las que se puede insertar, actualizar, eliminar y/o consultar informacin de la base de datos (almacenada en el servidor Oracle). Un formato se divide de forma lgica bsicamente en tres elementos funcionales:
Universidad de Jan
74
Developer/2000: Forms bloques, items y disparadores.
Adems de estos tres elementos funcionales existen dos unidades visuales: canvas-view y window. Con estos elementos se puede disear de forma flexible el flujo de entrada de datos, con deteccin y correccin de errores, y la representacin visual de la informacin de la base de datos, disponiendo de una gran variedad de formatos distintos.
FORMATO Es la unidad lgica ms amplia dentro de una aplicacin. Cada formato debe contener como mnimo un bloque, pudiendo contener cualquier nmero de disparadores. Un formato puede contener cualquier nmero de windows. En un formato con mltiples windows, las unidades lgicas del formato (bloques e items) se representan en ms de una ventana. Los disparadores creados a nivel de formato pueden ser llamados desde cualquiera de los bloques e items contenidos en este formato
BLOQUE Es la unidad lgica ms amplia dentro de un formato. Deber contener como mnimo un item, y podr contener cualquier nmero de disparadores. Cada bloque se puede asociar directamente con una y slo una tabla de la base de datos, aunque tambin pueden crearse bloques de control que no tengan asociada ninguna tabla. Esta asociacin directa permite a su vez la asociacin entre items y atributos de la tabla, lo que permite que los items de un bloque muestren la informacin de los atributos correspondientes de la tabla base asociada. Cada bloque dentro de un formato tiene un nombre nico. Los disparadores a nivel de bloque tienen preferencia sobre los disparadores de nivel de formato que tengan el mismo nombre, siendo ejecutados en lugar de stos cuando el cursor est en ese bloque. Cuando un bloque est asociado a una tabla puede ocurrir que pueda tratar (mostrar, actualizar, ...) una sola tupla de la tabla a la vez, o que pueda tratar varias tuplas de la tabla a la vez, en cuyo caso se dice que el bloque es de tipo multiregistro.
ITEM El item es la unidad lgica ms amplia dentro de un bloque. Los datos son manipulados a travs de esta unidad. Cada item dentro de un bloque debe tener un nombre nico para formar una asociacin directa entre el item y un atributo especfico de una tabla de la base de datos. Un item tambin puede tener cualquier nmero de disparadores, pero para existir no necesita contener ninguna unidad excepto su nombre. Existen dos grupos diferentes de items: los relacionados con la informacin de la base de datos y
75
Universidad de Jan
los relacionados con la informacin de un formato concreto. Si el bloque que contiene el item est asociado a una tabla de la base de datos, el item puede estar directamente asociado con uno de los atributos de esa tabla. Esta asociacin se crea simplemente utilizando el nombre del atributo como nombre del item y marcando dicho item como item de la base de datos. Los items que no estn marcados como items de la base de datos se utilizan nicamente para mostrar informacin relacionada con el formato, como ttulos, variables, resultados de clculos temporales, valores de variables globales, ... Los disparadores a nivel de item tienen preferencia sobre los que tuvieran el mismo nombre a nivel de bloque o de formato, ejecutndose en lugar de stos si existiera dicha coincidencia de nombres.
DISPARADOR Los niveles de formato, bloque e item constituyen la estructura de un formato, mientras que los disparadores son los que le proporcionan su funcionalidad. Como ya vimos en el captulo anterior, un disparador es un conjunto de comandos SQL o PL/SQL. La ejecucin de un disparador est vinculada al desencadenamiento de un determinado evento como puede ser una pulsacin de teclado especfica, un movimiento concreto del cursor o un movimiento concreto del cursor del ratn. Por ejemplo, a nivel de item, existen tres acontecimientos de cursor para activar un disparador: pre_item, post_item y post_change. En el primer caso el disparador se activa cuando se entra en el item, en el segundo caso cuando se sale del item y en el tercer caso cuando se sale del item y se haya cambiado su valor. En apartados posteriores se har un estudio ms detallado de los disparadores dentro de FORMS.
3. El proceso de desarrollo de un formato

Para crear un formato se utiliza el programa Designer. Al formato se le dar un nombre y mediante la creacin de una serie de objetos y el establecimiento de sus propiedades se ir rellenando la informacin necesaria para determinar el aspecto del formato, los datos que va a manipular y su reaccin ante situaciones o eventos especficos. Una vez completado el proceso de diseo del formato se ejecutarn el resto de programas de FORMS. Lo primero que hay que hacer es grabar a disco lo que hasta ese momento se encuentra en memoria (FILE -> SAVE), de esta forma obtenemos el correspondiente fichero .FMB. Para ejecutar el formato se utiliza FILE -> RUN. Si el resultado no es el esperado o existen errores en el formato, se modifica y se repite el proceso. Una vez creado el formato correcto es conveniente salvarlo en las tablas FORMS del diccionario de datos del servidor Oracle. A partir de este momento el formato se ejecutar con Runform, impidiendo de esta forma que el usuario final pueda modificar su diseo.
3.1. Creacin de un formato por defecto

Se va a crear un formato de la manera ms sencilla, que es utilizando las caractersticas por defecto. El formato que se va a crear corresponde a la tabla COCHES, utilizada en el captulo 2. Los pasos a dar son los siguientes: Universidad de Jan
76
1. Ejecutar el programa Designer y realizar la conexin al servidor Oracle. 2. Aparece en pantalla el men principal de Designer y el Navegador de Objetos que permitir crear, modificar y acceder a todos los objetos que vayan siendo aadidos al formato. La forma de crear un formato nuevo es similar a la creacin de cualquier objeto en FORMS: hay que situarse en el Navegador de Objetos encima del tipo de objeto que se quiere crear (en este caso se pulsa sobre el icono Forms) y se pulsa el botn CREATE del Navegador o bien NAVIGATOR -> CREATE (ver Figura 3). Se crea un nuevo objeto de tipo Forms al que hay que darle nombre. Para ello, se hace doble click sobre el icono del nuevo formato , apareciendo la ventana de sus propiedades. Hay que situarse en la propiedad Name y especificar el nombre COCHES.
Figura 3. Creacin de un nuevo formato. 3. Para crear un bloque por defecto se selecciona, en el navegador de objetos, el tipo Blocks dentro del formato creado y se pulsa de nuevo el botn CREATE. Aparecer la ventana de definicin de bloque nuevo (ver Figura 4). Ahora hay que rellenar los diferentes campos de esta ventana. Se selecciona la tabla asociada al bloque (COCHES) y se le asigna por defecto tambin como el nombre del bloque. 4. Dentro de la pestaa LAYOUT de la ventana de creacin de nuevo bloque se puede establecer la siguiente informacin: Records: sirve para especificar el nmero de tuplas de la tabla que aparecern a la vez en el formato, es decir, se especifica si el bloque va a ser mono o multiregistro (para este ejemplo se elige un bloque multiregistro de 5 tuplas). Integrity Constraints: especifica si Forms debe forzar las restricciones de integridad definidas cuando se cre la tabla base en el servidor Oracle (la activacin de este campo es muy til ya que cuando se producen violaciones de las restricciones establecidas en las tablas, los mensajes de error sern ms detallados).
77
Universidad de Jan
Button Palette: especifica si Forms debe crear una paleta por defecto de botones para el manejo en tiempo de ejecucin de los datos en el bloque. Scroll Bar: especifica si Forms debe crear una barra de scroll para el bloque que permita el movimiento entre los distintos registros del bloque. Si se selecciona esta opcin, la opcin Orientation determina si la barra de scroll se visualiza vertical u horizontalmente.
Figura 4. Ventana de Definicin de Bloque. En las opciones de la pestaa ITEMS se pueden seleccionar los atributos de la tabla que aparecern en el formato, de qu tipo es cada item y la etiqueta que se pondr encima de cada atributo. Por defecto se seleccionan todos los atributos, se coge el tipo definido al crear la tabla en el servidor y la etiqueta del item es el nombre del atributo en la tabla. 5. Como se ha terminado de definir el bloque se pulsa el botn OK para salir de la ventana de definicin de bloque, observando que en el navegador de objetos se ha creado una nueva entrada para el bloque recin creado y dentro de este bloque (se despliega pulsando sobre ) se han creado los correspondientes items para almacenar los valores de los distintos atributos de la tabla. 6. Para salvar el formato se utiliza la opcin FILE -> SAVE.
3.2. Manipulacin del formato

Una vez que creado el formato se pasa a su ejecucin. Durante la fase de diseo, esta ejecucin se realiza con la opcin FILE -> RUN, de modo que si se quiere modificar el formato repetidas veces, no sea necesario estar entrando y saliendo de Designer. Una vez que el formato est totalmente acabado, la opcin lgica es ejecutarlo desde el programa Runform, ya que el usuario del formato no ser su diseador y no suele ser conveniente que dicho usuario pueda modificar el formato. Una vez lanzado el formato, ste aparece en la pantalla vaco tal y como fue definido (ver Figura 5). Para trabajar con el formato se pueden utilizar tambin las teclas de funcin, pero en este caso no las teclas de funcin de modo diseo (las vistas anteriormente) sino las teclas de funcin en modo trabajo. Para mostrar en pantalla las teclas de funcin se utiliza la tecla Show Function Keys que para el PC bajo WINDOWS es la tecla CTRL + F1. Las operaciones que es posible realizar con el formato son las siguientes: 1. Insercin de tuplas: Para insertar tuplas en la tabla se van rellenando los items deseados (los que sean llave primaria sern obligados). Para pasar de un item a otro se utiliza la tecla Next Item y para cambiar de registro la tecla Next Record. Hay que tener en cuenta que no se procesar ningn cambio en la base de datos hasta que se pulse la tecla Accept (o el botn Save, si fue creada una paleta de botones).
Universidad de Jan
78
Figura 5. Formato en ejecucin.
2. Consulta: Para consultar la base de datos se utilizan dos teclas: Enter Query y Execute Query (se puede utilizar tambin el botn Query de la paleta de botones). Cuando se pulsa la tecla Enter Query (o el botn Query) aparece el bloque en blanco y se entra en el modo de consulta. Es posible realizar dos tipos de consultas en este momento: o bien una consulta a base de ejemplos o bien una tpica consulta SELECT con las clusulas WHERE y ORDER BY. Para realizar el primer tipo de consultas se sitan expresiones del tipo ">valor" o "pr%" en el item correspondiente. Este tipo de expresiones se pueden combinar situndolas en varios items (equivale al operador AND). Por ejemplo, para consultar aquellos coches de la marca RENAULT fabricados antes de 1990, se situara en el item MARCA el valor RENAULT y en el item AN_FAB la expresin <1990, como se muestra en la figura 6.
Figura 6. Consulta mediante ejemplos.
79
Universidad de Jan
Posteriormente se pulsa la tecla Execute Query (o el botn Query de nuevo), obteniendo el resultado de la consulta sobre el formato. La segunda forma de consultar la tabla es especificando una sentencia SELECT de SQL. Para ello se sigue el siguiente proceso: pulsar Enter Query y poner el smbolo & en cualquiera de los items. A continuacin se pulsa la tecla Execute Query, apareciendo una ventana solicitando la consulta. Se introduce la consulta que se desee realizar, pudindose utilizar en toda su extensin el comando SELECT. Finalmente se presiona OK, apareciendo el resultado de la consulta como en el caso anterior. Ejemplos de este tipo de consulta podran ser: Query Where?: order by marca (obtiene todos los coches ordenados alfabticamente por su nombre). Query Where?: mat NOT IN ( SELECT mat FROM trabajos t, mecanicos m WHERE t.dni=m.dni AND m.puesto='CHAPA'). Con esta consulta se obtendran los coches que no han sido reparados de CHAPA (ver Figura 7).
Figura 7. Consulta SQL.
3. Modificacin de tuplas: Para realizar una modificacin primero hay que buscar la informacin a modificar mediante la consulta correspondiente (punto 2). Una vez que se tiene la informacin visualizada se realizan las modificaciones oportunas. Finalmente se pulsa la tecla Accept (o el botn Save) para hacer permanentes en el servidor los cambios realizados. Para borrar una tupla se utiliza la tecla Delete Record y para aadir una nueva tupla o bien se accede al final de la tabla pulsando la tecla Next Record las veces que sea necesario, y se inserta la informacin, o bien pulsamos la tecla Insert Record.
Universidad de Jan
80
3.3. Creacin de un formato general

El formato que se ha creado en el punto anterior es muy limitado, ya que han sido utilizadas slo las caractersticas por defecto. La creacin de un formato general a medida se hace desde el LAYOUT EDITOR. Para acceder al LAYOUT EDITOR hay que situarse sobre algn bloque del navegador de objetos, pulsar el botn derecho del ratn y elegir, del men que aparece, la opcin Layout Editor (o directamente mediante TOOLS -> LAYOUT EDITOR). El LAYOUT EDITOR (editor de composicin), como su nombre indica, permite editar el aspecto del formato. Para ilustrar estos conceptos se va a modificar el formato anteriormente creado para dotarle de mayor funcionalidad. Las modificaciones a realizar son las siguientes: 1. Establecer el item MAT de forma que no pueda ser modificado accidentalmente: Hacer doble click sobre el item MAT. Aparece la ltima de la ventanas necesarias para el diseo de cualquier formato, la ventana PROPIEDADES. La ventana de propiedades visualiza las caractersticas, agrupadas por tipos, de los objetos seleccionados en el navegador de objetos o en el layout editor. Dentro de la ventana de propiedades se establece a TRUE las propiedades Primary Key y Required (no se puede pasar al siguiente campo si no se ha introducido un valor) y se pone a FALSE las propiedades Update Allowed (Actualizacin Permitida) (no se puede actualizar el valor una vez dado). El aspecto de la pantalla ser el indicado en la figura 8.
Figura 8. Especificacin de Propiedades en la definicin de un item.
81
Universidad de Jan
2. Acortar el tamao del item MARCA y poner la etiqueta Ao al item AN_FAB: Desde el LAYOUT EDITOR se pulsa sobre el item MARCA y se redimensiona utilizando los puntos indicadores. Esto no implica que no se puedan introducir valores de hasta 15 caracteres (como se especific en la creacin de la tabla), sino que slo aparecern a la vez los que quepan en el item de texto, pudiendo ver el resto utilizando las teclas Scroll Right y Scroll Left (cuando se est trabajando con el formato). Para cambiar la etiqueta al item AN_FAB, seleccionar el botn TEXT del layout editor y pulsar sobre la etiqueta que se desea cambiar, aparece un cursor que permite su modificacin. Esto tampoco significa que cambie el nombre del item, sino que aparecer un ttulo de columna ms amigable en el formato. 3. Establecer que la marca y el modelo de cada coche se introduce con letras maysculas, de forma que luego se puedan hacer bsquedas de forma ms fcil. Establecer a UPPER la propiedad Case Restriction para los items MARCA y MODELO.
Figura 9. Formato en ejecucin una vez modificado.
4. Aadir un nuevo item al formato que muestre la fecha actual. Crear un nuevo bloque llamado FECHA (de esta forma se independiza a la fecha de las acciones que se realicen sobre el bloque COCHES). Este bloque fecha no lleva asociada ninguna tabla y en la ventana de definicin de bloque se establece el campo SEQUENCE ID a 1 (indicando que este ser el primer bloque en el que entrar el cursor al ejecutar el formato). Se crea un item FECHA sobre el bloque FECHA anteriormente creado, estableciendo la propiedad Canvas (vista donde se visualizar) al mismo valor que tengan los items del bloque COCHES. El tipo de datos a asignar es DATE (propiedad Data Type). Para establecer que aparezca la fecha actual poner $$DATE$$ en la propiedad Default Value. Posteriormente, en el layout editor, se situa el nuevo item en la posicin deseada.
Universidad de Jan
82
5. Cambiar el nmero de tuplas que se visualizan a la vez (modo multiregistro), pasando de 5 a 7 tuplas, y establecer una ordenacin por defecto por el atributo MARCA de forma ascendente: Se asigna el valor 7 a la propiedad Records Displayed del bloque COCHES. Esto modifica el tamao de la visualizacin de los registros, pero no modifica el tamao de la barra de scroll ni la posicin de la paleta de botones. Estos cambios se deben hacer manualmente en el layout editor. Para establecer la ordenacin por defecto, la propiedad ORDER BY Clause del bloque COCHES debe valer MARCA ASC. Se vuelve ejecutar el formato, obteniendo el resultado mostrado en la figura 9.
4. Tipos de items
Hasta este momento slo se han utilizado uno de los tipos de items que FORMS proporciona para visualizar la informacin de la base de datos. Estos items se denominan text items ya que visualizan la informacin en forma de texto alfanumrico (un nombre, un nmero, una fecha, ...). Sin embargo existen otros tipos de informacin visualizables en los formatos (una imagen, un botn, un control VBX, ...) o bien otras formas de visualizar la informacin (mediante una lista, mediante un check box, mediante un radio group, ...). Cada una de estas posibilidades est relacionada con un tipo distinto de items. Los tipos de items fundamentales que nos proporciona FORMS son: text item: visualiza informacin en formato texto. radio group: visualiza un nmero fijo y arbitrario de opciones mutuamente excluyentes representadas mediante radio buttons (botones circulares). check box: control biestable que indica si un valor es verdadero o falso o si una condicin se cumple o no. list item: es una lista de elementos con formato texto. buttons: son items de interfaz que cuando son pulsados ejecutan comandos o inician otras acciones. A continuacin se va a detallar como definir un list item para visualizar las marcas de los coches, y un radio group y un check box para seleccionar, respectivamente, el puesto y el tipo de contrato de los mecnicos. En apartados posteriores se ver la definicin y funcionamiento de los items de tipo button.
4.1. List items

Los items de tipo list item permiten seleccionar el valor deseado para el item mediante la visualizacin de una lista esttica de valores. La lista de valores estar compuesta por un conjunto de elementos de lista, cada uno de los cuales tendr asociado un valor concreto que ser el que se almacenar en la base de datos o el que servir para identificar qu elemento de lista debe activarse cuando se recupera la informacin de la base de datos. Los pasos para la creacin de un item de tipo list item, en este caso para la visualizacin de los valores del item MARCA asociado al atributo MARCA de la tabla COCHES, son los siguientes: 1. Para crear un list item o bien se inserta desde el LAYOUT EDITOR seleccionando previamente el bloque al que se desea que pertenezca y seleccionando de la barra de herramientas la 83 Universidad de Jan
herramienta list item , seleccionando posteriormente la zona donde se inserta en nuevo list item, o bien, como sucede en el ejemplo del formato COCHES, se parte de un text item ya existente y se le redefine la propiedad item type con el valor LIST ITEM. 2. Una vez redefinido el tipo de item para el item MARCA, lo siguiente que hay que hacer es especificar los elementos que formarn la lista y el valor asociado a cada elemento. Para ello se hace doble click sobre la propiedad List Elements del item MARCA, apareciendo un cuadro de dilogo (ver figura 10) que permite especificar tanto los elementos que aparecern en la lista (List Elements) como el valor asociado a cada uno de ellos (List Item Value). Para este ejemplo, adems de especificar unas cuantas marcas, se define tambin el elemento de lista OTRA con valor OTRA, en previsin de la existencia de marcas de coches no especificadas en la lista.
Figura 10. Especificacin de los elementos de un List Item.
Figura 11. Formato con un List Item.
3. Existen tres tipos diferentes de list item en cuanto a su visualizacin, establecindose en la propiedad ListStyle: Poplist, Tlist y Combo box. Dependiendo del tipo elegido, la lista de elementos se visualizar de forma diferente. El estilo seleccionado para el ejemplo es poplist.
Universidad de Jan
84
4. Otra propiedad a especificar, sobre todo cuando es posible que en la base de datos existan valores no contemplados en la lista, es la propiedad Other Values, en la cual se especifica uno de los valores asociados a uno de los elementos de lista, indicando que cuando para ese item se recupere informacin no contemplada en ningn valor de la lista, el elemento de lista que debe activarse es el que se corresponde con el valor especificado en esta propiedad. Para el ejemplo, esta propiedad toma el valor OTRA, de esta forma, si al hacer alguna consulta sobre la base de datos se recupera un coche cuya marca no se encuentra en la lista, entonces el elemento de lista que se activa es OTRA. 5. Si se desea que por defecto al introducir datos est preseleccionado un elemento de la lista, la propiedad Default Value del item debe contener alguno de los valores asociados a los elementos de la lista. En la figura 11 se muestra un momento de la ejecucin del formato COCHES una vez definido el list item y cuando se est seleccionando la marca para un nuevo coche.
4.2. Radio group

Los items de tipo radio group permiten seleccionar y visualizar el valor de un item mediante un conjunto de botones circulares mutuamente excluyentes. El radio group estar compuesto por un conjunto de botones circulares (radio buttons), cada uno de los cuales tendr asociada tanto una etiqueta que figurar junto al radio button como un valor concreto que ser el que se almacenar en la base de datos o el que servir para identificar qu radio button debe activarse cuando se recupera la informacin de la base de datos. El ejemplo de definicin de un radio group, as como el que se ver en el apartado siguiente para el caso de un check box, se van a realizar sobre un formato para el acceso a la tabla MECANICOS. Las caractersticas de creacin de este formato son similares a las descritas en el apartado 6 para el caso de la tabla COCHES, teniendo en cuenta que en el caso del formato MECANICOS el bloque asociado a la tabla es monoregistro. El formato inicial creado por defecto tiene el aspecto que se muestra en la figura 12.
Figura 12. Formato por defecto para la tabla MECANICOS. Los pasos para la creacin de un item de tipo radio group, en este caso para la visualizacin de los valores del item PUESTO asociado al atributo PUESTO de la tabla MECANICOS, son los siguientes: 1. Para crear un radio group o bien se inserta desde el LAYOUT EDITOR seleccionando previamente el bloque al que se desea que pertenezca, y seleccionando de la barra de
85
Universidad de Jan
, seleccionando posteriormente la zona donde se herramientas la herramienta radio button inserta el nuevo radio button, o bien, como sucede en el formato MECANICOS, se parte de un text item ya existente y se le redefine la propiedad item type con el valor RADIO GROUP. 2. El siguiente paso es crear el nmero deseado de radio buttons. Para crear un radio button, se expande en el navegador de objetos el radio group creado, se selecciona el nodo radio buttons y se pulsa el botn CREATE. Esta opracin se repite tantas veces como opciones posibles se quieran aadir al radio group. Para el ejemplo se crean cuatro radio buttons. 3. Para cada radio button hay que establecer la etiqueta que figurar junto al radio button (propiedad label) as como el valor que representa ese radio button y que se asigna al item cuando dicho radio button est seleccionado (propiedad value). El tipo de los valores asignados a cada radio button debe ser compatible con el tipo de datos (CHAR, NUMBER, DATE, ...) asignado al radio group. Para el ejemplo tanto las etiquetas (label) como los valores (value) de cada radio button tienen los mismo valores que son: MOTOR, AMORTIGUACION, CHAPA y OTRO. 4. La propiedad other values del radio group permite gestionar la situacin que se produce cuando al recuperar informacin de la base de datos se obtiene un valor no contemplado en ningn radio button. Esta propiedad se debe dejar en blanco indicando que no estn contemplados otros valores, o bien se da la etiqueta o el valor de algn radio button que ser el que se activar al encontrarse un valor no contemplado. Para el ejemplo, como se ha definido un redio button que contempla precisamente esta posibilidad, el valor de la propiedad other values es OTRO. 5. La propiedad default value del radio group especifica el valor inicial del radio group, determinando el radio button inicialmente seleccionado. En la figura 13 se muestra el ejemplo de radio group para el atributo PUESTO de la tabla MECANICOS. Como se puede apreciar un radio button sirve para indicar un puesto diferente de MOTOR, AMORTIGUACION o CHAPA. Este radio button slo sirve para visualizar la informacin, ya que si lo que se desea es introducir un puesto distinto de los existentes, se necesitar otro item para indicar cul es el nombre de puesto concreto.
Figura 13. Ejemplo de radio group.
Universidad de Jan
86
4.3. Check box

Los items de tipo radio group permiten seleccionar y visualizar el valor de un item una casilla con dos posibles estados indicando un valor verdadero o falso o que se cumple una determinada condicin. Los pasos para la creacin de un item de tipo check box, en este caso para la visualizacin de los valores del item PARCIAL asociado al atributo PARCIAL de la tabla MECANICOS, son los siguientes: 1. Para crear un check box o bien se inserta desde el LAYOUT EDITOR seleccionando previamente el bloque al que se desea que pertenezca, y seleccionando de la barra de , seleccionando posteriormente la zona donde se inserta herramientas la herramienta check box el nuevo check box, o bien, como sucede en el formato MECANICOS, se parte de un text item ya existente y se le redefine la propiedad item type con el valor CHECK BOX. 2. Hay que establecer la etiqueta que figurar junto al check box (propiedad label) as como le valor que representa el check box cuando est activado (propiedad checked value) y cuando est desactivado (propiedad unchecked value) y que son asignados al item cuando el check box est activado o desactivado respectivamente. Para el ejemplo, cuando el check box est activado el valor es 1 y cuando est desactivado es 0. 3. La propiedad check box other values permite gestionar la situacin que se produce cuando al recuperar informacin de la base de datos se obtiene un valor no contemplado. Esta propiedad tiene tres posibles valores: NOT ALLOWED, indicando que no se permiten otros valores, CHECKED, que establece que cuando se obtiene un valor no contemplado se debe activar el check box, y UNCHECKED, indicando que un valor no contemplado desactiva el check box. Para el ejemplo, la opcin lgica es NOT ALLOWED. 4. La propiedad default value del check box especifica su valor inicial, determinando su estado inicial. En el ejemplo el valor por defecto es 0. En la figura 14 se muestra el resultado final del formato MECANICOS.
Figura 14. Ejemplo de check box.
87
Universidad de Jan
5. Listas de valores calculadas en tiempo de ejecucin

El problema fundamental que tienen los items de tipo list item es que los valores que aparecen en la lista se establecen en tiempo de diseo, cuando habitualmente los valores posibles pueden variar con el tiempo. En determinadas situaciones es bastante interesante poder obtener una lista de valores posibles para un determinado item en funcin de los valores almacenados en la base de datos. Es ms, puede ser interesante que en la lista se muestren no slo los valores posibles para el item, sino tambin informacin adicional. Las listas de valores (LOVs) se derivan de una estructura interna llamada grupo de registros (RECORD GROUP). Cuando se define una LOV, sta se asocia con un determinado record group que es creado simultneamente y de forma automtica por Designer. Un record group tiene una estructura similar a una tabla de la base de datos. Una LOV es el objeto interfaz que permite ver, realizar scroll y seleccionar los registros que estn almacenados en un momento determinado en el record group subyacente. Cuando se crea un objeto LOV, se especifica cules de las columnas del record group subyacente sern visualizadas en el LOV. Para establecer una lista de valores (LOV) asociada al item DNI del formato MECANICOS, lo primero que hay que hacer es crear un objeto de tipo LOV (de la misma forma que se invoca la creacin de cualquier objeto en FORMS). Aparece la ventana de creacin de LOV (ver Figura 15), en la que se debe especificar, mediante una sentencia SELECT, el conjunto de registros que se visualizarn en la lista.
Figura 15. Ventana de creacin de Lista de Valores. De esta forma se crea un objeto LOV y adems un objeto record group que es el que almacena los registros visualizados en el LOV. A estos nuevos objetos se les asignan nombres por defecto, que pueden ser cambiados en la correspondiente ventana de propiedades. Lo siguiente que hay que hacer es asociar el LOV creado a un determinado item del formato, de forma que cuando el cursor entre en ese item, aparezca el indicativo <list> en la ventana de ejecucin, proporcionando la posibilidad de pulsar la tecla List y visualizar la lista de valores. Para ello, hay que situarse en las propiedades del item DNI y establecer la propiedad LOV al identificativo del nuevo LOV creado (Designer muestra una lista de los LOV de que se dispone y se elige el creado anteriormente). Por ltimo, slo queda indicar dnde debe volcarse la informacin que se seleccione de la lista de valores. Esta informacin se establece en la propiedad Column Mapping del objeto LOV. Esta propiedad se especifica mediante un cuadro de dilogo (ver Figura 16) en el que se establece para cada atributo seleccionado en la definicin del LOV (Column Names), su tamao (en puntos) en la ventana del LOV (Display Width), la etiqueta del atributo (Column Title) y en qu item del formato se
Universidad de Jan
88
debe volcar la informacin seleccionada en el LOV (Return Item). Para el ejemplo, slo se va a volcar el DNI del mecnico, por lo que para el atributo NOMBRE se deja en blanco la propiedad Return Item. Como se puede apreciar en la figura 16, la forma en que se ha especificado en item de volcado para el atributo DNI es mediante el formato nombre_bloque.nombre_item. Aunque en el caso concreto de este formato no es necesario, y hubiera bastado con indicar slo el nombre del item DNI, la especificacin completa permite evitar ambigedades si existen ms bloques en el formato que contengan algn item con nombre DNI.
Figura 16. Definicin del mapeado de una lista de valores.
Figura 17. Lista de valores en ejecucin.
Otras caractersticas tiles que pueden ser especificadas son: 1. Ttulo de la ventana que muestra los valores: Propiedad Tittle del objeto LOV. 2. Posicin en pantalla (X,Y) de la ventana: Propiedades X Position e Y Position del objeto LOV.
En el ejemplo, en la ventana aparecern tanto los DNI como como los nombres de los mecnicos almacenados en la base de datos en el momento de solicitar la lista, haciendo de esta forma ms fcil la eleccin del DNI deseado. Universidad de Jan
89
Para que el usuario del formato se de cuenta de la nueva opcin introducida, se puede insertar una ayuda al item DNI que avise de que se puede usar la tecla List. Para ello, se pone a TRUE la propiedad Auto Hint del item DNI y en la propiedad Hint se introduce el texto que debe aparecer en la lnea de ayuda cuando el cursor entre en el item DNI (por ejemplo, Pulse la tecla LIST para ver los mecnicos de la base de datos). La forma en que aparece la lista de valores cuando se est ejecutando el formato es la mostrada en la figura 17.
6. Formatos Maestro - Detalle

Imagina que se quiere disear un formato que contenga para cada mecnico los trabajos que ha realizado. Este formato permitir consultar los trabajos de cada mecnico, introducir nuevos mecnicos con sus trabajos asociados y aadir nuevos trabajos a mecnicos ya existentes. Este formato contendr por tanto dos bloques, uno asociado a la tabla MECANICOS y otro asociado a la tabla TRABAJOS. Pero no interesa slo tener los dos bloques en el formato, sino que adems es necesario que estn relacionados, es decir, si se consulta un mecnico determinado deben aparecer de forma automtica todos los trabajos que ha realizado, y si se introduce un nuevo trabajo se asigne tambin automticamente al mecnico actual.
Figura 18. Creacin de Relacin Maestro-Detalle en creacin de nuevo bloque.
Como se puede apreciar no va a bastar con crear dos bloques normales, sino que se debe establecer alguna dependencia entre ellos. A esta dependencia existente entre el bloque de los mecnicos y el bloque de los trabajos se le denomina relacin Maestro-Detalle. En este caso, el bloque maestro sera el bloque MECANICOS y el bloque detalle sera el bloque TRABAJOS. Entre las tablas asociadas al Maestro y al Detalle debe existir una relacin llave primaria-llave externa, es decir, como la tabla de detalle contiene los detalles de cada tupla del maestro, es necesaria la existencia de una llave exterior en la tabla de detalle que indique a qu tupla del maestro se corresponde cada detalle. Para el ejemplo, este atributo comn llave primaria-llave externa es DNI. Existen dos formas de crear una relacin Maestro-Detalle en Oracle Forms: 1. Crear la relacin en la ventana de Nuevo Bloque al mismo tiempo que es creado el BLOQUE DETALLE de la relacin. Si se elige esta opcin, el BLOQUE MAESTRO debe estar ya creado. Para proceder a la creacin de la relacin, en la pestaa Master/Detail de la ventana de creacin de un nuevo bloque DETALLE, se elige el bloque MAESTRO en el campo Master Block (el botn Select muestra un LOV con los posibles bloques maestros). A continuacin se establece el campo Universidad de Jan
90
Join Condition especificando la condicin de unin que enlaza cada registro detalle con su correspondiente registro maestro (idntico al establecimiento de un JOIN en una consulta SELECT con varias tablas). Si el bloque maestro se ha elegido a travs del botn SELECT, entonces el campo Join Condition se establece automticamente. Para el ejemplo, una vez creado el bloque MECANICOS, la pestaa Master/Detail de la ventana de creacin del bloque detalle TRABAJOS quedara como se ve en la figura 18. La creacin de este objeto bloque implica adems la creacin de un objeto relation y objetos trigger (disparadores) a nivel de bloque y a nivel de formato. Estos disparadores contienen el cdigo que permite sincronizar los dos bloques implicados en la relacin.
2. La segunda forma consiste en insertar una nueva relacin bajo el nodo Relations (del navegador de objetos) del apropiado BLOQUE MAESTRO. Si se elige esta opcin, tanto el BLOQUE MAESTRO como el BLOQUE DETALLE deben estar creados. Aparece la ventana de Nueva Relacin (Figura 19.) en la que se debe establecer el nombre de la nueva relacin, el bloque maestro, el bloque detalle y la condicin de unin.
Figura 19. Creacin de un nuevo objeto Relation.
Dos propiedades importantes de los objetos Relation son: Master Deletes: Especifica cmo debe afectar el borrado de un registro en el bloque maestro a los registros del bloque detalle. Los posibles valores de esta propiedad son: Non-Isolated (el valor por defecto): previene el borrado de un registro maestro cuando existen en la base de datos registros detalle asociados. Isolated: permite borrar un registro maestro sin afectar a los registros detalle asociados. Cascading: permite que se borre un registro maestro y automticamente son borrados todos los registros detalle. En una relacin maestro-detalle-detalle, donde las relaciones estn anidadas, slo son borrados los registros del primer bloque detalle. Coordination: Establece cundo son visualizados los registros en el bloque detalle. Por defecto, cuando ocurre cualquier evento sobre el bloque maestro, los registros del bloque detalle son actualizados.
91
Universidad de Jan
Una vez que se ha creado la relacin entre los dos bloques, sta puede ser cambiada en cualquier momento. Cuando se cambian las propiedades Master Deletes o Coordination de una relacin existente, Oracle Forms aade, borra o modifica los disparadores (TRIGGERS) que sean necesarios. Una vez realizadas las modificaciones oportunas en el LAYOUT EDITOR y generado el formato, el aspecto de su ejecucin es el mostrado en la figura 20.
Figura 20. Relacin Maestro-Detalle en ejecucin.
UN DETALLE IMPORTANTE A TENER EN CUENTA es que, como se puede apreciar, en el bloque detalle no se visualiza el item DNI, sin embargo el item s existe, slo que automticamente se define de forma que no se visualice en pantalla (propiedad Displayed) cuando se est ejecutando el formato si se ha creado la relacin segn lo visto en el primer mtodo. A la hora de la ejecucin y debido a la existencia de ms de un bloque en pantalla, es necesario utilizar la teclas Next Block y Previous Block para desplazarse de un bloque a otro, de igual forma que se utilizaban las teclas Next Field y Previous Field para moverse entre los distintos items de un determinado bloque. Mediante el mecanismo Maestro-Detalle FORMS genera el cdigo necesario para: coordinar las consultas entre los bloques establecer el JOIN entre la tabla maestro y la de detalle establecer el comportamiento cuando se borran tuplas de la tabla maestro
Universidad de Jan
92
hacer que los bloques maestro visualicen las tuplas detalle asociadas establecer la propiedad Copy Value From Item del atributo que acta como llave externa al valor del atributo al que referencia. Prcticamente no existen limitaciones respecto al nmero de relations que pueden ser creadas en un formato. Cualquier bloque puede ser maestro o detalle en ms de una relation, y un bloque que es maestro en una relation puede ser el detalle en otra relation. Cuando se crean relaciones maestrodetalle complejas, Forms ajusta automticamente los disparadores existentes para controlar las relations definidas. Los tipos ms comunes de relaciones maestro-detalle complejas son: maestro con varios detalles dependientes, maestro con varios detalles independientes y detalle con dos maestros.
7. Aadiendo cdigo Disparadores
la
aplicacin:
PL/SQL
En este apartado se va a introducir el concepto de Disparador dentro de FORMS, fundamental como ya hemos visto dentro del mundo de las bases de datos y bsico tambin en la filosofa de trabajo de Oracle FORMS. De forma intuitiva, se entiende por disparador un conjunto de acciones, escritas en un lenguaje concreto, asociadas a la manifestacin de un determinado evento sobre un determinado elemento de informacin de la base de datos o de la aplicacin. El disparador se ejecutar cuando dicho evento suceda en el sistema. Los usos habituales de los disparadores dentro de FORMS son: comprobar la validez (restricciones de integridad complejas) de un determinado item del formato. En este caso el elemento de informacin sera el item, y el evento a controlar su insercin o modificacin. El disparador se encargara de comprobar la validez del item una vez que se haya introducido informacin en l o se haya modificado la ya existente. En el caso de que el valor introducido no fuese vlido, el disparador contendra las acciones oportunas a realizar. realizar determinadas operaciones asociadas a un bloque de informacin superior, como por ejemplo, comprobar la correccin del borrado de una determinada tupla y la realizacin de las acciones oportunas (borrado de las tuplas que la referencian). establecer qu es lo que debe suceder cuando se pulsa una determinada tecla, pudiendo de esta forma deshabilitar determinadas teclas o darles una funcionalidad distinta a la asignada por defecto. especificar las acciones a relizar cuando se pulsa un botn del formato. Antes de la versin 3 de SQL*FORMS los disparadores se escriban a base de sentencias SQL y macrocomandos de SQL*FORMS, a partir de la versin 3 los disparadores se escriben en PL/SQL. Cuando se activa el disparador, se ejecuta el grupo de sentencias PL/SQL que constituyen el texto del disparador. Se pueden colocar diversos disparadores a cualquiera de los tres niveles de un formato (formato, bloque e item). Para ejecutar un disparador, RUNFORM busca el item activo, luego el bloque activo y despus el formato activo para el disparador especfico que se vaya a ejecutar. Se pueden tener tres disparadores diferentes con el mismo nombre, cada uno de ellos en cada nivel del formato. Cuando se arranca un formato, lo primero que hace el cursor es entrar en el formato, en su primer bloque y en el primer item de entrada de datos de ese bloque.
93
Universidad de Jan
La adicin de disparadores a la estructura del formato aporta una gran versatilidad al mismo. Por ejemplo, el efecto de pulsar una tecla de funcin ser siempre el mismo si se pulsa desde un item; con disparadores, sin embargo, una tecla de funcin se puede redefinir de tal forma que realice diferentes funciones para cada item o bloque, o se puede realizar deteccin de errores y validacin de datos basados en el movimiento del cursor. Los disparadores pueden extraer informacin del formato y bifurcar condicionalmente a localizaciones especficas dentro del formato. Los disparadores hacen ms complejo el control, ya que la siguiente accin que tomar el formato depende de la condicin actual del formato, los datos introducidos, el item en el que se encuentre el cursor y la tecla que ha sido pulsada. Los disparadores ofrecen al usuario la posibilidad de controlar perfectamente el movimiento del cursor y procesarlo dentro del formato.
7.1.
Referencias a objetos: objetos de la parte cliente y objetos de la parte servidor de la aplicacin
Las aplicaciones que se estn desarrollando tienen dos partes claramente diferenciadas. Por una parte esta la porcin servidor, residente en el servidor Oracle, consistente en un conjunto de tablas y vistas con sus datos y cdigo correspondientes. Y por otra parte est la porcin cliente, residente en el PC y ejecutada por RunForm, consistente en un conjunto de formatos, bloques e items, relacionados uno a uno, en algunos casos, con objetos (tablas, atributos, ...) de la porcin servidor. Esto implica que a la hora de aadir cdigo a la aplicacin en algunos casos habr que referenciar objetos del servidor y en otros casos objetos de la parte cliente. El acceso a la base de datos (residente en el servidor) se realiza a travs de comandos SELECT que son enviados por la porcin cliente, resueltos por el servidor que a su vez devuelve los resultados al cliente (un formato) para que este lo situe en los correspondientes bloques e items. Por tanto las consideraciones a este respecto a tener en cuenta son: para referenciar a un item concreto dentro de un bloque, se utiliza la notacin: :nombre_bloque.nombre_item: dentro del cdigo PL/SQL. nombre_bloque.nombre_item: cuando se utiliza en algn sitio que no sea cdigo PL/SQL, por ejemplo en las condiciones JOIN al crear un formato maestro-detalle. dentro de Oracle FORMS (lenguaje PL/SQL), la sentencia SELECT se ve modificada pudiendo admitir una clusula adicional INTO item [, item, ...]. Esta clusula se utiliza para indicar que el resultado de la sentencia SELECT (ejecutada en el servidor) se vuelque en un determinado item de un bloque (perteneciente al cliente). Por ejemplo: SELECT nombre INTO :mecanicos.nombre FROM mecanicos WHERE dni = 1111; Esta sentencia SELECT, puesta en el lugar adecuado, introducir en el item NOMBRE del bloque MECANICOS el nombre del mecnico con dni 1111.
Universidad de Jan
94
7.2. Tipos de Disparadores

Bsicamente los disparadores se agrupan en: disparadores de acontecimiento, disparadores transaccionales, disparadores de tecla, disparadores de eventos de interfaz, y disparadores de usuario. Los disparadores de acontecimiento se activan cuando se producen eventos propios de Oracle FORMS como el movimiento del cursor o la entrada en modo de consulta. Estos disparadores se asocian a niveles especficos dentro de un formato, tal y como se puede apreciar en la tabla 1, donde se muestran algunos de los disparadores ms tiles y su significado: Tabla 1. Disparadores de acontecimiento. Disparadores de FORMATO Pre- Form Se ejecuta antes de entrar en el formato. Post- Form Se ejecuta al salir de un formato. When-New-Form-Instance Se ejecuta justo despus de navegar al primer item del primer bloque del formato. Muy til para inicializar variables globales o ejecutar consultas por defecto sobre el formato. Disparadores de BLOQUE Pre-Block Se ejecuta antes de pasar al bloque. Post-Block Se ejecuta al dejar el bloque. When-New-Block-Instance Se ejecuta justo despus de navegar al primer item del bloque viniendo de otro bloque. Pre-Query Se ejecuta tras iniciar el proceso de ejecucin de una consulta y antes de que Oracle empiece a procesar la consulta. Post-Query Se ejecuta una vez para cada registro devuelto por la consulta e insertado en el bloque. Muy til para calcular estadsticas u operaciones sobre los registros devueltos por la consulta. Pre-Record Se ejecuta antes de entrar en un nuevo registro del bloque. Post-Record Se ejecuta tras dejar un registro del bloque. Disparadores de ITEM Pre-Text-Item Se ejecuta antes de entrar en el item de texto. Post- Text-Item Se ejecuta al salir del item de texto. Post-Change Se ejecuta cuando el valor de un item de texto cambia. When-New-Item-Instance Se ejecuta cuando el cursor se mueve al item. When-Checkbox-Changed Se ejecuta cuando cambia el estado del checkbox. When-Radio-Changed Se ejecuta cuando se activa un radio button diferente del que estaba activado.
Para comprender la funcin de los disparadores de acontecimiento, se puede imaginar que se est siguiendo la pista al cursor mientras se mueve dentro del formato. Cuando se arranca el formato, el cursor se introduce situndose a nivel de formato, desencadenando la ejecucin de el disparador
95
Universidad de Jan
pre-form. Cuando se supera esta etapa, el cursor intenta entrar en el primer bloque, desencadenando la ejecucin del disparador pre-block. Lo mismo sucede para el primer item, activando el disparador pre-text-item. Cuando se van abandonando los distintos niveles se ejecutan los disparadores post asociados. Disparadores Transaccionales: Para el nivel de bloque existen adems una serie de disparadores asociados a la aceptacin de transacciones y se ejecutan tras la pulsacin de la tecla Accept. Estos disparadores a nivel de bloque se ejecutan slo cuando se van a reflejar en la base de datos los cambios producidos en los registros del bloque. En la tabla 2 se describen brevemente estos disparadores. Tabla 2. Disparadores transaccionales. Disparadores Transaccionales Se ejecuta antes de que una tupla sea borrada. Se dispara una vez para cada registro del bloque que se vaya a borrar. Se ejecuta despus de que una tupla sea borrada. Se dispara una vez para cada registro del bloque que se ha borrado. Se ejecuta antes de que una tupla sea insertada. Se dispara una vez para cada registro del bloque que se va a insertar. Se ejecuta despus de que una tupla sea insertada. Se dispara una vez para cada registro del bloque que se a insertado. Se ejecuta antes de que una tupla sea actualizada. Se dispara una vez para cada registro del bloque que se vaya a actualizar. Se ejecuta despus de que una tupla sea actualizada. Se dispara una vez para cada registro del bloque que se ha actualizado.
Pre-Delete Post-Delete Pre-Insert Post-Insert Pre-Update Post-Update
Figura 21. Disparadores almacenados. Aunque Forms proporciona estos disparadores para el control de las transacciones que se efectan contra el servidor Oracle, en la mayora de los casos es ms conveniente tener declarados y almacenados este tipo de disparadores en la propia base de datos como otro objeto ms relacionado con una tabla concreta (como se vio en el captulo anterior). De esta forma el disparador va a ser independiente de la aplicacin y se va a ejecutar siempre sin tener en cuenta desde dnde se est accediendo a la tabla. Como ya vimos, estos disparadores se pueden crear desde SQL*Plus como otro objeto cualquiera de la base de datos utilizando el comando SQL CREATE TRIGGER, aunque Forms proporciona un cuadro de dilogo que permite de igual forma crear el disparador y almacenarlo en la base de datos de una manera ms uniforme al estilo Forms. Para acceder a este cuadro de dilogo (previa conexin al servidor Oracle) se debe abrir
Universidad de Jan
96
desde el navegador de objetos la categora Database Objects que muestra en primer momento los usuarios a los que se tiene acceso. Expandiendo el objeto que representa al usuario concreto, aparecen las categoras en que se agrupan los distintos objetos del usuario (tablas, vistas, ...). Como los disparadores almacenados en la base de datos estn relacionados con una tabla concreta, se deben expandir la categora tables y posteriormente la tabla concreta a la que se le quiere crear el disparador, apareciendo la categora triggers. Como otro objeto Forms cualquiera para proceder a su creacin se pulsa el botn CREATE, apareciendo el cuadro de dilogo antes mencionado y cuyo aspecto es el mostrado en la figura 21. Disparadores de Tecla: estos disparadores se pueden utilizar para reprogramar las acciones de una tecla de funcin determinada. Evidentemente, la tecla puede ser redefinida en distintos niveles del formato, por lo que hay que estar situado en el nivel en el cual el disparador ha sido definido para poder activarlo. Estos disparadores se utilizan normalmente para cambiar la accin de una determinada tecla de funcin que se use en la ejecucin de un formato, o incluso para desactivarla. En la tabla 3 se muestra informacin sobre las diferentes teclas que se pueden utilizar:
Nombre Tecla KEY-CLRBLK KEY-CLRFRM KEY-CLRREC KEY-COMMIT KEY-CQUERY KEY-CREREC KEY-DELREC KEY-DOWN KEY-DUP-ITEM KEY-DUPREC KEY-ENTQRY KEY-EXEQRY KEY-EXIT KEY-Fn KEY-HELP KEY-LISTVAL KEY-MENU KEY-NXTBLK KEY-NXT-ITEM KEY-NXTKEY KEY-NXTREC KEY-NXTSET KEY-OTHERS KEY-PRVBLK KEY-PRV-ITEM KEY-PRVREC KEY-CSRDOWN KEY-SCRUP KEY-UP
Tabla 3. Disparadores de tecla. Descripcin Limpiar bloque Limpiar formato/Vuelta atrs Limpiar registro Aceptar transaccin Contar consultas Crear registro Borrar registro Siguiente registro, primer registro Duplicar item Duplicar registro Introducir consulta Ejecutar consulta Salir/Cancelar Tecla de funcin Fn Ayuda Listar valores de items Bloque de men Siguiente bloque Siguiente item Siguiente item de clave primaria Siguiente registro Siguiente conjunto de registros Se aplica a todas las teclas no definidas especficamente Bloque previo Item previo Registro previo Desplazar hacia abajo Desplazar hacia arriba Registro previo, mismo item
97
Universidad de Jan
Disparadores de Eventos de Interfaz: Son disparadores asociados a eventos relacionados con la interfaz grfica utilizada por la aplicacin. Algunos ejemplos de estos disparadores se muestran en la tabla 4:
When-Button-Pressed When-Mouse-Click When-Window-Resized ...
Tabla 4. Disparadores de acontecimiento. Cuando se pulsa un botn del formato Cuando se pulsa el ratn Cuando se redimensiona una ventana
Disparadores de usuario: Son disparadores que no estn asociados ni a una tecla en concreto ni a un determinado evento. Se les asigna un nombre y luego pueden ser llamados desde otros disparadores utilizando la orden EXECUTE_TRIGGER().
Tabla 5. Procedimientos empaquetados. Nombre Descripcin Bell; Hace sonar un pitido. Call_Form(nombre_formato); Ejecuta un nuevo formato, conservando el formato anterior activo. Clear_block/item; Limpia el bloque/item activo. Copy(fuente,destino); Escribe un valor en un item. Equivale a :bloque.item := valor;. Erase(nombre_variable_global); Borra la variable global indicada. Execute_Trigger(nombre_disparador) Ejecuta un disparador de usuario. ; Execute_query; Ejecuta la consulta. Exit_Form; Abandona el formato actual. Go_Block('nombre_bloque'); Mueve el cursor al bloque indicado. Si el bloque no tiene items input ocurrir un error. Go_Item('nombre_item'); Mueve el cursor al item indicado. Host(cadena_comando_sistema); Ejecuta el comando del sistema indicado. Message(mensaje); Muestra el mensaje en la lnea de ayuda (hasta 72 caracteres). New_Form(nombre_formato) Borra el formato activo y lo sustituye por el formato indicado. Pause; Suspende el proceso hasta que el operador presione una tecla de funcin. enva un mensaje de aviso. Next/Previous-Block/Item; Mueve el cursor al siguiente/anterior bloque/item.
Universidad de Jan
98
7.3. El lenguaje de los disparadores: PL/SQL

El cdigo de los disparadores se escribe en el lenguaje propio de Oracle PL/SQL. Aunque en el captulo anterior ya se estudi este lenguaje, a continuacin se muestra un breve resumen de algunas de las carctersticas de PL/SQL a la hora de escribir los disparadores propios de FORMS. Hay que recordar que a los items de un determinado bloque del formato se les referencia de la siguiente forma dentro del cdigo PL/SQL: :nombre_bloque.nombre_item
Una sentencia interesante es la sentencia NULL. Esta sentencia no hace nada, pero puede servir, por ejemplo, para desactivar una tecla determinada. Los procedimientos empaquetados son procedimientos propios de FORMS (no de PL/SQL) y pueden ser ejecutados dentro de bloques PL/SQL que definan disparadores. La forma de utilizarlos es como si se tratara de una sentencia de PL/SQL, es decir, poniendo su nombre y terminando en punto y coma. En la tabla 5 se listan algunos de los procedimientos empaquetados que se pueden utilizar. Dentro del cdigo de un disparador FORMS se dispone de tres tipos de variables: Variables Locales PL/SQL: Se declaran en la parte DECLARE del bloque PL/SQL. Slo estn activas en los bloques de PL/SQL. Variables Globales: Van precedidas del prefijo :global. Estas variables estn activas en cualquier disparador del formato durante la sesin de trabajo. Para utilizarlas se deben inicializar previamente de la siguiente forma: :global.nombre_var := valor; Se puede borrar una variable global activa mediante el procedimiento ERASE. Estas variables se suelen utilizar para guardar informacin que no se quiere almacenar en un bloque o que se desea utilizar en otros formatos en la misma sesin. Suelen ser muy tiles para intercambiarse informacin entre distintos formatos. Las variables globales son de tipo texto, por lo que para utilizarlas como parmetros en funciones u operaciones que requieren un valor de otro tipo hay que utilizar las funciones de conversin como TO_NUMBER() o TO_DATE(). Variables del sistema: Son propias del sistema y almacenan informacin sobre el estado interno de Oracle FORMS. En la tabla 6 se indican algunas de las variables del sistema. Tabla 7. Algunas variables del sistema. Descripcin Recoge la fecha del sistema. Recoge la hora del sistema. Recoge el estado del bloque actual: Changed (algn registro modificado), New (slo registros nuevos) o Query (registros recuperados de la Base de Datos). Almacena el nombre del formato que se est ejecutando. Devuelve el nombre del bloque donde est el cursor. Devuelve el nombre del bloque.item donde est el cursor. Contiene el valor del item donde est el cursor. Devuelve el estado del formato donde est el cursor: Changed, New o Query.
Nombre $$date$$ $$time$$ :system.block_status
:system.current_form :system.cursor_block :system.cursor_item :system.cursor_value :system.form_status
99
Universidad de Jan
7.3.1.
Ejemplos de disparadores FORMS
En esta seccin se van a estudiar una serie de ejemplos que muestran algunas posibilidades de los disparadores. Considerar el formato que se propuso de ejemplo al final del apartado 6 (relacin Maestro - Detalle). Para dotarle de mayor funcionalidad en primer lugar se aaden los siguientes items (utilizando, por ejemplo, la herramienta TEXT ITEM del LAYOUT EDITOR):
TOTAL_TRABAJOS (dentro del bloque de MECANICOS): es un item de tipo NUMBER y NO pertenece a la tabla. PRECIO (dentro del bloque de TRABAJOS): es un item de tipo NUMBER y NO pertenece a la tabla. Este item almacena el precio por hora de trabajo en funcin de la fecha de reparacin. MARCA y MODELO (dentro del bloque de TRABAJOS): son items de tipo CHAR y NO pertenecen a la tabla base del bloque (ya que pertenece a la tabla COCHES). TOTAL_COCHE (dentro del bloque de TRABAJOS): es un item de tipo NUMBER y NO pertenece a la tabla. Recoger el precio de la reparacin de cada trabajo realizado (calculado como PRECIO * HORAS).
Figura 22. Formato con nuevos items.
Como los bloques estn asociados a sus tablas respectivas de la base de datos, entonces cualquier nuevo item aadido se crea con la propiedad Base Table Item a TRUE. Esto significa que cuando se produzca una consulta sobre la base de datos, o cuando se intente insertar informacin en la misma, Forms va a enviar el valor que tenga dicho item como si se tratara de un atributo ms de la tabla subyacente. Por tanto, como los items anteriormente aadidos no pertenecen a las tablas asociadas a los bloques del formato, deben tener la propiedad Base Table Item a FALSE. Otra caracterstica til es evitar que el cursor entre en estos nuevos items creados, ya que la informacin que contienen se va a calcular en funcin de los valores existentes en otros items. Para ello se establece la propiedad Navigable a FALSE. Universidad de Jan 100
Es interesante que los valores de los campos total_trabajos y total_coche, al almacenar informacin numrica, aparezcan alineados a la derecha y con un formato numrico de dos cifras digitales. Esto se consigue estableciendo la propiedad Aligment a RIGTH y la propiedad Format Mask a 999999.99. La imagen del formato una vez modificado ser la mostrada en la figura 22. 1. Disparador para la visualizacin de los items MARCA y MODELO. Si se ejecuta el formato tal y como est y se efectua una consulta, se aprecia que como los nuevos items introducidos no pertenecen a la base de datos, sino que pertenecen al formato, no se rellena la informacin. Es necesario por tanto crear los disparadores que hagan que automticamente se rellene esa informacin.
Figura 23. Definicin de un disparador.
La creacin de un disparador es semejante a la creacin de cualquier objeto Forms. Los pasos a dar para crear el disparador asociado al item MAT del bloque TRABAJOS que permita la visualizacin de la marca y el modelo de cada coche reparado, son los siguientes: 1. Hay que situarse en el nodo Triggers del item DNI del bloque TRABAJOS. Pulsar el botn CREATE. 2. Seleccionar el nombre del disparador de entre la lista de valores que aparece en pantalla: Seleccionar el disparador POST-CHANGE, ya que este tipo de disparador se ejecuta cuando cambia el contenido del item al que va asociado. 3. Rellenar el texto del disparador. En este caso hay que escribir una sentencia SELECT INTO que devuelva la marca y el modelo del coche cuya matrcula es la almacenada en el item MAT del bloque TRABAJOS. Habr que controlar el hecho de que se introduzca una matrcula de un coche inexistente (aunque esto ya se puede controlar mediante una restriccin de integridad referencial) con la correspondiente excepcin. El bloque PL/SQL podra ser: BEGIN SELECT marca, modelo INTO :trabajos.marca,:trabajos.modelo FROM coches WHERE mat=:trabajos.mat;
101
Universidad de Jan
Programacin de Bases deDatos Oracle EXCEPTION WHEN no_data_found THEN /* si el SELECT no devuelve nada */ MESSAGE(El coche no existe); RAISE form_trigger_failure; END;
4. Una vez introducido el texto del disparador se pulsa el botn COMPILE lo que desencadenar la compilacin del disparador, indicando los posibles errores si es que los hay. La pantalla de definicin de disparador tendr el aspecto mostrado en la figura 23. 2. Disparador para el clculo de los items PRECIO y TOTAL_COCHE y para la actualizacin del item TOTAL_TRABAJOS. Utilizar un disparador POST-CHANGE asociado al item FECHA_REP. El PRECIO es 1000 pts/hora para el ao 1996, aumentndose en un 5% cada ao. TOTAL_COCHE se calcula como el resultado de multiplicar los valores de los items PRECIO y HORAS. El valor inicial del item TOTAL_TRABAJOS se obtiene con un disparador POST_QUERY que ser posteriormente explicado. Pero como los cambios efectuados a TOTAL_COCHE afectan a TOTAL_TRABAJOS, entonces es necesario aadir al disparador descrito a continuacin el cdigo necesario para mantener en todo momento este item con su valor correcto. El disparador que se debe crear tiene las siguientes caractersticas: Nombre: Bloque: Item: Texto: POST-CHANGE (se dispara tanto al insertar como al consultar las horas). TRABAJOS FECHA_REP
DECLARE ant_total_coche number:=0; BEGIN :trabajos.precio:=1000*power(1.05,to_number( substr(to_char(:trabajos.fecha_rep),8))-96); IF :trabajos.total_coche <> 0 THEN /* hay que guardar valor antiguo */ ant_total_coche := :trabajos.total_coche; END IF; :trabajos.total_coche:=:trabajos.horas*:trabajos.precio; /* actualizacin de total_trabajos */ IF :system.mode<>'QUERY' THEN IF ant_total_coche <> 0 THEN /* hay que restablecer el valor antiguo */ /* restar la cantidad anterior */ :mecanicos.total_trabajos:=:mecanicos.total_trabajosant_total_coche; /* sumar la nueva cantidad */ :mecanicos.total_trabajos:=:mecanicos.total_trabajos+ :trabajos.total_coche; ELSE /* nuevo registro */ :mecanicos.total_trabajos:=:mecanicos.total_trabajos+ :trabajos.total_coche; END IF; END IF; END;
Universidad de Jan
102
3. Disparadores para el clculo del item TOTAL_TRABAJOS. Utilizar un disparador de tipo POST-QUERY asociado al bloque TRABAJOS. Este disparador se ejecuta una vez por cada registro devuelto por la consulta. Para la inicializacin del item se utiliza un disparador PRE-QUERY. Nombre: PRE-QUERY (se dispara antes de consultar el bloque). Bloque: TRABAJOS Texto: begin :mecanicos.total_trabajos:=0; end; Nombre: POST-QUERY (se dispara una vez para cada registro devuelto al consultar). Bloque: TRABAJOS Texto: begin :mecanicos.total_trabajos:= :mecanicos.total_trabajos + :trabajos.total_coche; end;
Despus de realizar una consulta debera aparecer toda la informacin como se muestra en la figura 24.
Figura 24. Formato con disparadores tras una consulta.
4. Disparador para manejo de un item de tipo botn y movimiento dentro del formtato. Se pretende crear un formato que permita introducir una marca y mostrar slo los coches de esa marca. Para su realizacin debe crearse un nuevo formato al que se le aadir un bloque de control nuevo, llamado CONTROL, que contenga un item, llamado MARCA, que recoger la marca de la que se quiere hacer la consulta y un botn que active la consulta (para insertar el botn se del LAYOUT EDITOR). Asociado al botn se puede utilizar la herramienta PUSH BUTTON debe crear un disparador WHEN-BUTTON-PRESSED que se activar cuando se pulse sobre el botn. El cdigo del disparador debe consistir en tres pasos: ir al bloque donde se visualizan los coches (GO_BLOCK('COCHES');), ejecutar consulta (EXECUTE_QUERY;) y volver al bloque
103
Universidad de Jan
donde se toma la marca (GO_BLOCK('CONTROL');). Para que cuando se llame al procedimiento que ejecuta la consulta, slo se obtengan los coches de la marca introducida, se debe establecer la propiedad WHERE clause del bloque COCHES como marca = :control.marca de esta forma cuando se invoca el procedimiento empaquetado EXECUTE_QUERY slo se seleccionan aquellas tuplas de la tabla COCHES cuya marca sea la introducida en el item MARCA del bloque CONTROL. El aspecto de este formato al ejecutarse es el mostrado en la figura 25.
Figura 25. Coches por marca.
Universidad de Jan
104
8. Creacin de MENS
Cualquier formato se ejecuta o bien sin ningn men, o con el men por defecto o con un men definido por el usuario. Est men es un mdulo separado que se enlaza al formato en tiempo de ejecucin. En el momento de la ejecucin, una aplicacin slo puede tener un men activo en un momento determinado. El men por defecto es parte del formato, pero los mens definidos por el usuario, sin embargo, son mdulos separados. Por tanto, cuando se disee una aplicacin con un nico formato que usa un nico men, se debern proporcionar dos ficheros ejecutables: un .FMX para el formato y un .MMX para el men. En una aplicacin con varios formatos podrn utilizarse varios formatos as como varios mens. Varios formatos pueden compartir el mismo men o bien cada formato puede invocar a un men diferente. El men por defecto incluye los comandos estndard para la navegacin, edicin e interaccin con la base de datos. Para construir un men a medida, primero se crea un objeto de tipo MENU y posteriormente se definen los objetos que va a contener el men. De igual forma que los objetos de los formatos, los objetos de los mens tienen propiedades que definirn su funcionalidad una vez que se est ejecutando el men. Un men incluye los siguientes objetos: El mdulo del men en s. Mens: el men principal, mens individuales y submens. Items de men en cada mens individual y sus comandos asociados. Cada mdulo de men contiene uno o ms mens. Cada men contiene uno o ms items de men. Los mens que se van a disear son los tpicos mens pull-down. Un men pull-down standard consiste en tres niveles: El men principal: se visualiza horizontalmente y contiene items que consisten en ttulos de mens individuales. Mens individuales: se visualizan verticalmente y o bien ejecutan comandos o invocan a otros submens. Submens: se visualizan verticalmente a la derecha de un item de men y proporcionan elecciones adicionales relacionadas con un item de un men individual.
El diseo habitual de un menu pull-down incluye una barra de men (men principal), mens individuales y un nico nivel de submens. En la figura 26 se muestra un tpico diseo de men pulldown para el taller mecnico. El men principal sera el formado por los items de men DATOS, TRABAJOS y TERMINAR, el men formado por los items MECANICOS y COCHES sera un men 105 Universidad de Jan
individual y, por ltimo, el men formado por los items TODOS y POR MARCA sera un submen.
Figura 26. El editor de mens.
Para la creacin de un men como el de la figura 26 se han de seguir los siguientes pasos:
1. En el navegador de objetos hay que crear un nuevo objeto de la categora men. Una vez creado se le asigna el nombre de igual forma que se haca para los formatos.
2. Usando el EDITOR DE MENS se crea el men principal, los mens individuales y los items de men: Para acceder al EDITOR DE MENS se hace doble click sobre el icono correspondiente al nuevo objeto men creado. Inicialmente el men aparece con un nico item. En este men se aadirn los items que formarn el men principal. Este proceso se realiza repitiendo tantas veces como sea necesario el siguiente proceso: Se le asigna un nombre al item: se pulsa encima de <new_item> y se teclea el nombre para ese item de men. Se pulsa el botn CREATE RIGHT la derecha al men. del EDITOR DE MENS para aadir un nuevo item a
Para crear un men individual (pop-up) slo hay que situarse sobre el item del men principal que . Para aadir ms elementos a un men lo vaya a activar y pulsar el botn CREATE DOWN individual se realiza el mismo proceso descrito anteriormente sustituyendo la pulsacin de CREATE RIGHT por pulsaciones de CREATE DOWN ya que los items de los mens individuales crecen hacia abajo. Para crear un submen asociado a un item determinado de un men individual, slo hay que situarse en el item del men individual y pulsar CREATE RIGHT, lo que crea el submen con un item inicial. Para aadir ms items a este submen se sigue el mismo proceso que para aadir a un men individual.
Universidad de Jan
106
3. Se realiza la asignacin de comandos a los items de men creados. En el paso anterior se ha creado la estructura del men. Lo siguiente que hay que realizar es asignar una accin a cada item de men. Los items de men que abren otros mens o submens ya tienen asociadas estas acciones automticamente (la accin de abrir otro men). Todos los items de men deben tener asignada una opcin vlida en la propiedad Command Type, la cual puede valer Null, Menu, PL/SQL, Plus, Current Forms o Macro (las opciones Plus, Current Form y Macro se incluyen por compatibilidad con versiones anteriores, aunque no es recomendable utilizarlas). La mayora de los item de mens ejecutan bloques PL/SQL y por tanto su propiedad Command Type ser PL/SQL. Sin embargo, si un item de men llama a un submen, su propiedad Command Type valdr Menu. Null se usa para utilizar separadores.
Para asignar un comando a un item de men se debe realizar lo siguiente: Seleccionar (doble click) el item de men deseado en el editor de mens. En la ventana de propiedades, comprobar que la propiedad Command Type est en el valor deseado: Si el item ejecuta un comando, elegir PL/SQL, si el item invoca un submen, elegir Menu y si el item es un separador, elegir Null. En la ventana de propiedades, hacer doble click en la propiedad Command Text para visualizar el editor PL/SQL. En el editor PL/SQL, escribir el cdigo a ejecutar. Compilar y cerrar el editor PL/SQL.
Figura 27. Asignacin de cdigo a un item de men.
4. Se genera el men y se enlaza a un formato determinado. Para generar el men se utiliza la opcin GENERATE de la opcin ADMINISTRATION del men FILE (tambin se puede utilizar la combinacin de teclas CTRL + T). Es necesario generar el men ya que se enlaza al formato en tiempo de ejecucin. Al generar el men se crea un fichero .MMX.
107
Universidad de Jan
Para relacionar o enlazar un men con un determinado formato hay que asignar a la propiedad Menu Module del formato el nombre (path del fichero .MMX) del men generado. De esta forma, FORMS carga el men automticamente cuando se ejecuta el formato. Si alguna de las opciones del men invoca a otros formatos, para que se mantenga el men creado en todo momento, habr que asignar el men a todos los formatos que se puedan abrir desde el men del formato inicial.
Universidad de Jan
108
5 Developer/2000: Reports Programacin del cliente
Developer/2000: Reports
1. Introduccin
En este tema se va a realizar un estudio de la herramienta REPORTS 2.5 (incluida al igual que FORMS en el paquete Developer/2000 de Oracle). Oracle REPORTS es una herramienta para el desarrollo, visualizacin e impresin de informes (reports). Ejemplos de informes pueden ser las listas de notas de una asignatura, una factura, las etiquetas para realizar un mailing, etc. Un informe, al igual que un formato, es un programa escrito en un lenguaje especial. Por esta razn, asociado a cada informe existen varios ficheros, un fichero .REX que es el fichero fuente, un fichero .RDF con el diseo en binario y uno .REP que es el fichero objeto ejecutable. La existencia de los ficheros .REX permiten la portabilidad de los informes de unas plataformas a otras. La herramienta REPORTS consta bsicamente de dos programas: R25Des: es el entorno de desarrollo del informe. Incluye un conjunto de herramientas visuales que permiten crear los objetos del informe, establecer sus propiedades y escribir el cdigo asociado a los objetos (clculo de frmulas, resmenes de columnas, invocacin de otras aplicaciones, etc.). Desde R25DES se crean los ficheros .REX y .RDF y se genera el fichero runtime .REP. R25Run: es un motor de tiempo de ejecucin (runtime) que ejecuta un informe .REP generado con R25DES. Al igual que para el caso de FORMS, a travs de R25DES se pueden tanto disear como ejecutar (visualizar, imprimir, lanzar a fichero, ...) los informes.
2. Conceptos bsicos
El proceso de creacin de un informe consta de la siguiente secuencia de pasos: 1. Crear el modelo de datos del informe: consiste en elegir los datos que se van a visualizar en el informe, establecer las posibles relaciones entre esos datos y aadir los posibles clculos necesarios para la obtencin final del informe.
2. Disear el aspecto del informe: se puede elegir entre seis tipos diferentes de estilos por defecto proporcionados por Oracle Reports (estilo tabular, estilo maestro/detalle, estilo etiquetas para mailing, ...), aunque tambin se puede crear un aspecto propio para el informe.
111
Universidad de Jan
El modelo de datos de un informe especifica cules son los datos que se deben visualizar en el informe. De igual forma que un formato se estructuraba en bloques, items, disparadores, etc., el modelo de datos de un informe est compuesto por los siguientes tipos de objetos para la definicin de los datos: Consultas (queries): son comandos SELECT que obtienen los datos de la base de datos. Grupos (groups): son objetos que determinan la jerarqua de los datos que aparecen en el informe. Cada consulta tiene un grupo asociado y adems se pueden crear otros grupos (llamados break groups) para, por ejemplo, eliminar los valores repetidos de una columna del informe o para crear subtotales. Columnas (columns): son los objetos que contienen los valores concretos de un informe. Pueden ser columnas que representen los atributos seleccionados en una consulta o columnas que muestren clculos o resmenes de otras columnas. Parmetros (parameters): son variables que permiten relizar diferentes acciones en tiempo de ejecucin. Estas variables se pueden referenciar por ejemplo en bloques PL/SQL o en el cuerpo de una consulta. Enlaces (data links): los enlaces se utilizan para establecer relaciones uno a muchos entre consultas y grupos mediante la correspondencia entre columnas.
3. El entorno de desarrollo del informe

El entorno de desarrollo de un informe (programa R25DES) es muy similar al ya visto para el diseo de formatos (FORMS): En primer lugar se cuenta con un navegador de objetos, que al igual que en FORMS, muestra de una forma jerrquica los distintos objetos que componen cada informe. Las propiedades de cada objeto se muestran en cuadros de dilogo diferentes para cada tipo de objeto. Para modificar de una manera visual los distintos objetos que componen un informe se dispone de tres editores: el editor del modelo de datos (Data Model editor), el editor de aspecto (Layout editor) y el editor del formato de parmetros (Parameter Form editor). A su vez cada editor cuenta con una serie de paletas y barras de herramientas para crear y manipular manualmente los objetos dentro del editor. Para crear un informe se utiliza el programa R25DES. Al informe se le dar un nombre y mediante la creacin de una serie de objetos y el establecimiento de sus propiedades se ir rellenando la informacin necesaria para determinar el aspecto del informe, los datos que va a manipular y su reaccin ante situaciones o eventos especficos. Una vez completado el proceso de diseo del informe lo siguiente que hay que hacer es grabar a disco lo que hasta ese momento se encuentra en memoria (FILE -> SAVE), de esta forma se obtienen los correspondientes ficheros .RDF y .REP. Como ya se dispone del fichero .REP se puede ejecutar el informe utilizando FILE -> RUN. Si el resultado no convence o existen errores en el informe, se puede modificar y repetir el proceso. Una vez creado el informe final es conveniente salvarlo en las tablas del diccionario de datos del
Universidad de Jan
112
servidor Oracle. A partir de este momento el informe se ejecutar con R25RUN, impidiendo de esta forma que el usuario final pueda modificar su diseo.
4. Creacin de informes
En este apartado se va a realizar la creacin, modificacin y ejecucin de un informe para mostrar la informacin relacionada de las tablas TRABAJOS, COCHES y MECANICOS en un formato similar al de una factura. En primer lugar se realizar de una forma muy sencilla y posteriormente se ir modificando su aspecto y su funcionalidad, viendo de esta forma algunas de las distintas posibilidades ofrecidas por REPORTS.
Figura 1. Creacin de un nuevo informe.
4.1. Creacin de un informe con estilo tabular por defecto

Se va a crear un informe de la manera ms sencilla utilizando el estilo tabular. El informe que se va a crear coge informacin de las tablas TRABAJOS, COCHES y MECANICOS, de manera que se muestre para cada coche su matrcula, marca y modelo, los puestos en los que ha sido reparado y el resto de detalles de cada trabajo. Para la creacin del informe se siguen los siguientes pasos: 1. Ejecutar el programa R25Des y realizar la conexin al servidor Oracle. 2. Aparece en pantalla el men principal de R25Des y el Navegador de Objetos que permitir crear, modificar y acceder a todos los objetos que se vayan aadiendo al informe. Para crear un nuevo informe, situndose en el Navegador de Objetos sobre el tipo de objeto que se quiere crear 113 Universidad de Jan
(en este caso se pulsa sobre el nodo Reports) se pulsa el botn CREATE del Navegador de objetos, crendose un nuevo objeto de tipo Reports, inicialmente llamado UNTITLED, al que se le asignar el nombre cuando se guarde en disco (ver Figura 1). 3. Para especificar la informacin que se va a mostrar en el informe se utiliza el editor del modelo de datos, al cual se accede haciendo doble click sobre el icono del nodo Data model del nuevo informe creado. Para obtener los datos de la base de datos hay que crear un objeto consulta de la barra de herramientas y pinchando en el editor. (query) seleccionando el botn SQL Aparece un objeto de tipo consulta (identificado mediante un rectngulo de esquinas redondeadas). Para acceder a la ventana de propiedades del objeto consulta se hace doble click sobre l (ver Figura 2) y se establece el nombre de la consulta (campo name) y el comando SELECT que obtiene la informacin para el informe (campo SELECT statement). El resto de campos de la ventana de propiedades del objeto consulta son: Maximum Rows: establece el nmero mximo de tuplas que sern recuperadas de la base de datos. Tiene su utilidad en el momento del diseo del informe para hacer la consulta ms rpida. External Query: indica un fichero .SQL donde se encuentra almacenado el comando SELECT para la consulta. Tables/Columns...: permite acceder a las distintas tablas y atributos de la base de datos, permitiendo construir de una forma sencilla el comando SELECT de la consulta.
Figura 2. Definiendo un objeto consulta. Al igual que para el resto de objetos del informe, en la pestaa COMMENT se puede insertar un comentario que documente el significado del objeto creado. 4. Como ya se ha terminado de definir la consulta se pulsa el botn OK para salir de su ventana de definicin de propiedades, observando que en el navegador de objetos se ha creado un nuevo objeto para la consulta recin creada, as como un objeto de tipo grupo (Group) que es el que almacena las tuplas devueltas por la consulta. Ambos objetos, la consulta (Trabajos) y el grupo (G_Trabajos) se representan en el editor del modelo de datos tal y como muestra la figura 3. Dentro del grupo G_Trabajos se pueden observar las distintas columnas derivadas de la consulta. 5. Si se hace doble click sobre el grupo G_Trabajos se abre su ventana de propiedades (ver Figura 4a) donde se puede establecer un filtro (campo Filter) sobre las tuplas que se recuperan basado en Universidad de Jan
114
el nmero de ellas que se van a recuperar (First Last) o en condiciones complejas que deben cumplir para ser insertadas dentro del grupo (Condition). Esta condicin compleja se establece a travs de una funcin PL/SQL (function) que puede devolver TRUE o FALSE basndose en los valores de las columnas o de los parmetros del informe. En la figura 4b se ha establecido como filtro del grupo G_Trabajos que slo aparezcan aquellos trabajos realizados a coches RENAULT o VW.
Figura 3. Editor del modelo de datos.
(a) (b) Figura 4. Propiedades de un objeto de tipo grupo. Como puede apreciarse en el cdigo de la figura 4b, la manera de referenciar las columnas de un informe es anloga a la forma de identificar a los items de un formato, es decir, :nombre_columna. 6. Una vez especificado el modelo de datos del informe, el siguiente paso es definir el aspecto del informe. En este caso se va a dar un formato de estilo tabular por defecto. Para ello se selecciona de la barra de TOOLS -> DEFAULT LAYOUT... o se pulsa el botn DEFAULT LAYOUT herramientas del editor del modelo de datos, apareciendo la ventana que permite seleccionar entre los diferentes estilos de informe por defecto (ver figura 5a.). La pestaa DATA/SELECTION de la
115
Universidad de Jan
ventana del estilo por defecto permite especificar que columnas se visualizan en el informe (Columns), sus etiquetas (label), el ancho y el alto de cada columna (W y H), los grupos que se deben visualizar (Group) y la forma en que se van a visualizar los registros de cada grupo (Repeat).
(a) Figura 5. Estilos por defecto.
(b)
Una vez pulsado OK aparece el editor de aspecto (LAYOUT) donde se representa el estilo de visualizacin del informe y donde se pueden aadir y modificar etiquetas, grficos, etc. 7. Para salvar el informe se utiliza la opcin FILE -> SAVE. Para ejecutar el informe se utiliza la opcin FILE -> RUN, que en primer lugar muestra el formato de parmetros por defecto, preguntando por el destino del informe (impresora, fichero, pantalla, mail, ...), para posteriormente pasar a su impresin. Se selecciona la opcin SCREEN y se pulsa el botn RUN REPORT, obteniendo el informe en pantalla como se muestra en la figura 6. Desde el previsualizador (previewer) tambin se puede lanzar el informe a la impresora en cualquier momento pulsando el botn PRINT.
Figura 6. Informe lanzado a pantalla.
4.2. Mejorando el aspecto del informe

En este apartado se van a introducir algunas tcnicas para mejorar el aspecto general del informe y para darle una mayor funcionalidad. En primer lugar se introducir el concepto de break group, que permite eliminar valores repetidos para una determinada columna y agrupa de manera lgica la informacin; posteriormente se estudiar la forma de aadir columnas resumen y columnas calculadas; y finalmente se mejorar el aspecto del informe aadiendo elementos grficos como
Universidad de Jan
116
textos y recuadros, as como parmetros que permitan seleccionar en tiempo de ejecucin los datos a visualizar en el informe. 1. Eliminar las ocurrencias redundantes de coches: Es necesario crear un break group que contenga las columnas MAT, MARCA y MODELO, es decir, un grupo que slo visualizar una vez el conjunto de ocurrencias con el mismo valor en esas tres columnas. Para crear este break group hay que realizar los siguientes pasos: Situarse en el editor del modelo de datos. Desplazar el grupo G_Trabajos hacia abajo para dejar hueco al nuevo break grupo. Pinchar sobre la columna MAT del grupo G_Trabajos, desplazarla y soltarla fuera del grupo G_Trabajos. Esto ocasiona la creacin del nuevo break group. Estirar el nuevo break group para dar cabida a las columnas MARCA y MODELO que de igual forma se arrastran desde el grupo G_Trabajos hacia el nuevo grupo creado. Editar las propiedades del nuevo grupo cambindole el nombre y estableciendo el mismo filtro creado anteriormente para G_Trabajos. En la figura 7 se muestra el modelo de datos con el nuevo break group. Para que los cambios realizados en el modelo de datos se visualicen correctamente en el informe es necesario reflejarlos en el layout editor. Para ello, se pulsa el botn de DEFAULT LAYOUT y se selecciona de nuevo el estilo tabular. Este proceso es necesario realizarlo cada vez que se aada alguna modificacin que implique un cambio de la jerarqua de los datos del informe.
Figura 7. Modelo de datos con un break group. Es necesario aadir un segundo break group para la columna PUESTO, de forma que para cada coche slo se visualice una vez el nombre del puesto en que ha sido reparado aunque tenga varias reparaciones en el mismo. Tras reflejar estos cambios en el layout, el aspecto del informe en ejecucin queda como se muestra en la figura 8.
117
Universidad de Jan
2. Aadir las columnas para el clculo del precio por hora (en funcin del ao de reparacin), del total por trabajo y del total por coche.
Figura 8. Informe con break goups en ejecucin.
Estas columnas implican o bien la realizacin de una frmula sobre los valores de otras columnas (precio por hora y total por trabajo) o bien la obtencin de informacin resumen de una columna (total por coche). Para aadir una columna de frmula se sigue el siguiente proceso: Situarse en el editor del modelo de datos. Seleccionar el botn FORMULA COLUMN .
Pinchar sobre el grupo en el que se insertar la columna. El grupo en el que se inserta la columna de frmula depende de la frecuencia de repeticin de las columnas que se necesitan para la realizacin del clculo. Para el clculo del precio por hora, como se necesita el valor de la fecha de reparacin, se insertar en el grupo G_Trabajos; de igual forma, como el total por trabajo necesita los valores de las horas trabajadas y el precio por hora, se insertar tambin en el grupo G_Trabajos. Hacer doble click sobre la nueva columna creada para acceder a sus propiedades, cambiando el nombre (propiedad Name) y editando la funcin que calcula el valor de la columna presionando el botn EDIT... de la propiedad Formula. Para la columna que calcula el precio por hora en funcin del ao de reparacin los valores introducidos son: Name: Formula: Precio function PrecioFormula return Number is ao number; valor number; begin ao := to_char(:fecha_rep,'YY'); valor := 1000*power(1.05,ao-96); return(valor); end;
Para la columna que calcula el total por trabajo los valores introducidos son:
Universidad de Jan
118
Developer/2000: Reports Name: Formula:
Tot_Trabajo function Tot_TrabajoFormula return Number is begin return(:horas*:precio); end;
Para aadir una columna resumen se sigue el siguiente proceso: Situarse en el editor del modelo de datos. Seleccionar el botn SUMMARY COLUMN .
Pinchar sobre el grupo en el que se insertar la columna. El grupo en el que se inserta la columna de frmula depende de la frecuencia de repeticin que se le quiera dar a la columna resumen. Para el clculo del total por coche, como se necesita un valor para cada conjunto de trabajos realizados a un coche, se insertar en el grupo Break_Trabajos. Hacer doble click sobre la nueva columna creada para acceder a sus propiedades, cambiando el nombre (propiedad Name) y estableciendo la columna sobre la que se quiere hacer el resumen (propiedad Source), el tipo de funcin a aplicar sobre la columna elegida para obtener el resumen (propiedad Function) y cada cuanto se debe resetear el valor resumen (propiedad Reset at). La figura 9 muestra los valores establecidos para el clculo del total por coche. El valor resumen consiste en la suma de la columna Tot_trabajo agrupando para cada conjunto de registros del grupo Break_Trabajos, es decir, para cada conjunto de trabajos realizados a un mismo coche.
Figura 9. Propiedades de una columna resumen.
Una vez introducidas las columnas, se pulsa de nuevo el botn DEFAULT LAYOUT, y en la pestaa Data/Selection se establecen las etiquetas para las nuevas columnas. Una vez regenerado el aspecto del informe, se pueden utilizar mscaras para evitar que se visualicen decimales en las cifras que representan dinero. Para introducir una mscara para una columna concreta se accede a la ventana de propiedades de esa columna haciendo doble click sobre la columna representada en el layout editor y se establece la propiedad Format Mask de la pestaa OBJECT. La mscara que se debe establecer para las columnas F_Tot_trabajo y F_Tot_coche es de cinco dgitos enteros, es decir, NNNNN. El aspecto del informe tras estas modificaciones es el mostrado en la figura 10 (por claridad se han suprimido de la visualizacin las columnas MARCA y MODELO).
119
Universidad de Jan
Programacin de Bases deDatos Oracle 3. Aadir al informe la fecha actual y numeracin de pgina.
El aspecto creado por defecto se puede modificar desde el layout editor, de tal manera que se puede cambiar el tamao, la posicin o el estilo de visualizacin de las columnas y el texto ya creado, aadir ms texto, grficos o nuevos campos que proporcionen ms informacin en el informe. Para aadir la fecha actual al informe se sigue el siguiente proceso: Situarse en el layout editor. Seleccionar el botn FIELD y pinchar donde se desee situar la fecha.
Hacer doble click sobre el nuevo campo creado para acceder a su ventana de propiedades. Se establece el nombre (Name), el valor a visualizar (Source From) y la mscara para el campo (Format Mask) como se indica en la figura 11.
Figura 10. Informe con columnas de frmula y resumen.
Figura 11. Campo con la fecha actual. Una vez establecidas las propiedades del nuevo campo Fecha se aade un texto (con el botn TEXT ) que sirva de etiqueta para el campo creado.
Universidad de Jan
120
Una tpica manera de numerar las pginas de los informes es utilizando la notacin Pgina / Total Pginas. Para hacerlo se necesitan dos nuevos campos, uno que visualice la pgina actual y otro que visualice el nmero total de pginas. Estos dos campos se crean de manera anloga a la descrita para el campo con la fecha actual, estableciendo para el campo con la pgina actual: Name: Pag Source From: &Physical Page Number Hidden: Activado y para el campo con el total de pginas: Name: Tot_Pag Source From: &Total Physical Pages Hidden: Activado Activar la propiedad Hidden significa que el campo no se va a visualizar, ya que va a ser referenciado directamente desde el texto que sirve como etiqueta a la numeracin de pgina. Este texto se introduce con el botn TEXT y referenciando a los campos anteriormente creados como &Pag y &Tot_Pag. Por ejemplo se puede escribir Pgina: &Pag / &Tot_Pag El aspecto del informe tras la introduccin de estos campos es el mostrado en la figura 12.
Figura 12. Informe con fecha y numeracin de pgina. 4. Crear un formato de parmetros para el informe que solicite la matrcula del coche del que se deben visualizar sus trabajos. Es necesario crear un formato de parmetros del usuario que solicite la matrcula del coche del cual se quiere obtener la factura de su reparacin. Los pasos a seguir son los siguientes: Desde el navegador de objetos, dentro del nodo Data Model, hay que crear un nuevo objeto del tipo User Parameters. En este nuevo objeto de tipo parmetro de usuario se establecen los valores que podrn ser seleccionados al arrancar el informe y almacena el valor seleccionado para su posterior uso en tiempo de ejecucin. Haciendo doble click sobre el icono del nuevo parmetro creado se accede a su ventana de propiedades, donde en la pestaa GENERAL se establece el nombre del parmetro (propiedad Name) y el tipo de datos de los valores que va a 121 Universidad de Jan
almacenar (propiedad Datatype), y en la pestaa DATA/SELECTION se seleccionan los posibles valores que aparecern para el parmetro. Esta lista de valores (propiedad List of Values) puede ser esttica o estar basada en una consulta sobre la base de datos como se muestra en la figura 13 para el caso del parmetro que selecciona la matrcula.
Figura 13. Lista de valores del parmetro de usuario.
Figura 14. Formato de parmetros con parmetro para la matrcula.
Figura 15. Informe tras seleccin de matrcula. Universidad de Jan 122
Hay que reescribir los filtros PL/SQL para los grupos G_Trabajos y Break_Trabajos para que se basen en el nuevo parmetro introducido en la seleccin de registros a visualizar en el informe. El cdigo de ambos filtros puede ser el siguiente: IF (:mat=:matricula) THEN return(TRUE); ELSE return (FALSE); END IF; Ahora al ejecutar el informe, el formato de parmetros muestra el muevo parmetro que debe tomar valor de una de las matrculas de los coches reparados en el taller (ver Figura 14). Los parmetros que aparecen en el formato de parmetros se pueden controlar (activar o desactivar) desde TOOLS -> DEFAULT PARAMETERS FORM. Tambin es posible modificar el aspecto del formato de parmetros desde el Parameter Form editor. En la figura 15 se muestra el informe obtenido tras realizar la seleccin de la figura 14.
5. Otros estilos de informes

Hasta el momento slo se ha utilizado el estilo tabular de los varios posibles que proporciona REPORTS para definir el aspecto del informe. A continuacin se van a describir dos estilos posibles, los estilos Maestro/Detalle y Matriz, que permiten realizar diseos diferentes de los informes de una forma sencilla. Otros estilos por defecto proporcionados por REPORTS y de gran utilidad para la mayora de las aplicaciones son los estilos form letter y mailing label. El primero permite escribir una serie de cartas con el mismo texto pero cambiando determinadas zonas en funcin de los datos recuperados de la base de datos, como por ejemplo las tpicas cartas publicitarias que slo se diferencian en el nombre del destinatario y algunos datos ms. El estilo mailing label permite generar de forma sencilla un conjunto de etiquetas para ser utilizadas como destinatarios de cartas, etc.
5.1. Informe con estilo Maesto - Detalle

Los informes de estilo maestro-detalle son similares a los que contienen break groups en el sentido de que se muestra para un determinado valor (o conjunto de valores) un conjunto de registros relacionados. Sin embargo, los informes maestro/detalle estn basados en dos consultas y los grupos asociados a dichas consultas se hayan unidos por un enlace de datos. A continuacin se detallan los pasos a dar para crear un informe maestro-detalle que visualice para cada mecnico su dni y su nombre, el total de horas trabajadas por ao y el total ganado. Los pasos para crear este informe son los siguientes: Crear un objeto consulta que seleccione el dni y nombre de los mecnicos. Las propiedades que hay que establecer para el objeto consulta son: Name: SELECT Statement: Mecanicos SELECT dni,nombre FROM mecanicos ORDER BY nombre;
123
Universidad de Jan
Crear un objeto consulta que seleccione para cada dni y para cada ao el nmero total de horas trabajadas. Las propiedades que hay que establecer para el objeto consulta son: Name: SELECT Statement: Trabajos SELECT dni, to_char(fecha_rep,'YY')"ao", sum(horas)"horas" FROM trabajos GROUP BY dni,to_char(fecha_rep,'YY');
Crear un enlace de datos que establezca la relacin maestro/detalle. Desde el editor del modelo de datos se selecciona el botn DATA LINK , se pincha sobre la columna DNI del grupo G_Mecanicos (Maestro) y sin soltar se arrastra hasta la columna DNI2 del grupo G_Trabajos (Detalle). Esto desencadena la creacin del enlace de datos, quedando el modelo de datos como se muestra en la figura 16.
Figura 16. Modelo de datos para informe Maestro/Detalle. Crear una columna calculada dentro del grupo G_Trabajos con las siguientes propiedades: Name: Precio Formula: function PrecioFormula return Number is precioh number; begin precioh := 1000* power(1.05, to_number(:ao)-96); return(precioh*:horas); end; Crear una columna resumen dentro del grupo G_Mecanicos con las siguientes propiedades: Name: Source: Function: Reset At: Total Precio Sum G_Mecanicos
Pulsar el botn DEFAULT LAYOUT, activar el radio button Master/Detail, y en la pestaa DATA/SELECTION establecer el valor Repeat del grupo G_MECANICOS como Across/Down Universidad de Jan 124
(permite visualizar el informe en varias columnas) y desactivar la columna DNI2. Desde el navegador de objetos hacer doble click sobre el icono del frame R_MECANICOS que se encuentra dentro del nodo body bajo layout. Esto abre la ventana de propiedades del frame en la que se establecen las propiedades Spacing Vertical y Spacing Horizontal a 0.25, implicando que las distintas ocurrencias de los trabajos de cada mecnico se separarn entre s 0.25 pulgadas. Desde el layout editor, seleccionar el frame R_MECANICOS y establecer que se enmarque con una lnea de color negro utilizando la paleta de colores a la que se accede con el botn LINE COLOR . Cambiar el tipo de letra de las etiquetas DNI, NOMBRE y Total para que se visualicen en negrita y cursiva seleccionando cada uno de estos textos y utilizando FORMAT -> FONT. De igual forma se cambia el tipo de letra para el campo F_Total para que se visualice en negrita. Establecer la propiedad Format Mask de los campos F_Precio y F_Total a NNNNN. El informe resultante es el mostrado en la figura 17.
Figura 17. Informe con estilo Maestro/Detalle.
5.2. Informe con estilo Matriz

Los informes con estilo Matriz permiten visualizar la informacin en un formato similar a una rejilla, donde tanto los valores de las filas como los de las columnas son variables en funcin de los datos almacenados en la base de datos. A continuacin se describe el proceso de creacin de un informe con estilo matriz que permite visualizar el nmero de horas trabajadas por ao en cada puesto. Adems se visualiza el nmero total de horas por ao y por puesto. Los pasos a dar son los siguientes:
125
Universidad de Jan
Crear un objeto consulta que obtenga para cada ao y en cada puesto el total de horas trabajadas. Las propiedades de este objeto consulta son: Name: Horas SELECT Statement: SELECT puesto, to_char(fecha_rep,'YY')"ao", sum(horas) FROM trabajos t,mecanicos m WHERE t.dni=m.dni GROUP BY puesto,to_char(fecha_rep,'YY'); Desde el editor del modelo de datos, pinchar y arrastrar fuera y por encima del grupo G_Trabajos las columnas Puesto y Ao, de forma que se creen dos nuevos grupos que se nombran G_Puesto y G_Ao. Estos dos grupos son los que contienen los valores que etiquetan las filas y las columnas de la matriz.
Figura 18. Modelo de datos con un cross product group. Para poder crear una matriz es necesario crear un grupo que obtenga la informacin para cada posible pareja fila-columna (PRODUCTO CARTESIANO). Estos grupos se denominan cross product group y se crean pulsando el botn CROSS PRODUCT del editor del modelo de datos y enmarcando la zona del editor donde se encuentren los grupos que representan las filas y columnas de la matriz. Es decir, hay que pulsar el botn CROSS PRODUCT y enmarcar los grupos G_Puesto y G_Ao. Al nuevo grupo creado se le establece como nombre G_Matriz. El modelo de datos resultante es el mostrado en la figura 18. Para obtener los sumatorios por filas y columnas se deben crear dos columnas resumen dentro del grupo G_Matriz con las siguientes propiedades: Universidad de Jan 126
Name: Source: Function: Reset At: Product Order: Name: Source: Function: Reset At: Product Order:
Fila_aos sum_horas Sum G_ao G_ao (establece frecuencia de visualizacin de valores) Col_puestos sum_horas Sum G_puesto G_puesto
Pulsar el botn DEFAULT LAYOUT y seleccionar el radio button Matrix. En la pestaa DATA/SELECTION establecer Across como valor Repeat del grupo G_Puesto para establecer que los puestos son las columnas de la matriz. Borrar todas las etiquetas de las columnas ya que las etiquetas de la matriz son los propios valores devueltos en cada columna. Desde el layout editor establecer con FORMAT -> ALIGMENT -> CENTER una alineacin centrada para los campos F_puesto, F_sum_horas, F_Col_puestos y F_ao. Enmarcar los campos F_puesto y F_ao y aadir una lnea vertical junto al campo F_Fila_Aos. Cambiar a negrita la fuente de los campos F_puesto, F_ao, F_Col_puestos y F_Fila_aos. El informe una vez ejecutado muestra la informacin como se ve en la figura 19.
Figura 19. Informe con estilo matriz.
127
Universidad de Jan
6 Bibliografa
Bibliografa
1. Koch, G. "ORACLE 7 : manual de referencia", McGraw Hill, 1994. 2. Muller, R.J. "Oracle developer/2000 handbook", McGraw-Hill, 1997 3. Oracle Corporation. "Oracle7 Server SQL Reference", 1995. 4. Oracle Corporation. "Oracle7 Server Application Developer's Guide", 1995. 5. Oracle Corporation. "Forms 4.5 Developer's Guide Manual", 1995. 6. Oracle Corporation. "Reports 2.5 Building Reports Manual", 1995. 7. Pepin, D. "Oracle : guia de referencia para el programador", Anaya multimedia, 1991. 8. Urman. "ORACLE8. Programacin PL/SQL", McGraw Hill, 1998.
131
Universidad de Jan

Oracle

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Oracle

Încărcat de

Drepturi de autor:

Formate disponibile

Programacin de Bases de Datos Oracle

Juan Ruiz de Miras Andrs Molina Aguilar

Universidad de Jan Departamento de Informtica

Programacin de Bases de Datos Oracle

BIBLIOGRAFA ................................................................................................................................. 129

Programacin de Bases de Datos Oracle

Programacin de Bases de Datos Oracle

3. Nociones bsicas de SQL*Plus

4. Usuarios de la base de datos, cambio de contrasea

Programacin de Bases de Datos Oracle

5. El Diccionario de Datos de ORACLE

5.1. Tablas del Diccionario de Datos

5.2. Las vistas del Diccionario de Datos

Programacin de Bases de Datos Oracle

DBA_TABLES DBA_CATALOG DBA_OBJECTS DBA_DATA_FILES DBA_USERS

2 SQL: Lenguaje de Consulta Estructurado

Programacin de Bases de Datos Oracle

Programacin de Bases de Datos Oracle

2. Tipos de datos y conversin entre tipos

SQL Fechas (DATE):

Programacin de Bases de Datos Oracle

3. Expresiones y operadores condicionales

Programacin de Bases de Datos Oracle nombre = 'PEPE' fecha < 1-ene-93

Programacin de Bases de Datos Oracle

4. Creacin, modificacin y destruccin de TABLAS

4.1. Creacin de TABLAS

SQL mat marca an_fab );

4.2. Modificacin de TABLAS

4.3. Eliminacin de TABLAS

Programacin de Bases de Datos Oracle

5. Insercin, modificacin y eliminacin de DATOS

5.1. Insercin de Datos

5.2. Modificacin de Datos

Programacin de Bases de Datos Oracle

5.3. Eliminacin de Datos

6. Consultas sobre la base de datos

Programacin de Bases de Datos Oracle

6.1. Conceptos bsicos relativos al comando SELECT

Programacin de Bases de Datos Oracle

Programacin de Bases de Datos Oracle

MARCA --------------RENAULT VW PEUGEOT PEUGEOT PEUGEOT TOYOTA RENAULT

Programacin de Bases de Datos Oracle

Donde R.x indica que se refiere al atributo x de la tabla cuyo alias es R.

SQL Obtener parejas de mecnicos del mismo puesto:

Programacin de Bases de Datos Oracle

6.2. Otros usos del comando SELECT

SQL columna o expresin debe ser numrica. Ejemplos:

Programacin de Bases de Datos Oracle

Programacin de Bases de Datos Oracle

Consulta de informacin agrupada

Programacin de Bases de Datos Oracle

SUM(horas) = 3.2 SUM(horas) = 8 SUM(horas) = 8 SUM(horas) = 2.1

Programacin de Bases de Datos Oracle

Programacin de Bases de Datos Oracle

Programacin de Bases de Datos Oracle

SELECT puesto FROM mecanicos WHERE nombre = 'EMILIO') AND nombre!='EMILIO';

Programacin de Bases de Datos Oracle

MAT -------M3020KY J1234Z J9999AB J1234Z

Variables de tupla y consultas sincronizadas

Operaciones entre conjuntos

DNI --------3333 5555

Programacin de Bases de Datos Oracle

Programacin de Bases de Datos Oracle

7.1. Concepto de vista