Programación de bases de datos.

Ahora que ya dominas el uso de SQL para la manipulación y consulta de datos, es el momento de dar una vuelta de tuerca adicional para mejorar las aplicaciones que utilicen nuestra base de datos.

Para ello nos vamos a centrar en la programación de bases de datos, utilizando principalmente el lenguaje PL/SQL que utiliza Oracle y que veremos al comienzo de esta unidad y terminaremos trabajando también con MySQL como hemos venido haciendo en las unidades anteriores para que puedas usar su propio lenguaje procedimental llamado SQL/PSM.

Debes conocer

Durante los primeros apartados de la unidad encontrarás diferentes videotutoriales y ejemplos de código haciendo referencia a la base de datos de Conferencias que venimos trabajando desde la unidad 4 y cuyas tablas y datos ya conoces. Se adjunta aquí el script para que puedas descargarlo de nuevo y practicar con los ejemplos que se muestran en esta unidad. Recuerda que puedes consultar el diagrama Entidad-Relación y el paso a tablas en la unidad 4.

Script creación de tablas y datos de BD Conferencia (zip - 1.68 KB).

Al igual que hemos trabajado en las unidades anteriores tanto en Oracle como en MySQL también vamos a hacer referencia a multitud de ejemplos en el código de los últimos apartados de esta unidad a la base de datos ProyectosX cuyos esquemas también los encontrarás en la unidad 4. Por tanto, aunque ya tendrás el script instalado desde la unidad 4, se adjunta de nuevo para que puedas crear las tablas e insertar de nuevo los datos iniciales.

Script creación de tablas y datos de BD ProyectosX (zip - 1,37 KB)

1.- Introducción a PL/SQL de Oracle.

Caso práctico

Ministerio de Educación-ITE (Miguel Martínez Monasterio) (CC BY-NC)

Juan y María se han puesto a repasar el manual de PL/SQL que les ha pasado Ada. Aunque no han avanzado mucho con el mismo, ya saben a qué se van a enfrentar y los beneficios que pueden obtener del uso del mismo para su base de datos de gestión de conferencias. Cuando hacen la primera parada de la mañana para tomarse un café, ambos se ponen a comentar las primeras conclusiones que han sacado después de su primer acercamiento a este lenguaje. Ambos están deseosos de seguir avanzando en su aprendizaje y saben que para ello cuentan con la inestimable ayuda de Ada.

Estarás pensado que si no tenemos bastante con aprender SQL, sino que ahora tenemos que aprender otro lenguaje más que lo único que va a hacer es complicarnos la vida. Verás que eso no es cierto ya que lo más importante, que es el conocimiento de SQL, ya lo tienes. PL/SQL tiene una sintaxis muy sencilla y verás como pronto te acostumbras y luego no podrás vivir sin él.

Pero, ¿qué es realmente PL/SQL?

PL/SQL es un lenguaje procedimentalLenguaje ProcedimentalLenguaje que utiliza los procedimientos y funciones para crear programas y así poder utilizar diferentes grados de abstracción y reutilización del código. estructurado en bloques que amplía la funcionalidad de SQL. Con PL/SQL podemos usar sentencias SQL para manipular datos y sentencias de control de flujo para procesar los datos. Por tanto, PL/SQL combina la potencia de SQL para la manipulación de datos, con la potencia de los lenguajes procedimentales para procesar los datos.

Aunque PL/SQL fue creado por Oracle, hoy día todos los gestores de bases de datos utilizan un lenguaje procedimental muy parecido al ideado por Oracle para poder programar las bases de datos.

Como veremos, en PL/SQL podemos definir variables, constantes, funciones, procedimientos, capturar errores en tiempo de ejecución, anidar cualquier número de bloques, etc. como solemos hacer en cualquier otro lenguaje de programación. Además, por medio de PL/SQL programaremos los disparadores de nuestra base de datos, tarea que no podríamos hacer sólo con SQL.

El motor de PL/SQL acepta como entrada bloques PL/SQL o subprogramas, ejecuta sentencias procedimentales y envía sentencias SQL al servidor de bases de datos. En el esquema adjunto puedes ver su funcionamiento.

Una de las grandes ventajas que nos ofrece PL/SQL es un mejor rendimiento en entornos de red cliente-servidorCliente-ServidorLa arquitectura cliente-servidor es un modelo de aplicación distribuida en el que las tareas se reparten entre los proveedores de recursos o servicios, llamados servidores, y los demandantes, llamados clientes. Un cliente realiza peticiones a otro programa, el servidor, que le da respuesta., ya que permite mandar bloques PL/SQL desde el cliente al servidor a través de la red, reduciendo de esta forma el tráfico y así no tener que mandar una a una las sentencias SQL correspondientes.

Ministerio de Educación (CC BY-NC)

Recomendación

En esta unidad vamos a trabajar con el SGBD de Oracle principalmente a lo largo de varios apartados. Por tanto, debes tener instalado en tu equipo:

Oracle Database 21c Express y
SQL Developer como herramienta cliente y entorno gráfico para trabajar más fácilmente con bases de datos.

Es muy recomendable que visualices de nuevo la unidad 1 y en particular el Anexo I: Primeros pasos en Oracle Database. En ese anexo, encontrarás los enlaces de descarga y unos videotutoriales que te ayudarán en el proceso de instalación, configuración y primeros pasos para crear usuarios, tablas y cargar scripts con datos para realizar todo tipo de pruebas.

1.1.- Resolución de posibles problemas trabajando con Oracle.

Cuando trabajamos con una Base de Datos en Oracle podemos interactuar con ella mediante una herramienta gráfica, como por ejemplo SQL Developer. Lo primero que tendremos que hacer será establecer una conexión nueva con el usuario SYSTEM. A partir de ahí y trabajando desde esa conexión con todos los roles y privilegios de los que se dispone, cada vez que queramos crear una base de datos nueva, se recomienda que primero se cree una nueva conexión utilizando un usuario definido por nosotros mismos y no utilizar por defecto el usuario SYSTEM.

Pero, ¿Qué ocurre si se presenta algún problema que te impide trabajar con Oracle? ¿No recuerdas la contraseña de administrador? ¿Te ha expirado o expirará próximamente? ¿No puedes crear un usuario para empezar a trabajar con una nueva Base de Datos?

No te preocupes, vamos a intentar en este apartado resolver algunos de los principales problemas que puedas encontrar cuando trabajas con Oracle.

Citas Para Pensar

Los errores son la prueba de que lo estás intentando.
Stephen Richard

Veamos algunos de las posibles dificultades o fallos más frecuentes que pueden ocurrirnos cuando trabajamos con Oracle:

No recuerdo la contraseña del usuario administrador: Este problema nos puede ocurrir con bastante frecuencia, sobretodo si hace mucho tiempo que no utilizamos SQL Developer para conectarnos a Oracle.

En primer lugar debes recordar que cuando se instala Oracle, se debe establecer una contraseña para el usuario SYSTEM. Cuando después utilizamos la herramienta gráfica SQL Developer para conectarnos, la primera conexión que debemos crear siempre en SQL Developer para comenzar a trabajar es precisamente una conexión con este usuario SYSTEM.

Podemos encontrarnos entonces con dos situaciones cuya solución será la misma:

1) Si es la primera vez que vas a crear una conexión con el usuario SYSTEM y no introduces la contraseña correcta, el error que muestra será como el que aparece en la siguiente imagen que puedes pulsar para ampliar:

Captura pantalla SQL Developer (GNU/GPL)

Precisamente en el mensaje del error dice "nombre de usuario/contraseña no válidos; conexión denegada", lo cual indica que para el usuario SYSTEM, que por supuesto sí existe, no estamos introduciendo la contraseña válida.

2) Si ya se creó una primera conexión pero al intentar acceder no te lo permite porque no recuerdas o no coincide la contraseña original te podrá aparecer un mensaje de error como se muestra en esta imagen que también puedes ampliar.

Captura SQL Developer (GNU/GPL)

Este error precisamente se muestra cuando intentamos conectarnos a una conexión que fue creada anteriormente, por ejemplo con el usuario SYSTEM y ahora al intentar volver a conectarnos nos indica que no se puede.

Para poder solucionar el fallo que se ha descrito en los dos apartados anteriores podemos reestablecer la contraseña del usuario SYSTEM y para ello podremos hacerlo siguiendo los pasos que se explican en este video:

Elaboración propia Descripción textual del vídeo (GNU/GPL)

La contraseña de administrador está próxima a caducar. Si se muestra este mensaje cuando entramos en SQL Developer indicando que en unos días expirará la contraseña podemos resolverlo realizando una serie de pasos.

Captura SQL Developer (GNU/GPL)

Puedes seguir las siguientes indicaciones que encontrarás en este fichero para solucionar este problema:

Pasos para modificar el tiempo de expiración de una contraseña. (pdf - 0,35 MB)

No puedo crear un usuario nuevo: Para trabajar con diferentes bases de datos en Oracle, es aconsejable crear nuevas conexiones y además con diferentes usuarios definidos por nosotros mismos. Seguramente, si lo has intentado, al ejecutar una sentencia de creación de usuario utilizando un nombre cualquiera te ha mostrado un mensaje de error. Esto es debido a que Oracle tiene una regla para definir los nombres de usuarios comunes y es que comiencen por C## seguido del nombreUsuario (por ejemplo C##PEDRO o C##MARIA). También podemos alterar la sesión de Oracle para crear usuarios con nombres que nosotros creamos oportunos saltándonos esta regla predefinida. Puedes visualizar el siguiente videotutorial donde se explica ambas formas de crear usuarios en Oracle y decides cuál utilizar.

Cómo crear usuarios y conexiones nuevas en Oracle 21c

Elaboración propia Descripción textual del video. (GNU/GPL)
No se puede crear o establecer una nueva conexión: Cuando queremos establecer una conexión nueva y estamos seguros de que el nombre de usuario y contraseña son válidos, nos tenemos que fijar en los parámetros del host y el puerto por el cual se conecta al servidor Oracle. El error que seguramente te aparecerá, y es bastante frecuente, será como el que se muestra en la siguiente imagen ampliable:

Captura de SQL Developer (GNU/GPL)

Si te fijas bien, el mensaje refiere a que no puede conectarse al servidor, bien porque éste no esté iniciado o porque no esté escuchando a la parte del cliente. Puede deberse a varias causas, intenta seguir los pasos del siguiente fichero para solucionar este problema:

Pasos para solucionar el error de conexión. (pdf - 0,52 MB)

Recuerda que es muy aconsejable en Oracle crear una nueva conexión con un nuevo usuario cada vez que quieras crear una nueva base de datos. De esa manera no se mezclarán tablas de las diferentes BD y estará todo más claro.

2.- Conceptos básicos.

Caso práctico

Pizarra en la que con tiza rosa se pueden leer las vocales.

Ministerio de Educación - ITE (CC BY-NC)

Juan ha avanzado muy rápido en la lectura del manual que le pasó Ada. Juan ya sabe programar en otros lenguajes de programación y por tanto la lectura de los primeros capítulos que se centran en cómo se estructura el lenguaje, los tipos de datos, las estructuras de control, etc. le han resultado muy fáciles de comprender. Sabe que lo único que tendrá que tener en cuenta son algunos aspectos en cuanto a las reglas de escritura y demás, pero la lógica es la de cualquier otro lenguaje de programación.

Como María está un poco más verde en el tema de la programación, Juan se ha ofrecido a darle un repaso rápido a todo lo que él ha visto y a explicarle todo aquello en lo que tenga dudas y a ver si pronto se pueden poner manos a la obra con la base de datos de juegos on-line.

En este apartado nos vamos a ir introduciendo poco a poco en los diferentes conceptos que debemos tener claros para programar en PL/SQL. Como para cualquier otro lenguaje de programación, debemos conocer las reglas de sintaxis que podemos utilizar, los diferentes elementos de que consta, los tipos de datos de los que disponemos, las estructuras de control que nos ofrece (tanto iterativas como condicionales) y cómo se realiza el manejo de los errores.

Como podrás comprobar, es todo muy sencillo y pronto estaremos escribiendo fragmentos de código que realizan alguna tarea particular. ¡Vamos a ello!

Autoevaluación

Solución

2.1.- Unidades léxicas (I).

Ministerio de Educación - ITE (CC BY-NC)

En este apartado nos vamos a centrar en conocer cuáles son las unidades léxicas que podemos utilizar para escribir código en PL/SQL. Al igual que en nuestra lengua podemos distinguir diferentes unidades léxicas como palabras, signos de puntuación, etc. En los lenguajes de programación también existen diferentes unidades léxicas que definen los elementos más pequeños que tienen sentido propio y que al combinarlos de manera adecuada, siguiendo las reglas de sintaxis, dan lugar a sentencias válidas sintácticamente.

PL/SQL es un lenguaje no sensible a las mayúsculas, por lo que será equivalente escribir en mayúsculas o minúsculas, excepto cuando hablemos de literales de tipo cadena o de tipo carácter.

Cada unidad léxica puede estar separada por espacios (debe estar separada por espacios si se trata de 2 identificadores), por saltos de línea o por tabuladores para aumentar la legibilidad del código escrito.

IF A=CLAVE THEN

     ENCONTRADO:=TRUE;

ELSE

     ENCONTRADO:=FALSE;

END IF;

Sería equivalente a escribir la siguiente línea:

if a=clave then

     encontrado:=true;

else

     encontrado:=false;

end if;

Y también sería equivalente a este otro fragmento:

IF a = clave THEN

     encontrado := TRUE;

ELSE

     encontrado := FALSE;

END IF;

Las unidades léxicas se pueden clasificar en:

Delimitadores.
Identificadores.
Literales.
Comentarios.

Vamos a verlas más detenidamente.

Delimitadores.

PL/SQL tiene un conjunto de símbolos denominados delimitadores utilizados para representar operaciones entre tipos de datos, delimitar comentarios, etc. En la siguiente tabla puedes ver un resumen de los mismos.

Delimitadores en PL/SQL.
Delimitadores Simples.		Delimitadores Compuestos.
Símbolo.	Significado.	Símbolo.	Significado.
+	Suma.	**	Exponenciación.
%	Indicador de atributo.	<>	Distinto.
.	Selector.	¡=	Distinto.
/	División.	<=	Menor o igual.
(	Delimitador de lista.	>=	Mayor o igual.
)	Delimitador de lista.	..	Rango.
:	Variable host.	\|\|	Concatenación.
,	Separador de elementos.	<<	Delimitador de etiquetas.
*	Producto.	>>	Delimitador de etiquetas.
"	Delimitador de identificador acotado.	--	Comentario de una línea.
=	Igual relacional.	/*	Comentario de varias líneas.
<	Menor.	*/	Comentario de varias líneas.
>	Mayor.	:=	Asignación.
@	Indicador de acceso remoto.	=>	Selector de nombre de parámetro.
;	Terminador de sentencias.
-	Resta/negación.

2.1.1.- Unidades léxicas (II).

Ministerio de Educación - ITE (CC BY-NC)

Ya hemos visto qué son los delimitadores. Ahora vamos a continuar viendo el resto de unidades léxicas que nos podemos encontrar en PL/SQL.

Identificadores.

Los identificadores en PL/SQL, como en cualquier otro lenguaje de programación, son utilizados para nombrar elementos de nuestros programas. A la hora de utilizar los identificadores debemos tener en cuenta los siguientes aspectos:

Un identificador es una letra seguida opcionalmente de letras, números, $, _, #.
No podemos utilizar como identificador una palabra reservada.
- Ejemplos válidos: X, A1, codigo_postal.
- Ejemplos no válidos: rock&roll, on/off.
PL/SQL nos permite además definir los identificadores acotados, en los que podemos usar cualquier carácter con una longitud máxima de 30 y deben estar delimitados por ". Ejemplo: "X*Y".
En PL/SQL existen algunos identificadores predefinidos y que tienen un significado especial ya que nos permitirán darle sentido sintáctico a nuestros programas. Estos identificadores son las palabras reservadas y no las podemos utilizar como identificadores en nuestros programas. Ejemplo: IF, THEN, ELSE ...
Algunas palabras reservadas para PL/SQL no lo son para SQL, por lo que podríamos tener una tabla con una columna llamada 'type' por ejemplo, que nos daría un error de compilación al referirnos a ella en PL/SQL. La solución sería acotarlos. SELECT "TYPE" …

Literales.

Los literales se utilizan en las comparaciones de valores o para asignar valores concretos a los identificadores que actúan como variables o constantes. Para expresar estos literales tendremos en cuenta que:

Los literales numéricos se expresarán por medio de notación decimal o de notación exponencial. Ejemplos: 234, +341, 2e3, -2E-3, 7.45, 8.1e3.
Los literales tipo carácter y tipo cadena se deben delimitar con unas comillas simples.
Los literales lógicos son TRUE y FALSE.
El literal NULL que expresa que una variable no tiene ningún valor asignado.

Comentarios.

En los lenguajes de programación es muy conveniente utilizar comentarios en mitad del código. Los comentarios no tienen ningún efecto sobre el código pero sí ayudan mucho al programador o la programadora a recordar qué se está intentando hacer en cada caso (más aún cuando el código es compartido entre varias personas que se dedican a mejorarlo o corregirlo).

En PL/SQL podemos utilizar dos tipos de comentarios:

Los comentarios de una línea se expresarán por medio del delimitador --. Ejemplo:
```
a:=b;  --asignación
```
Los comentarios de varias líneas se acotarán por medio de los delimitadores /* y */. Ejemplo:
```
/* Primera línea de comentarios.
```
```
    Segunda línea de comentarios. */
```

Ejercicio resuelto

Dada la siguiente línea de código, haz su descomposición en las diferentes unidades léxicas que contenga.

IF A <> B THEN iguales := FALSE; --No son iguales

2.2.- Tipos de datos simples, variables y constantes.

Ministerio de Educación - ITE (CC BY-NC)

En cualquier lenguaje de programación, las variables y las constantes tienen un tipo de dato asignado (bien sea explícitamente o implícitamente). Dependiendo del tipo de dato el lenguaje de programación sabrá la estructura que utilizará para su almacenamiento, las restricciones en los valores que puede aceptar, la precisión del mismo, etc.

En PL/SQL contamos con todos los tipos de datos simples utilizados en SQL y algunos más. En este apartado vamos a enumerar los más utilizados.

Numéricos.

BINARY_INTEGER: Tipo de dato numérico cuyo rango es de -2147483647 .. 2147483647. PL/SQL además define algunos subtipos de éste: NATURAL, NATURALN, POSITIVE, POSITIVEN, SIGNTYPE.
NUMBER: Tipo de dato numérico para almacenar números racionales. Podemos especificar su escala (-84 .. 127) y su precisión (1 .. 38). La escala indica cuándo se redondea y hacia dónde. Ejemplos. escala=2: 8.234 -> 8.23, escala=-3: 7689 -> 8000. PL/SQL también define algunos subtipos como: DEC, DECIMAL, DOUBLE PRECISION, FLOAT, INTEGER, INT, NUMERIC, REAL, SMALLINT.
PLS_INTEGER: Tipo de datos numérico cuyo rango es el mismo que el del tipo de dato BINARY_INTEGER, pero que su representación es distinta por lo que las operaciones aritméticas llevadas a cabo con los mismos serán más eficientes que en los dos casos anteriores.

Alfanuméricos.

CHAR(n): Array de n caracteres, máximo 2000 bytes. Si no especificamos longitud sería 1.
LONG: Array de caracteres con un máximo de 32760 bytes.
RAW: Array de bytes con un número máximo de 2000.
LONG RAW: Array de bytes con un máximo de 32760.
VARCHAR2: Tipo de dato para almacenar cadenas de longitud variable con un máximo de 32760.

Grandes objetos.

BFILE: PunteroPunteroUn puntero o apuntador es una variable que referencia una región de memoria; en otras palabras es una variable cuyo valor es una dirección de memoria. a un fichero del Sistema Operativo.
BLOB: Objeto binario con una capacidad de 4 GB.
CLOB: Objeto carácter con una capacidad de 2 GB.

Otros.

BOOLEAN: TRUE/FALSE.
DATE: Tipo de dato para almacenar valores día/hora desde el 1 enero de 4712 a.c. hasta el 31 diciembre de 4712 d.c.

Hemos visto los tipos de datos simples más usuales. Los tipos de datos compuestos los dejaremos para posteriores apartados.

Para saber más

Tipos de datos en PL/SQL.

En el siguiente enlace podrás ampliar información sobre los tipos de datos de los que disponemos en PL/SQL.

Autoevaluación

Solución

2.2.1.- Variables y constantes.

Pizarra en la que se puede leer “π=3'1416”.

Ministerio de Educación - ITE (CC BY-NC)

Llevamos un buen rato hablando de tipos de datos variables e incluso de constantes y te estarás preguntando cuál es la forma adecuada de definirlas. En este apartado vamos a ver las diferentes posibilidades a la hora de definirlas y dejaremos para el apartado siguiente ver cuál es el lugar adecuado para hacerlo dentro de un bloque PL/SQL.

Para declarar variables o constantes pondremos el nombre de la variable, seguido del tipo de datos y opcionalmente una asignación. Si es una constante antepondremos la palabra CONSTANT al tipo de dato (lo que querrá decir que no podemos cambiar su valor). Podremos sustituir el operador de asignación en las declaraciones por la palabra reservada DEFAULT. También podremos forzar a que no sea nula utilizando la palabra NOT NULL después del tipo y antes de la asignación. Si restringimos una variable con NOT NULL deberemos asignarle un valor al declararla, de lo contrario PL/SQL lanzará la excepción VALUE_ERROR (no te asustes que más adelante veremos lo que son las excepciones, pero como adelanto te diré que es un error en tiempo de ejecución).

id SMALLINT;

hoy DATE := sysdate;

pi CONSTANT REAL:= 3.1415;

id SMALLINT NOT NULL;          --ilegal, no está inicializada

id SMALLINT NOT NULL := 9999;     --legal

El alcance y la visibilidad de las variables en PL/SQL será el típico de los lenguajes estructurados basados en bloques, aunque eso lo veremos más adelante.

Conversión de tipos.

Aunque en PL/SQL existe la conversión implícita de tipos para tipos parecidos, siempre es aconsejable utilizar la conversión explícita de tipos por medio de funciones de conversión (TO_CHAR, TO_DATE, TO_NUMBER, …) y así evitar resultados inesperados.

Precedencia de operadores.

Al igual que en nuestro lenguaje matemático se utiliza una precedencia entre operadores a la hora de realizar las operaciones aritméticas, en PL/SQL también se establece dicha precedencia para evitar confusiones. Si dos operadores tienen la misma precedencia lo aconsejable es utilizar los paréntesis (al igual que hacemos en nuestro lenguaje matemático) para alterar la precedencia de los mismos, ya que las operaciones encerradas entre paréntesis tienen mayor precedencia. En la tabla siguiente se muestra la precedencia de los operadores de mayor a menor.

Precedencia de operadores.
Operador.	Operación.
**, `NOT`	Exponenciación, negación lógica.
+, `-`	Identidad, negación.
*, `/`	Multiplicación, división.
+, `-`, \|\|	Suma, resta y concatenación.
=, `¡=`, <, >, <=, >=, IS NULL, `LIKE`, BETWEEN, `IN`	Comparaciones.
AND	Conjunción lógica
OR	Disyunción lógica.

Autoevaluación

Rellena el hueco con el resultado de las siguientes operaciones.

2.3.- El bloque PL/SQL.

Ya hemos visto las unidades léxicas que componen PL/SQL, los tipos de datos que podemos utilizar y cómo se definen las variables y las constantes. Ahora vamos a ver la unidad básica en PL/SQL que es el bloque.

Un bloque PL/SQL consta de tres zonas:

Declaraciones: definiciones de variables, constantes, cursores y excepciones.
Proceso: zona donde se realizará el proceso en sí, conteniendo las sentencias ejecutables.
Excepciones: zona de manejo de errores en tiempo de ejecución.

La sintaxis es la siguiente:

[DECLARE

     [Declaración de variables, constantes, cursores y excepciones]]

BEGIN

     [Sentencias ejecutables]

[EXCEPTION

     Manejadores de excepciones]

END;

Los bloques PL/SQL pueden anidarse a cualquier nivel. Como hemos comentado anteriormente el ámbito y la visibilidad de las variables es la normal en un lenguaje procedimental. Por ejemplo, en el siguiente fragmento de código se declara la variable aux en ambos bloques, pero en el bloque anidado aux con valor igual a 10 actúa de variable global y aux con valor igual a 5 actúa como variable local, por lo que en la comparación evaluaría a FALSE, ya que al tener el mismo nombre la visibilidad dominante sería la de la variable local.

DECLARE

     aux number := 10;

BEGIN

     DECLARE

          aux number := 5;

     BEGIN

          DBMS_OUTPUT.PUT_LINE('El valor de aux es: ' || aux); --mostrar por pantalla

          IF aux = 10 THEN     --evalúa a FALSE, no entraría

...

     END;

END;

Para comenzar a ver cómo se programa en PL/SQL puedes visualizar el siguiente videotutorial donde se muestra cómo trabajar con bloques PL/SQL. Además se ve la utilización de la función DBMS_OUTPUT.PUT_LINE muy útil para mostrar por pantalla mensajes y contenidos de valores de las variables que inicialicemos, etc..

Elaboración propia - Descripción textual del vídeo. (Dominio público)

Autoevaluación

Solución

Para saber más

Ámbito y visibilidad en PL/SQL.

En el siguiente enlace podrás ampliar información sobre el ámbito y la visibilidad de las variables en PL/SQL.

2.4.- Estructuras de control condicional.

Ministerio de Educación - ITE (CC BY-NC)

En la vida constantemente tenemos que tomar decisiones que hacen que llevemos a cabo unas acciones u otras dependiendo de unas circunstancias o repetir una serie de acciones un número dado de veces o hasta que se cumpla una condición. En PL/SQL también podemos imitar estas situaciones por medio de las estructuras de control que son sentencias que nos permiten manejar el flujo de controlFlujo de controlSe llama flujo de control al orden en el que se ejecutan las instrucciones de un programa, siendo las propias instrucciones las que determinan o controlan dicho flujo. En un programa, a menos que el flujo de control se vea modificado por una instrucción de control, las instrucciones siempre se ejecutan secuencialmente, una detrás de otra. de nuestro programa, y éstas son dos: condicionales e iterativas.

Control condicional.

Las estructuras de control condicional nos permiten llevar a cabo una acción u otra dependiendo de una condición. Vemos sus diferentes variantes:

IF-THEN: Forma más simple de las sentencias de control condicional. Si la evaluación de la condición es TRUE, entonces se ejecuta la secuencia de sentencias encerradas entre el THEN y el final de la sentencia.

Sentencia IF-THEN.
Sintaxis.	Ejemplo.
IF condicion THEN secuencia_de_sentencias; END IF;	IF (b<>0) THEN c:=a/b; END IF;

IF-THEN-ELSE: Con esta forma de la sentencia ejecutaremos la primera secuencia de sentencias si la condición evalúa a TRUE y en caso contrario ejecutaremos la segunda secuencia de sentencias.

Sentencia IF-THEN-ELSE.
Sintaxis.	Ejemplo.
IF condicion THEN Secuencia_de_sentencias1; ELSE Secuencia_de_sentencias2; END IF;	IF (b>0) THEN c:=a*b;<br />ELSE<br /> c:=a+b;<br />END IF;

IF-THEN-ELSIF: Con esta última forma de la sentencia condicional podemos hacer una selección múltiple. Si la evaluación de la condición 1 da TRUE, ejecutamos la secuencia de sentencias 1, sino evaluamos la condición 2. Si esta evalúa a TRUE ejecutamos la secuencia de sentencias 2 y así para todos los ELSIF que haya. El último ELSE es opcional y es por si no se cumple ninguna de las condiciones anteriores.

Sentencia IF-THEN-ELSIF.
Sintaxis.	Ejemplo.
IF condicion1 THEN Secuencia_de_sentencias1; ELSIF condicion2 THEN Secuencia_de_sentencias2; ... [ELSE Secuencia_de_sentencias;] END IF;	IF (operacion = ‘SUMA’) THEN resultado := arg1 + arg2; ELSIF (operacion = ‘RESTA’) THEN resultado := arg1 – arg2; ELSIF (operacion = ‘PRODUCTO’) THEN resultado := arg1 * arg2; ELSIF (arg2 <> 0) AND (operacion = ‘DIVISION’) THEN resultado := arg1 / arg2; ELSE RAISE operacion_no_permitida; END IF;

Sentencia IF-THEN-ELSIF.

Sintaxis.

Ejemplo.

IF condicion1 THEN

     Secuencia_de_sentencias1;

ELSIF condicion2 THEN

     Secuencia_de_sentencias2;

...

[ELSE

     Secuencia_de_sentencias;]

END IF;

IF (operacion = ‘SUMA’) THEN

     resultado := arg1 + arg2;

ELSIF (operacion = ‘RESTA’) THEN

     resultado := arg1 – arg2;

ELSIF (operacion = ‘PRODUCTO’) THEN

     resultado := arg1 * arg2;

ELSIF (arg2 <> 0) AND (operacion = ‘DIVISION’) THEN

     resultado := arg1 / arg2;

ELSE

     RAISE operacion_no_permitida;

END IF;

Autoevaluación

Solución

2.4.1.- Estructuras de control iterativo.

Estantería con el mismo ratón de peluche repetido.

Ministerio de Educación - ITE (CC BY-NC)

Ya que hemos visto las estructuras de control condicional, veamos ahora las estructuras de control iterativo.

Control iterativo.

Estas estructuras nos permiten ejecutar una secuencia de sentencias un determinado número de veces.

LOOP: La forma más simple es el bucle infinitoBucle infinitoBucle infinito es aquel ciclo que se repite de forma indefinida, ya que su condición para finalizar nunca se cumple o no tiene dicha condición., cuya sintaxis es:
```
LOOP
```
```
     secuencia_de_sentencias;
```
```
END LOOP;
```
EXIT: Con esta sentencia forzamos a un bucle a terminar y pasa el control a la siguiente sentencia después del bucle. Un EXIT no fuerza la salida de un bloque PL/SQL, sólo la salida del bucle.
```
LOOP
```
```
     ...
```
```
     IF encontrado = TRUE THEN
```
```
          EXIT;
```
```
     END IF;
```
```
END LOOP;
```
EXIT WHEN condicion: Fuerza a salir del bucle cuando se cumple una determinada condición.
```
LOOP
```
```
     ...
```
```
     EXIT WHEN encontrado;
```
```
END LOOP;
```
WHILE LOOP: Este tipo de bucle ejecuta la secuencia de sentencias mientras la condición sea cierta.
Sentencia WHILE LOOP.

Sintaxis. Ejemplo.
WHILE condicion LOOP

Secuencia_de_sentencias;

END LOOP;
WHILE (not encontrado) LOOP

...

END LOOP;

Sentencia WHILE LOOP.
Sintaxis.	Ejemplo.
WHILE condicion LOOP Secuencia_de_sentencias; END LOOP;	WHILE (not encontrado) LOOP ... END LOOP;

FOR LOOP: Este bucle itera mientras el contador se encuentre en el rango definido.

Sentencia FOR LOOP.
Sintaxis.	Ejemplo.
FOR contador IN [REVERSE] limite_inferior..limite_superior LOOP Secuencia_de_sentencias; END LOOP;	FOR i IN 1..3 LOOP --i=1, i=2, i=3 ... END LOOP; SELECT count(*) INTO num_asist FROM ASISTENTE; FOR i IN 1..num_asist LOOP ... END LOOP; FOR i IN REVERSE 1..3 LOOP --i=3, i=2, i=1 ... END LOOP;

Sentencia FOR LOOP.

Sintaxis.

Ejemplo.

FOR contador IN [REVERSE] limite_inferior..limite_superior LOOP

     Secuencia_de_sentencias;

END LOOP;

FOR i IN 1..3 LOOP     --i=1, i=2, i=3

...

END LOOP;

SELECT count(*) INTO num_asist FROM ASISTENTE;

FOR i IN 1..num_asist LOOP

...

END LOOP;

FOR i IN REVERSE 1..3 LOOP --i=3, i=2, i=1

...

END LOOP;

Autoevaluación

Solución

2.5.- Excepciones.

Dibujo de una cara de un chico sorprendido.

Ministerio de Educación - ITE (Félix Vallés Calvo) (CC BY-NC)

Muchas veces te habrá pasado que surgen situaciones inesperadas con las que no contabas y a las que tienes que hacer frente. Pues cuando programamos con PL/SQL pasa lo mismo, que a veces tenemos que manejar errores debidos a situaciones diversas. Vamos a ver cómo tratarlos.

Cualquier situación de error es llamada excepción en PL/SQL. Cuando se detecta un error, una excepción es lanzada, es decir, la ejecución normal se para y el control se transfiere a la parte de manejo de excepciones. La parte de manejo de excepciones es la parte etiquetada como EXCEPTION y constará de sentencias para el manejo de dichas excepciones, llamadas manejadores de excepciones.

Manejadores de excepciones.
Sintaxis.	Ejemplo.
WHEN nombre_excepcion THEN <sentencias para su manejo> .... WHEN OTHERS THEN <sentencias para su manejo>	DECLARE nom_empresa VARCHAR2(30); BEGIN SELECT empresa INTO nom_empresa FROM ASISTENTE WHERE codigo = 'AS0020'; ... EXCEPTION WHEN NO_DATA_FOUND THEN --Manejamos el no haber encontrado datos WHEN OTHERS THEN --Manejamos cualquier error inesperado END;

Manejadores de excepciones.

Sintaxis.

Ejemplo.

WHEN nombre_excepcion THEN

     <sentencias para su manejo>

     ....

WHEN OTHERS THEN

     <sentencias para su manejo>

DECLARE

     nom_empresa VARCHAR2(30);

BEGIN

     SELECT empresa INTO nom_empresa FROM ASISTENTE

     WHERE codigo = 'AS0020';

...

EXCEPTION

     WHEN NO_DATA_FOUND THEN

     --Manejamos el no haber encontrado datos

WHEN OTHERS THEN

     --Manejamos cualquier error inesperado

END;

La parte OTHERS captura cualquier excepción no capturada.

Las excepciones pueden estar definidas por el usuario o definidas internamente. Las excepciones predefinidas se lanzarán automáticamente asociadas a un error de Oracle. Las excepciones definidas por el usuario deberán definirse y lanzarse explícitamente.

En PL/SQL nosotros podemos definir nuestras propias excepciones en la parte DECLARE de cualquier bloque. Estas excepciones podemos lanzarlas explícitamente por medio de la sentencia RAISE nombre_excepción.

Excepciones definidas por el usuario.
Sintaxis.	Ejemplo.
DECLARE nombre_excepcion EXCEPTION; BEGIN ... RAISE nombre_excepcion; ... END;	DECLARE gratificacion_erronea EXCEPTION; BEGIN ... IF gratificacion<0 OR gratificacion>1000 THEN RAISE gratificacion_erronea; END IF; ... EXCEPTION WHEN gratificacion_erronea THEN --manejamos la gratificación errónea END;

Excepciones definidas por el usuario.

Sintaxis.

Ejemplo.

DECLARE

     nombre_excepcion EXCEPTION;

BEGIN

...

     RAISE nombre_excepcion;

...

END;

DECLARE

     gratificacion_erronea EXCEPTION;

BEGIN

...

     IF gratificacion<0 OR gratificacion>1000 THEN

          RAISE gratificacion_erronea;

     END IF;

...

EXCEPTION

     WHEN gratificacion_erronea THEN

          --manejamos la gratificación errónea

END;

Debes conocer

Las diferentes excepciones predefinidas en Oracle, junto a su código de error asociado (que luego veremos lo que es) y una explicación de cuándo son lanzadas las puedes ver al final de la unidad en el Anexo I. Excepciones predefinidas en Oracle.

2.5.1.- Manejo de errores.

Ministerio de Educación - ITE (Iguácel Asín García) (CC BY-NC)

Ahora que ya sabemos lo que son las excepciones, cómo capturarlas y manejarlas y cómo definir y lanzar las nuestras propias. Es la hora de comentar algunos detalles sobre el uso de las mismas.

El alcance de una excepción sigue las mismas reglas que el de una variable, por lo que si nosotros redefinimos una excepción que ya es global para el bloque, la definición local prevalecerá y no podremos capturar esa excepción a menos que el bloque en la que estaba definida esa excepción fuese un bloque nombrado, y podremos capturarla usando la sintaxis: nombre_bloque.nombre_excepcion.

Las excepciones predefinidas están definidas globalmente. No necesitamos (ni debemos) redefinir las excepciones predefinidas.

DECLARE

     no_data_found EXCEPTION;

BEGIN

     SELECT * INTO ...

EXCEPTION

     WHEN no_data_found THEN     --captura la excepción local, no

                         --la global

END;

Cuando manejamos una excepción no podemos continuar por la siguiente sentencia a la que la lanzó.

DECLARE

...

BEGIN

...

     INSERT INTO asistente VALUES (v_cod_as,v_nomAsis,v_ape1,v_ape2,null,null,v_empresa);

     INSERT INTO ponente VALUES (v_cod_p, v_nomPonente, null, null, v_especialidad);

...

EXCEPTION

     WHEN DUP_VAL_ON_INDEX THEN

          --manejamos la excepción debida a que el código de

          --asistente ya existe, pero no podemos continuar por

          --el INSERT INTO ponente, a no ser que lo pongamos

          --explícitamente en el manejador

END;

Pero sí podemos encerrar la sentencia dentro de un bloque, y ahí capturar las posibles excepciones, para continuar con las siguientes sentencias.

DECLARE
     v_cod_as VARCHAR2(6):='AS0001';
     v_nomAsis VARCHAR2(20):='Pepe';
     v_ape1 VARCHAR2(20):='Ray';
     v_ape2 VARCHAR2(20):='González';
     v_fecha DATE:='16/10/90';
     v_empresa VARCHAR2(20):='BigSoft';
     v_cod_p VARCHAR2(6):='ESP005';
     v_nomPonente VARCHAR2(20):='Víctor';
     v_ape1Ponente VARCHAR2(20):='Gil';
     v_especialidad VARCHAR2(60):='Bases de Datos';

BEGIN -- Comienza el bloque 1.

     dbms_output.put_line('entra en el primer bloque.'); --Mostramos mensaje en pantalla.

     BEGIN -- Comienza el bloque 2.
          --Intentamos insertar en ASISTENTES un registro cuyo código está duplicado.
          INSERT INTO asistente VALUES (v_cod_as,v_nomAsis,v_ape1,v_ape2,null,v_fecha,v_empresa);

     EXCEPTION         --Definimos esta excepción en el bloque 2.
          WHEN DUP_VAL_ON_INDEX THEN
               dbms_output.put_line('El código de asistente está duplicado.');

     END; --Termina el bloque 2.
     --Insertamos en la tabla PONENTE sin problemas el registro porque no hay duplicidades.
     INSERT INTO ponente VALUES (v_cod_p, v_nomPonente, v_ape1Ponente, null, v_especialidad);

END; --Termina el bloque 1.

Ejercicio Resuelto

¿Cómo capturarías la excepción que se produce cuando buscamos en la tabla ASISTENTE el nombre de uno de ellos indicando su código como condición? Prueba a pasar primero un código que sí exista y después otro que no exista para comprobar el funcionamiento del manipulador de excepciones.

Retroalimentación

Con el siguiente código podemos probar que pasando un valor en el código de asistente que sí exista como por ejemplo 'AS0001' se devuelve el mensaje correcto con el nombre del asistente. Pero si cambiamos el valor de la variable v_cod por AS0031' que sabemos que no existe en la base de datos, se ejecutará la excepción por el motivo de no encontrar el dato y realizará la instrucción de mostrar en pantalla el mensaje de error que le hemos indicado.

DECLARE
v_nom VARCHAR2(40);
v_cod VARCHAR2(40):='AS0001';  --Después pondríamos el valor 'AS0031' y comprobamos que manejamos correctamente el error.

BEGIN 
    --Seleccionamos el nombre (si existe) del asistente y lo guardamos en la variable v_nom.
    SELECT nombre INTO v_nom FROM ASISTENTE WHERE codigo = v_cod;
    
    --Mostramos mensaje si se ha recuperado el dato buscado.
    DBMS_OUTPUT.PUT_LINE('El asistente se llama: ' || v_nom);
    
EXCEPTION
    --Definimos la excepción y mostramos mensaje.
    WHEN NO_DATA_FOUND THEN
        dbms_output.put_line('No existe ningún asistente con ese código.');

END;

2.5.2.- Manejo de errores (I).

Resumen textual alternativo

Escultura en la que se ve un ojo pinchado en un tenedor.

Ministerio de Educación - ITE (Elena Hervás) (CC BY-NC)

Continuemos viendo algunos detalles a tener en cuenta, relativos al uso de las excepciones.

Cuando ejecutamos varias sentencias seguidas del mismo tipo y queremos capturar alguna posible excepción debida al tipo de sentencia, podemos encapsular cada sentencia en un bloque y manejar en cada bloque la excepción, o podemos utilizar una variable localizadora para saber qué sentencia ha sido la que ha lanzado la excepción (aunque de esta manera no podremos continuar por la siguiente sentencia).

DECLARE

     sentencia NUMBER := 0;

BEGIN

...

     SELECT * FROM asistente...

     sentencia := 1;

     SELECT * FROM ponente...

     sentencia := 2;

     SELECT * FROM sala...

...

EXCEPTION

     WHEN NO_DATA_FOUND THEN

          IF sentencia = 0 THEN

               RAISE asistente_no_encontrado;

          ELSIF sentencia = 1 THEN

               RAISE ponente_no_encontrado;

          ELSIF sentencia = 2 THEN

               RAISE sala_no_encontrada;

          END IF;

END;

Si la excepción es capturada por un manejador de excepción apropiado, ésta es tratada y posteriormente el control es devuelto al bloque superior. Si la excepción no es capturada y no existe bloque superior, el control se devolverá al entorno. También puede darse que la excepción sea manejada en un bloque superior a falta de manejadores para ella en los bloques internos, la excepción se propaga de un bloque al superior y así hasta que sea manejada o no queden bloques superiores con lo que el control se devuelve al entorno. Una excepción también puede ser relanzada en un manejador. En la siguiente presentación puedes ver cómo se propagan diferentes excepciones entre diferentes bloques.

Propagación Excepciones (pdf - 41,22 KB)

Propagación de las excepciones en PL/SQL

Propagación de las excepciones (a)

Propagación de las excepciones (b)

Propagación de las excepciones (c)

Autoevaluación

Solución

3.- Tipos de datos compuestos.

Caso práctico

Ministerio de Educación (CC BY-NC)

María, gracias a la ayuda de Juan, ha comprendido muy bien el manejo básico de PL/SQL. Juan le comenta que en la mayoría de los lenguajes de programación, además de los tipos de datos simples, existen tipos de datos compuestos que le dan mucha más versatibilidad a los mismos y una gran potencia. Juan no conoce bien si PL/SQL dispone de estos tipos de datos y si dispone de ellos ¿de cuáles?

María y Juan van a hablar con Ada para ver si les puede aclarar un poco la situación y dar unas pequeñas pautas para empezar. Ada les comenta que claro que PL/SQL cuenta con este tipo de datos, pero que hoy tiene una reunión importantísima y que tiene que terminar de preparársela, por lo que los remite al capítulo sobre tipos de datos compuestos del manual que les pasó. Juan y María le dicen que no se preocupe y que ya verá como a la vuelta de esa reunión son capaces de saber cuáles son e incluso de dominarlos. Ada, para motivarlos, les dice que si es así los invita a un aperitivo a su vuelta. Así que Juan y María se ponen con el capítulo de tipos de datos compuestos del manual para ver si pueden sorprender a Ada a su vuelta.

En el capítulo anterior, entre otras cosas, hemos conocido los tipos de datos simples con los que cuenta PL/SQL. Pero dependiendo de la complejidad de los problemas, necesitamos disponer de otras estructuras en las que apoyarnos para poder modelar nuestro problema. En este capítulo nos vamos a centrar en conocer los tipos de datos complejos que nos ofrece PL/SQL y cómo utilizarlos para así poder sacarle el mayor partido posible.

Citas para pensar

"Todo lo complejo puede dividirse en partes simples".René Descartes.

3.1.- Registros.

El uso de los registros es algo muy común en los lenguajes de programación. PL/SQL también nos ofrece este tipo de datos. En este apartado veremos qué son y cómo definirlos y utilizarlos.

Un registro es un grupo de elementos relacionados almacenados en campos, cada uno de los cuales tiene su propio nombre y tipo de dato.

Imagen de una carta con su sello y con la dirección de destino.

Ministerio de Educación - ITE(Clarissa Rodrígues González) (CC BY-NC)

Por ejemplo, una dirección podría ser un registro con campos como calle, número, piso, puerta, código postal, ciudad, provincia y país. Los registros hacen que la información sea más fácil de organizar y representar. Para declarar un registro seguiremos la siguiente sintaxis:

TYPE nombre_tipo IS RECORD (decl_campo[, decl_campo] ...);

donde:

decl_campo := nombre tipo [[NOT NULL] {:=|DEFAULT} expresion]

El tipo del campo será cualquier tipo de dato válido en PL/SQL excepto REF CURSOR. La expresión será cualquier expresión que evalúe al tipo de dato del campo.

TYPE direccion IS RECORD

calle          VARCHAR2(50),

numero          INTEGER(4),

piso          INTEGER(4),

puerta          VARCHAR2(2),

codigo_postal     INTEGER(5),

ciudad          VARCHAR2(30),

provincia     VARCHAR2(20),

pais          VARCHAR2(20) := ‘España’

);

mi_direccion direccion;

Para acceder a los campos usaremos la notación del punto.

...

mi_direccion.calle := ‘Ramirez Arellano’;

mi_direccion.numero := 15;

...

Autoevaluación

Solución

3.2.- Colecciones.

Una colección es un grupo ordenado de elementos, todos del mismo tipo. Cada elemento tiene un subíndice único que determina su posición en la colección.

Estantería llena de libros de diferentes tamaños.

Ministerio de Educación - ITE (CC BY-NC)

En PL/SQL las colecciones sólo pueden tener una dimensión. PL/SQL ofrece 2 clases de colecciones: arrays de longitud variable y tablas anidadas.

En este módulo nos centraremos en los arrays de longitud variable, viendo en esta unidad una introducción a su declaración, inicialización y utilidad pero dejando para la siguiente unidad una mayor profundización de este tipo de datos compuesto.

Arrays de longitud variable.

Los elementos del tipo VARRAY son los llamados arrays de longitud variable. Son como los arrays de cualquier otro lenguaje de programación, pero con la salvedad de que a la hora de declararlos, nosotros indicamos su tamaño máximo y el array podrá ir creciendo dinámicamente hasta alcanzar ese tamaño. Un VARRAY siempre tiene un límite inferior igual a 1 y un límite superior igual al tamaño máximo.

Para declarar un VARRAY usaremos la sintaxis:

TYPE nombre IS {VARRAY | VARYING} (tamaño_máximo) OF tipo_elementos [NOT NULL];

Donde tamaño_máximo será un entero positivo y tipo_elementos será cualquier tipo de dato válido en PL/SQL, excepto BINARY_INTEGER, BOOLEAN, LONG, LONG RAW, NATURAL, NATURALN, NCHAR, NCLOB, NVARCHAR2, objetos que tengan como atributos TABLE o VARRAY, PLS_INTEGER, POSITIVE, POSITIVEN, SIGNTYPE, STRING, TABLE, VARRAY. Si tipo_elementos es un registro, todos los campos deberían ser de un tipo escalar.

Cuando definimos un VARRAY, éste es automáticamente nulo, por lo que para empezar a utilizarlo deberemos inicializarlo. Para ello podemos usar un constructor:

TYPE colores IS VARRAY(3) OF VARCHAR2;

colores_primarios colores := colores('Rojo','Amarillo','Azul');

Para referenciar elementos en un VARRAY utilizaremos la sintaxis nombre_colección(subíndice).

IF <strong>colores_primarios(1)</strong> = 'Azul' THEN ...

Para saber más

Para comprender más el uso de los VARRAY los estudiaremos en profundidad en la siguiente unidad siguiente (Unidad 7 - Bases de Datos Objeto-Relacionales).

Ahora y sólo por curiosidad se presentan algunas características y atributos de este tipo de dato que más se utilizan:

Para extender un VARRAY usaremos el método EXTEND. Sin parámetros, extendemos en 1 elemento nulo el VARRAY. EXTEND(n) añade n elementos nulos al VARRAY y EXTEND(n,i) añade n copias del i-ésimo elemento.
COUNT nos dirá el número de elementos del VARRAY. LIMIT nos dice el tamaño máximo del VARRAY. FIRST siempre será 1. LAST siempre será igual a COUNT. PRIOR y NEXT devolverá el antecesor y el sucesor del elemento.
Al trabajar con VARRAY podemos hacer que salte alguna de las siguientes excepciones, debidas a un mal uso de los mismos: COLECTION_IS_NULL, SUBSCRIPT_BEYOND_COUNT, SUBSCRIPT_OUTSIDE_LIMIT y VALUE_ERROR.

3.3.- Cursores.

En los apartados anteriores hemos visto con algunas pinceladas algunos tipos de datos compuestos cuyo uso es común en otros lenguajes de programación. Sin embargo, en este apartado vamos a ver un tipo de dato más en profundidad, que aunque se puede asemejar a otros que ya conozcas, su uso es exclusivo en la programación de las bases de datos y que es el cursor.

Un cursor no es más que una estructura que almacena el conjunto de filas devuelto por una consulta a la base de datos.

Vista de un auditorio con muchas filas de butacas vacías.

Ministerio de Educación - ITE (CC BY-NC)

Oracle usa áreas de trabajo para ejecutar sentencias SQL y almacenar la información procesada. Hay 2 clases de cursores:

Implícitos: PL/SQL declara implícitamente un cursor para todas las sentencias SQL de manipulación de datos, incluyendo consultas que devuelven una sola fila.
Explícitos: Para las consultas que devuelven más de una fila, se debe declarar explícitamente un cursor para procesar las filas individualmente.

Cursores implícitos.

En este primer apartado vamos a hablar de los cursores implícitos y veremos un ejemplo dentro de un bloque PL/SQL.

La sintaxis de un cursor implícito es muy sencilla. Sólo tenemos que poner entre la cláusula SELECT y FROM la palabra reservada INTO para poder volcar los datos recuperados de los campos en las variables. Por eso es fundamental que la sentencia SELECT sólo devuelva un único registro, para que se puedan inicializar las variables correctamente.

SELECT nombre_campos INTO nombre_variables FROM TABLA WHERE...(condición);

Aquí se muestra un ejemplo de cursor implícito donde se recupera el nombre y apellidos del asistente con código AS0001 y se almacenan sus valores en las variables declaradas previamente.

SET SERVEROUTPUT ON; --Activamos la salida por pantalla

DECLARE
-- Declaramos las variables del mismo tipo que los campos que vamos a recuperar
v_nom VARCHAR2(40);
v_ape1 VARCHAR2(40);
v_ape2 VARCHAR2(40);

BEGIN 
    -- Obtenermos el nombre y apellidos del asistente AS0001 y 
    -- con INTO volvamos sus valores en las variables.
    SELECT nombre, apellido1, apellido2 INTO v_nom, v_ape1, v_ape2 
    FROM ASISTENTE 
    WHERE codigo = 'AS0001';
    
    --Mostramos por pantalla los contenidos de las variables.
    DBMS_OUTPUT.PUT_LINE('El asistente se llama: ' || v_nom || ' ' ||
                                                      v_ape1 || ' ' ||
                                                      v_ape2);

END;

Debes conocer

Aunque todavía no hemos visto las operaciones que se pueden realizar con un cursor explícito, es conveniente que te vayas familiarizando con la evaluación de sus atributos según las operaciones que hayamos realizado con el cursor y que tomarán pleno sentido cuando veamos el siguiente apartado. Lo puedes ver en el Anexo II. Evaluación de los atributos de un cursor explícito.

3.3.1.- Cursores explícitos.

Chico en una biblioteca consultando un libro.

Ministerio de Educación - ITE (CC BY-NC)

Cuando una consulta devuelve múltiples filas, podemos declarar explícitamente un cursor para procesar las filas devueltas. Es importante conocer los atributos de un cursor explícito.

Cada cursor tiene 4 atributos que podemos usar para obtener información sobre la ejecución del mismo o sobre los datos. Estos atributos pueden ser usados en PL/SQL, pero no en SQL.

%FOUND: Después de que el cursor esté abierto y antes del primer FETCH, %FOUND devuelve NULL. Después del primer FETCH, %FOUND devolverá TRUE si el último FETCH ha devuelto una fila y FALSE en caso contrario. Para cursores implícitos %FOUND devuelve TRUE si un INSERT, UPDATE o DELETE afectan a una o más de una fila, o un SELECT ... INTO ... devuelve una o más filas. En otro caso %FOUND devuelve FALSE.
%NOTFOUND: Es lógicamente lo contrario a %FOUND.
%ISOPEN: Evalúa a TRUE si el cursor está abierto y FALSE en caso contrario. Para cursores implícitos, como Oracle los cierra automáticamente, %ISOPEN evalúa siempre a FALSE.
%ROWCOUNT: Para un cursor abierto y antes del primer FETCH, %ROWCOUNT evalúa a 0. Después de cada FETCH, %ROWCOUNT es incrementado y evalúa al número de filas que hemos procesado. Para cursores implícitos %ROWCOUNT evalúa al número de filas afectadas por un INSERT, UPDATE o DELETE o el número de filas devueltas por un SELECT ... INTO ...

Cuando declaramos un cursor, lo que hacemos es darle un nombre y asociarle una consulta usando la siguiente sintaxis:

CURSOR nombre_cursor [(parametro [, parametro] ...)] [RETURN tipo_devuelto] IS sentencia_select;

Donde tipo_devuelto debe representar un registro o una fila de una tabla de la base de datos, y parámetro sigue la siguiente sintaxis:

parametro := nombre_parametro [IN] tipo_dato [{:= | DEFAULT} expresion]

Ejemplo:

CURSOR cAsistentes IS SELECT nombre, apellido1, apellido2 FROM ASISTENTE;

CURSOR cConferencias RETURN conferencia%ROWTYPE IS SELECT * FROM CONFERENCIA WHERE ...

Además, como hemos visto en la declaración, un cursor puede tomar parámetros, los cuales pueden aparecer en la consulta asociada como si fuesen constantes. Los parámetros serán de entrada, un cursor no puede devolver valores en los parámetros actuales. A un parámetro de un cursor no podemos imponerle la restricción NOT NULL.

CURSOR c1 (cantidad INTEGER DEFAULT 0) IS SELECT * FROM PARTICIPAR WHERE gratificacion = cantidad;

Cuando abrimos un cursor, lo que se hace es ejecutar la consulta asociada e identificar el conjunto resultado, que serán todas las filas que emparejen con el criterio de búsqueda de la consulta. Para abrir un cursor usamos la sintaxis:

OPEN nombre_cursor [(parametro [, parametro] ...)];

Ejemplos:

OPEN cAsistentes;

OPEN c1(450);

OPEN c1;

La sentencia FETCH devuelve una fila del conjunto resultado. Después de cada FETCH, el cursor avanza a la próxima fila en el conjunto resultado.

FETCH cAsistentes INTO v_nom, v_ape1, v_ape2;

Para cada valor de columna devuelto por la consulta asociada al cursor, debe haber una variable que se corresponda en la lista de variables después del INTO.

Para procesar un cursor entero deberemos hacerlo por medio de un bucle.

BEGIN

...

OPEN cAsistentes;

LOOP

     FETCH cAsistentes INTO v_nom, v_ape1, v_ape2;

     EXIT WHEN cAsistentes%NOTFOUND;

...

END LOOP;

...

END;

Una vez procesado el cursor, deberemos cerrarlo, con lo que deshabilitamos el cursor y el conjunto resultado queda indefinido.

CLOSE cAsistentes;

Una vez cerrado el cursor podemos volverlo a abrir, pero cualquier otra operación que hagamos con el cursor cerrado lanzará la excepción INVALID_CURSOR.

También podemos simplificar la operación de procesamiento de un cursor, por medio de los bucles para cursores, los cuales declaran implícitamente una variable índice definida como %ROWTYPE para el cursor, abren el cursor, se van trayendo los valores de cada fila del cursor, almacenándolas en la variable índice, y finalmente cierran el cursor.

BEGIN

  -- cAsisRec se declara implícitamente si usamos la estructura iterativa FOR.

  -- cAsisRec será de tipo %ROWTYPE y por tanto almacena los campos de la fila cursor.

     FOR cAsisRec IN cAsistentes LOOP

          --Procesamos las filas accediendo a cAsisRec.(nombreCampo)

          DBMS_OUTPUT.PUT_LINE(cAsisRec.nombre || ' ' || cAsisRec.apellido1 );

     END LOOP;

...

END;

Autoevaluación

Solución

Debes conocer

En los siguientes videotutoriales puedes ver cómo se trabaja con cursores implícitos y cursores explícitos. Básicamente la diferencia está en el resultado que obtenemos de la sentencia de consulta que hagamos. Cuando la sentencia de consulta sólo recupera un registro por cada uno de los campos que ponemos en la cláusula SELECT podemos guardar esos valores únicos en variables para después trabajar con ellos. Si por el contrario, la sentencia de consulta devuelve más de un registro, necesitamos declarar un cursor explícito para ir recogiendo esos valores, registro por registro.

Elaboración propia - Descripción textual del vídeo (Dominio público)

Elaboración propia. - Descripción textual del vídeo (Dominio público)

4.- Abstracción en PL/SQL.

Caso práctico

Ministerio de Educación - ITE (CC BY-NC)

María, gracias a la ayuda de Juan, tiene bastante claro cómo programar en PL/SQL, pero no entiende muy bien cómo integrar todo esto con la base de datos de juegos on-line. Sabe que puede utilizar unos tipos de datos, que hay unas estructuras de control y que se pueden manejar los errores que surjan, pero lo que no sabe es cómo y donde utilizar todo eso.

Juan le explica que lo que hasta ahora ha aprendido es el comienzo, pero que ahora viene lo bueno y que será donde le va a encontrar pleno sentido a lo aprendido anteriormente. Le explica que PL/SQL permite crear funciones y procedimientos y además agruparlos en paquetes y que eso será lo que realmente van a hacer con la base de datos de juegos on-line. Deberán ver qué es lo que utilizan más comúnmente e implementarlo en PL/SQL utilizando funciones y procedimientos según convenga. Juan la tranquiliza y le dice que lo primero que va a hacer es explicarle cómo se escriben dichas funciones y procedimientos y luego pasarán a implementar alguno y que así verá la potencia real de PL/SQL. María se queda más tranquila y está deseando implementar esa primera función o procedimiento que le resolverá la gran duda que tiene.

Hoy día cualquier lenguaje de programación permite definir diferentes grados de abstracción en sus programas. La abstracción permite a los programadores crear unidades lógicas y posteriormente utilizarlas pensando en qué hace y no en cómo lo hace. La abstracción se consigue utilizando funciones, procedimientos, librerías, objetos, etc.

PL/SQL nos permite definir funciones, procedimientos y disparadores entre otras muchas funcionalidades. También permite la utilización de objetos y por tanto utilizar el paradigma de la orientación a objetos como veremos en la siguiente unidad del módulo. Pero ahora nos centraremos en la programación con los diferentes subprogramas que podemos hacer con este lenguaje.

Para saber más

Abstracción en los lenguajes de programación.

En los siguientes enlaces puedes ampliar información sobre la abstracción en programación.

Programación dirigida a objetos.

4.1.- Subprogramas.

Los subprogramas son bloques nombrados a los cuales les podemos pasar parámetros y los podemos invocar. Además, los subprogramas pueden estar almacenados en la base de datos o estar encerrados en otros bloques. Si el programa está almacenado en la base de datos, podremos invocarlo si tenemos permisos suficientes y si está encerrado en otro bloque lo podremos invocar si tenemos visibilidad sobre el mismo.

Hay dos clases de subprogramas: las funciones y los procedimientos. Las funciones devuelven un valor y los procedimientos no.

Para declarar un subprograma utilizamos la siguiente sintaxis:

Sintaxis para la declaración de subprogramas.
Funciones.	Procedimientos.
CREATE OR REPLACE FUNCTION nombre [(parametro [, parametro] ...)] RETURN tipo_dato IS [declaraciones_locales] BEGIN sentencias_ejecutables [EXCEPTION manejadores_de_excepciones] END [nombre];	CREATE OR REPLACE PROCEDURE nombre [( parametro [, parametro] ... )] IS [declaraciones_locales] BEGIN sentencias_ejecutables [EXCEPTION manejadores_de_excepciones] END [nombre];

Sintaxis para la declaración de subprogramas.

Funciones.

Procedimientos.

CREATE OR REPLACE FUNCTION nombre [(parametro [, parametro] ...)]

RETURN tipo_dato IS

[declaraciones_locales]

BEGIN

sentencias_ejecutables

[EXCEPTION

manejadores_de_excepciones]

END [nombre];

CREATE OR REPLACE PROCEDURE nombre [( parametro [, parametro] ... )] IS

     [declaraciones_locales]

BEGIN

sentencias_ejecutables

[EXCEPTION

manejadores_de_excepciones]

END [nombre];

Donde:

parametro := nombre_parametro [IN|OUT|IN OUT] tipo_dato [{:=|DEFAULT} expresion]

Las variables pasadas como parámetros a un subprograma son llamadas parámetros actuales. Las variables referenciadas en la especificación del subprograma como parámetros, son llamadas parámetros formales.

Parámetros de los subprogramas:

Ministerio de Educación - ITE (Félix Vallés Calvo) (CC BY-NC)

Cuando llamamos a un subprograma, los parámetros actuales podemos escribirlos utilizando notación posicional o notación nombrada, es decir, la asociación entre parámetros actuales y formales podemos hacerla por posición o por nombre.
Cuando llamamos a un subprograma, los parámetros actuales podemos escribirlos utilizando notación posicional o notación nombrada, es decir, la asociación entre parámetros actuales y formales podemos hacerla por posición o por nombre.
En la notación posicional, el primer parámetro actual se asocia con el primer parámetro formal, el segundo con el segundo, y así para el resto. En la notación nombrada usamos el operador => para asociar el parámetro actual al parámetro formal. También podemos usar notación mixta.
Los parámetros pueden ser de entrada al subprograma, de salida, o de entrada/salida. Por defecto si a un parámetro no le especificamos el modo, éste será de entrada. Si el parámetro es de salida o de entrada/salida, el parámetro actual debe ser una variable.
Un parámetro de entrada permite que pasemos valores al subprograma y no puede ser modificado en el cuerpo del subprograma. El parámetro actual pasado a un subprograma como parámetro formal de entrada puede ser una constante o una variable.
Un parámetro de salida permite devolver valores y dentro del subprograma actúa como variable no inicializada. El parámetro formal debe ser siempre una variable.
Un parámetro de entrada-salida se utiliza para pasar valores al subprograma y/o para recibirlos, por lo que un parámetro formal que actúe como parámetro actual de entrada-salida siempre deberá ser una variable.
Los parámetros de entrada los podemos inicializar a un valor por defecto. Si un subprograma tiene un parámetro inicializado con un valor por defecto, podemos invocarlo prescindiendo del parámetro y aceptando el valor por defecto o pasando el parámetro y sobreescribiendo el valor por defecto. Si queremos prescindir de un parámetro colocado entre medias de otros, deberemos usar notación nombrada o si los parámetros restantes también tienen valor por defecto, omitirlos todos.

Cuando almacenamos un subprograma en la base de datos éste es compilado antes. Si hay algún error se nos informará de los mismos y deberemos corregirlos por medio de la cláusula OR REPLACE, antes de que el subprograma pueda ser utilizado.

Hay varias vistas del diccionario de datos que nos ayudan a llevar un control de los subprogramas, tanto para ver su código, como los errores de compilación. También hay algunos comandos de SQL*Plus que nos ayudan a hacer lo mismo pero de forma algo menos engorrosa.

Vistas y comandos asociados a los subprogramas.
Información almacenada.	Vista del diccionario.	Comando.
Código fuente.	USER_SOURCE	DESCRIBE
Errores de compilación.	USER_ERRORS	SHOW ERRORS
Ocupación de memoria.	USER_OBJECT_SIZE

También existe la vista USER_OBJECTS de la cual podemos obtener los nombres de todos los subprogramas almacenados.

Autoevaluación

Solución

4.1.1.- Ejemplos de procedimientos.

Ilustración de una caja con forma de cubo y adornada cada cara con diferentes figuras y colores.

Ministerio de Educación - ITE (Félix Vallés Calvo) (CC BY-NC)

Para almacenar un procedimiento en la base de datos utilizaremos la misma sintaxis que para declararlo, anteponiendo CREATE [OR REPLACE] a PROCEDURE, y finalizando el subprograma con una línea que simplemente contendrá el carácter '/' para indicarle a Oracle que termina ahí. Si especificamos OR REPLACE y el procedimiento ya existía, éste será reemplazado. Si no lo especificamos y el subprograma ya existe, Oracle nos devolverá un error indicando que el nombre ya está siendo utilizado por otro objeto de la base de datos.

Vamos a seguir utilizando la base de datos Conferencias y vamos a crear un procedimiento que imprima por pantalla todas las conferencias que se han realizado en una determinada sala que pasamos como parámetro. El código del procedimiento sería:

create or replace PROCEDURE ver_conferencias (nom_sala VARCHAR2)
AS
-- Declaramos el cursor con la sentencia apropiada.
CURSOR cConferencias 
IS
SELECT REFERENCIA, TEMA, PRECIO, FECHA, TURNO 
FROM CONFERENCIA 
WHERE UPPER(SALA) = UPPER(nom_sala);

-- Declaramos la variable de tipo fila del cursor.
v_conferencias cConferencias%ROWTYPE;

BEGIN
--Abrimos el cursor
OPEN cConferencias;
-- Leemos la primera fila recuperada y la guardamos en la variable.
FETCH cConferencias INTO v_conferencias;

-- Con un bucle recorrer todas las filas del cursor.
WHILE cConferencias%FOUND LOOP
    -- Escribimos por pantalla los valores del registro actual.
    DBMS_OUTPUT.PUT_LINE('Confer: ' || v_conferencias.referencia || 
                          ' - ' || v_conferencias.tema ||
                          ' - ' || v_conferencias.precio ||
                          ' - ' || v_conferencias.fecha ||
                          ' - ' || v_conferencias.turno);
    -- Pasamos a coger el siguiente registro y lo almacenamos.
    FETCH cConferencias INTO v_conferencias;

-- Finalizamos el bucle. 
END LOOP;

-- Cerramos el cursor.
CLOSE cConferencias;

END ver_conferencias;

Para invocar al procedimiento almacenado podremos realizarlo a través de la interfaz gráfica de SQL Developer ejecutando y viendo el resultado en la ventana de salida, o también se puede utilizar tanto la sentencia EXECUTE como la sentencia CALL desde línea de comando e incluso invocarlo desde un bloque PL/SQL.

-- Se puede invocar con EXECUTE.

EXECUTE ver_conferencias('Afrodita');

-- Y también se podría usar CALL.

CALL ver_conferencias('Zeus');

-- O incluso dentro de un bloque de PL/SQL

BEGIN

   ver_conferencias('Apolo');

END;

Debes conocer

En el siguiente videotutorial puedes ver cómo se realiza un procedimiento desde el inicio hasta el final y cómo se compila para comprobar errores antes de ejecutarlo o invocarlo de diferentes formas para comprobar su correcto funcionamiento.

Elaboración propia - Descripción textual del vídeo. (Dominio público)

Autoevaluación

Solución

4.1.2.- Ejemplos de funciones.

Ministerio de Educación - ITE (CC BY-NC)

De la misma forma que hemos hecho para los procedimientos, ahora con las funciones usaremos la sintaxis que ya hemos visto. También emplearemos OR REPLACE para que si la función ya existía y la volvemos a compilar no haya error.

Fíjate en el siguiente código de la función que obtiene para una determinada empresa que se pasa por parámetro el total gastado de sus asistentes o empleados que han asistido a algunas de las conferencias.

CREATE OR REPLACE FUNCTION gasto_empresa(nom_empresa varchar2)
RETURN NUMBER  -- Devolvemos un valor de tipo numérico.
AS
-- Declaración de variables.
total_gasto NUMBER;

BEGIN
-- Podemos inicializar la variable con un valor inicial.
total_gasto :=0;

-- Creamos la sentencia y guardamos el resultado con un cursor implícito.
select sum(precio) into total_gasto
from asistente, conferencia, asistir
where codigo=codAsistente
and refConferencia=referencia
and UPPER(empresa) = UPPER(nom_empresa);

-- Devuelve el resultado obtenido y almacenado en dicha variable.
RETURN (total_gasto);

END gasto_empresa;

Podemos invocar a la función de diferentes formas, entre ellas, mediante la interfaz gráfica de SQL Developer ejecutando el subprograma e introduciendo el valor del parámetro de entrada para después visualizar la salida en la ventana o pestaña de variables de salida.

Pero también podemos hacerlo mediante código usando por ejemplo una sentencia SELECT como se muestra a continuación:

SELECT EMPRESA, GASTO_EMPRESA(EMPRESA) FROM ASISTENTE
WHERE EMPRESA IS NOT NULL
GROUP BY EMPRESA;

O incluso con un bloque PL/SQL e invocando la llamada de la función para inicializar una variable cuyo resultado imprimiremos en pantalla siguiendo por ejemplo este código:

set serveroutput on; --Activamos la salida por pantalla
declare
    total NUMBER; --Declaramos variable para almacenar el total
    empre VARCHAR2(20); -- Declaramos variable para la empresa
begin
    empre := 'BigSoft'; --Asignamos un nombre de empresa
    total := gasto_empresa(empre); -- Invocamos a la función que devuelve el total.
    DBMS_OUTPUT.PUT_LINE('El gasto de la empresa ' || empre || ' ha sido: ' || total);
end;

Debes conocer

En el siguiente videotutorial puedes ver cómo se realiza una función paso a paso y cómo se puede comprobar posteriormente el resultado y el funcionamiento de la misma.

Elaboración propia - Descripción textual del vídeo (Dominio público)

Ejercicio Resuelto

Crea una función donde se pase el código de un ponente que tengamos en la base de datos y nos devuelva el total de las gratificaciones que ha sumado dicho ponente con todas las conferencias en las que ha participado.

Retroalimentación

Para crear esta función emplearemos la misma sintaxis que ya conoces. Recuerda que lo más complicado será obtener la sentencia SQL que obtiene el resultado que se pide. Para ello es importante que primero practicas de forma independiente y cuando consigas generar el resultado esperado la introduzcas en el esqueleto de la función quedando algo tal que así:

create or replace FUNCTION sueldo_ponente(cod_ponente varchar2)
RETURN NUMBER  -- Devolvemos un valor de tipo numérico.
AS
-- Declaración de variables.
suma_salario NUMBER;

BEGIN
-- Podemos inicializar la variable con un valor inicial.
suma_salario :=0;

-- Creamos la sentencia y guardamos el resultado con un cursor implícito.
SELECT SUM(GRATIFICACION) INTO suma_salario
FROM PARTICIPAR
WHERE UPPER(CODPONENTE)=UPPER(cod_ponente);

-- Devuelve el resultado obtenido y almacenado en dicha variable.
RETURN (suma_salario);

END sueldo_ponente;

Para invocar a la función recién creada usemos por ejemplo la llamada desde una sentencia de consulta SELECT aunque se podría realizar de cualquiera de las otras formas vistas anteriormente.

SELECT codigo, SUELDO_PONENTE(CODIGO) FROM PONENTE GROUP BY CODIGO;

5.- Disparadores.

Caso práctico

Ilustración en la que se representa un chico rodeado de muchas columnas y una tira de papel con algún texto se extiende por entre todas las columnas.

Ministerio de Educación - ITE (Loren) (CC BY-NC)

Juan y María ya han hecho un paquete en el que tienen agrupadas las funciones más usuales que realizan sobre la base de datos de juegos on-line. Sin embargo, María ve que hay cosas que aún no pueden controlar. Por ejemplo, María quiere que la clave y el usuario de un jugador o jugadora no puedan ser la misma y eso no sabe cómo hacerlo. Juan le dice que para ese cometido están los disparadores y sin más dilaciones se pone a explicarle a María para qué sirven y cómo utilizarlos.

En este apartado vamos a tratar una herramienta muy potente proporcionada por PL/SQL para programar nuestra base de datos que son los disparadores o triggers en inglés.

Pero, ¿qué es un disparador?

Un disparador no es más que un procedimiento que es ejecutado cuando se realiza alguna sentencia de manipulación de datos sobre una tabla dada y bajo unas circunstancias establecidas a la hora de definirlo.

Por lo que un disparador puede ser usado para:

Llevar a cabo auditorías sobre la historia de los datos en nuestra base de datos.
Garantizar complejas reglas de integridad.
Automatizar la generación de valores derivados de columnas.
Etc.

Cuando diseñamos un disparador debemos tener en cuenta que:

No debemos definir disparadores que dupliquen la funcionalidad que ya incorpora Oracle.
Debemos limitar el tamaño de nuestros disparadores, y si estos son muy grandes codificarlos por medio de subprogramas que sean llamados desde el disparador.
Cuidar la creación de disparadores recursivos.
Un disparador puede ser lanzado antes o después de realizar la operación que lo lanza. Por lo que tendremos disparadores BEFORE y disparadores AFTER.
Un disparador puede ser lanzado una vez por sentencia o una vez por cada fila a la que afecta. Por lo que tendremos disparadores de sentencia y disparadores de fila.
Un disparador puede ser lanzado al insertar, al actualizar o al borrar de una tabla, por lo que tendremos disparadores INSERT, UPDATE o DELETE (o mezclados).

Autoevaluación

Solución

5.1.- Definición de disparadores.

Ilustración en la que se ven dos chicos, un cañón y se puede leer “Bang!”.

Ministerio de Educación - ITE (Loren) (CC BY-NC)

Por lo visto anteriormente, para definir un disparador deberemos indicar si será lanzado antes o después de la ejecución de la sentencia que lo lanza, si se lanzará una vez por sentencia o una vez por fila a la que afecta, y si será lanzado al insertar y/o al actualizar y/o al borrar. La sintaxis que seguiremos para definir un disparador será la siguiente:

CREATE [OR REPLACE] TRIGGER nombre

momento acontecimiento ON tabla

[[REFERENCING (old AS alias_old|new AS alias_new)

FOR EACH ROW

[WHEN condicion]]

bloque_PL/SQL;

Donde:

nombre nos indica el nombre que le damos al disparador.
momento nos dice cuando será lanzado el disparador (BEFORE o AFTER)
acontecimiento será la acción que provoca el lanzamiento del disparador (INSERT y/o DELETE y/o UPDATE).
REFERENCING y WHEN sólo podrán ser utilizados con disparadores para filas. REFERENCING nos permite asignar un alias a los valores NEW o/y OLD de las filas afectadas por la operación, y WHEN nos permite indicar al disparador que sólo sea lanzado cuando sea TRUE una cierta condición evaluada para cada fila afectada.

En un disparador de fila, podemos acceder a los valores antiguos y nuevos de la fila afectada por la operación, referenciados como :OLD y :NEW (de ahí que podamos utilizar la opción REFERENCING para asignar un alias).

Debes tener en cuenta que:

Si el disparador es lanzado al insertar, el valor antiguo no tendrá sentido y el valor nuevo será la fila que estamos insertando.
Si el disparador es lanzado al actualizar el valor antiguo contendrá la fila antes de actualizar y el valor nuevo contendrá la fila que vamos actualizar.
Si el disparador es lanzado al borrar sólo tendrá sentido el valor antiguo.

En el cuerpo de un disparador también podemos acceder a unos predicados que nos dicen qué tipo de operación se está llevando a cabo, que son: INSERTING, UPDATING y DELETING.

Un disparador de fila no puede acceder a la tabla asociada. Se dice que esa tabla está mutando. Si un disparador es lanzado en cascada por otro disparador, éste no podrá acceder a ninguna de las tablas asociadas, y así recursivamente.

CREATE TRIGGER prueba

BEFORE UPDATE ON asistente

FOR EACH ROW

BEGIN

...

     SELECT nombre, apellido1, apellido2 FROM asistente WHERE ,,,

     /*devolvería el error ORA-04091: table ASISTENTE is mutating, trigger/function may not see it*/

...

END;

Si tenemos varios tipos de disparadores sobre una misma tabla, el orden de ejecución será:

Triggers before de sentencia.
Triggers before de fila.
Triggers after de fila.
Triggers after de sentencia.

Existe una vista del diccionario de datos con información sobre los disparadores: USER_TRIGGERS;

SQL>DESC USER_TRIGGERS;

Name                            Null?    Type

------------------------------- -------- ----

TRIGGER_NAME                    NOT NULL VARCHAR2(30)

TRIGGER_TYPE                             VARCHAR2(16)

TRIGGERING_EVENT                         VARCHAR2(26)

TABLE_OWNER                     NOT NULL VARCHAR2(30)

TABLE_NAME                      NOT NULL VARCHAR2(30)

REFERENCING_NAMES                        VARCHAR2(87)

WHEN_CLAUSE                              VARCHAR2(4000)

STATUS                                   VARCHAR2(8)

DESCRIPTION                              VARCHAR2(4000)

TRIGGER_BODY                             LONG

Autoevaluación

Indica si la siguiente AFIRMACIÓN sobre el lanzamiento de un disparador es correcta:

Retroalimentación

Falso

Precisamente el único valor que tiene sentido es el que se recupera con :OLD.

5.2.- Creación de disparadores.

Dibujo en blanco y negro que representa una chica con una escopeta.

Ministerio de Educación - ITE (Abraham Pérez Pérez) (CC BY-NC)

Ya hemos visto qué son los disparadores, los tipos que existen, cómo definirlos y algunas consideraciones a tener en cuenta a la hora de trabajar con ellos.

Ahora vamos a ver algunos ejemplos de su utilización con los que podremos comprobar la potencia que éstos nos ofrecen.

En los siguientes videotutoriales puedes ver algunos ejemplos de disparadores y su utilización en una base de datos. Recuerda que los disparadores se ejecutan de forma automática cuando se produce la operación para la que han sido programados.

Los usos más habituales de disparadores suelen ser los siguientes:

Incrementar o decrementar campos de tipo stock, totales, etc. Por ejemplo si tenemos una tabla PRODUCTO donde uno de sus campos es el stock y se inserta un nuevo pedido donde se solicita una determinada cantidad de un determinado producto, será interesante que se actualice de forma automática el stock decrementando en la cantidad de unidades pedidas el total de productos que tenemos en la base de datos. En este caso la operación que lanzaría este tipo de disparadores sería un INSERT en la mayoría de casos aunque también un UPDATE podría ser en ocasiones quien produzca variaciones en otros campos de otras tablas por supuesto.
Almacenar en tablas de tipo auditoría para llevar un control de cuándo, quién y cómo eliminó un registro, o actualizó un valor. Las operaciones que lanzarían este tipo de disparadores serían el DELETE o el UPDATE e incluso aunque no tan habitual también cuando se produce un INSERT podemos almacenar el usuario, fecha actual del sistema e información del registro que se inserta.

En este videotutorial se puede ver el primero de los usos de los triggers cuando se desea tener automatizado el cálculo de campos en alguna tabla incrementando el total recaudado de las conferencias cuando se inserta una nueva asistencia a alguna de ellas.

Elaboración propia - Descripción textual del vídeo (Dominio público)

Y a continuación vamos a ver un ejemplo de disparador donde se crea una tabla de tipo auditoría para llevar un control de todas las actualizaciones que se realizan en un campo, recogiendo por tanto el valor anterior y nuevo.

Las tablas de tipo auditoría también se utilizan mucho cuando queremos que el disparador se lance a partir de una sentencia de borrado, ya que antes de eliminar de forma definitiva un registro de una tabla, puede ser interesante almacenar dicho registro en una tabla para en un futuro poder recuperar esa información.

Elaboración propia - Descripción del vídeo (Dominio público)

Ejercicio Resuelto

Crea un disparador que dependiendo de si existen plazas disponibles para una determinada conferencia permita la inserción de un nuevo asistente o en caso de que no haya aforo suficiente no se permita la inserción y además se maneje la excepción correctamente.

Retroalimentación

El código en PL/SQL para crear el disparador sería el siguiente:

CREATE OR REPLACE TRIGGER COMPROBAR_AFORO 
BEFORE INSERT ON ASISTIR
FOR EACH ROW
DECLARE
totalAsistentes NUMBER(3);
totalAforo NUMBER(3);
superado_aforo EXCEPTION;

BEGIN
    /* Comprobamos el total de asistentes a la conferencia.*/
    SELECT COUNT(*) INTO totalAsistentes 
    FROM ASISTIR 
    WHERE REFCONFERENCIA=:NEW.refconferencia;

    /* Comprobaoms el aforo de la sala donde se realiza esa conferencia */
    SELECT capacidad INTO totalAforo 
    FROM SALA S, CONFERENCIA C 
    where C.sala=S.nombre
    AND C.referencia=:NEW.refconferencia;
    
    /*Manejamos la excepción si no hay aforo suficiente*/
    IF totalAsistentes>=totalAforo THEN
        DBMS_OUTPUT.PUT_LINE('No hay plaza');
        RAISE superado_aforo;
    ELSE
        DBMS_OUTPUT.PUT_LINE('Si hay plaza y se ha podido inscribir al nuevo asistente');
    END IF;
    
    /* Gestión de la excepción si supera aforo */
    EXCEPTION
    WHEN superado_aforo THEN 
        RAISE_APPLICATION_ERROR(-20001, 'No hay aforo suficiente' );

END;

Después para probar que funciona correctamente podemos realizar las siguientes acciones:

En primer lugar vamos a actualizar el aforo de la sala Afrodita a 7 personas ya que tenemos una conferencia que es BDO1314 con 6 asistentes actualmente.

 update sala set capacidad=7 where nombre='Afrodita';

Después vamos a visualizar con la siguiente sentencia cuántos asistentes tenemos en cada conferencia y mostraremos también las capacidades o aforos de las salas donde se celebran:

select refconferencia,sala, capacidad, count(*) as totalAsistentes
from asistir a, conferencia c, sala s
where a.refconferencia=c.referencia
and s.nombre=c.sala
group by refconferencia, sala, capacidad;

En un principio tendríamos espacio para un asistente más según este resultado:

Elaboración propia (Dominio público)

Si ejecutamos estas sentencias por separado debemos observar cómo el primer asistente que insertamos sí lo permite pero el segundo ya no porque no hay aforo suficiente.

-- ¿Puede el asistente AS0001 inscribirse? Si


insert into asistir values ('AS0001','BDO1314');


-- El segundo asistente AS0002 ya no podrá.


insert into asistir values ('AS0002','BDO1314');

Mostraría el siguiente informe de error de la excepción en el segundo caso:

Elaboración propia (Dominio público)

Para saber más

Ejercicios Resueltos de PL/SQL

Con todo esto ya hemos aprendido a utilizar lo más básico del lenguaje PL/SQL para trabajar con procedimientos, funciones y disparadores. Para finalizar aquí tienes más información por si deseas profundizar y tener más ejemplos:

Tutorial de PL/SQL

6.- Introducción a SQL/PSM de MySQL.

Caso práctico

Ministerio de Educación (CC BY-NC)

Juan y María después de trabajar con PL/SQL se han preguntado cómo sería trabajar con subprogramas en otras bases de datos. Investigando por internet se han dado cuenta que hay más lenguajes procedimentales que tienen la misma utilidad que PL/SQL para otras herramientas y SGBD.

Concretamente como también han estado diseñando, creando y utilizando bases de datos con MySQL les interesa averiguar qué lenguaje utiliza y qué similitudes o diferencias tendrá con el que ya han aprendido a usar para Oracle.

Como ya hemos trabajado con PL/SQL en una base de datos de Oracle vamos también a conocer cómo trabajar con un lenguaje procedimental en una base de datos utilizando MySQL.

Para practicar vamos a recuperar algunas de las BD y crear procedimientos, funciones y triggers mediante el lenguaje procedimental SQL/PSM o lo que es lo mismo (SQL Persistent Stored Modules).

Para ello nos vamos a centrar en la programación de bases de datos o construcción de guiones, utilizando la sintaxis de este lenguaje y veremos cómo podemos sacarle el máximo partido a una base de datos realizada con MySQL.

Vamos a aprender a crear:

Procedimientos.
Funciones.
Disparadores o triggers

Para saber más

¿Qué otros lenguajes procedimentales existen para otras herramientas y bases de datos? Aquí tienes algunos ejemplos:

Microsoft SQL Server utiliza Transact SQL.
PostgreSQL utiliza PL/pgSQL.
IBM Informix usa SPL.
Firebird usa PSQL.

6.1.- Características y conceptos básicos.

Para trabajar con este lenguaje, al igual que hicimos con PL/SQL en los apartados anteriores, necesitaremos conocer algunos aspectos básicos como son:

Declaración de variables y utilización dentro de los subprogramas.
Estructuras de control para proporcionar funcionalidad y lógica en los subprogramas.
Manejo de errores. Para controlar y mostrar las excepciones que se produzcan en la ejecución de los subprogramas. Al igual que se vió en Oracle, también con MySQL es posible controlar la ejecución de un programa o sentencia cuando se interrumpe por algún error. Esta característica se verá en el apartado 8.5 con profundidad y ejemplos.

Comencemos a ver las características más importantes que tendremos que tener en cuenta en con este lenguaje:

Cuando creamos una rutina, (procedimiento, función o trigger) puede ser necesario que se tenga que almacenar temporalmente algún valor en variables. Para eso se usarán las variables locales. Veamos como se declaran y se usan.

Declaración de variables:

Dentro de cada procedimiento se pueden definir variables locales, es decir, que sólo existen mientras se ejecuta el procedimiento y después se destruyen. Las variables locales únicamente son visibles dentro del bloque BEGIN … END donde estén declaradas, y deben estar al comienzo de este bloque, antes de cualquier sentencia.

Para declarar variables locales se utiliza la sintaxis:

DECLARE NombreVariable [, …] Tipo [DEFAULT Valor]

Para proporcionar un valor inicial a la variable declarada se utiliza DEFAULT. El valor inicial puede ser una constante o una expresión. En caso de no emplear DEFAULT el valor por defecto es NULL. En cuanto al tipo, puede utilizarse cualquier tipo válido en MySQL.

Para cada variable que se declara es necesario utilizar una sentencia DECLARE distinta.

Sentencia SET

Para asignar un valor a cualquier variable (local, global o pasada como parámetro) se utiliza la sentencia SET. Las variables que se asignan con SET pueden declararse dentro de una rutina o como variables globales de servidor.

Para modificar el valor de una variable o de un parámetro utilizando una asignación debe utilizarse la sentencia:

SET NombreVariable1=Expresión1 [, NombreVariable2=Expresión2] … ;

En Expresión puede haber una constante, una función, una variable, una operación entre ellas o incluso una sentencia SELECT que devuelva un solo resultado.

Estructuras de control:

Pasamos ahora a ver cómo podemos estructurar las sentencias dentro de una rutina o subprograma. Para ello utilizaremos las estructuras de control, que son parte fundamental en cualquier lenguaje de programación. A través de ellas podemos establecer la funcionalidad y la lógica de nuestras rutinas. Vamos a ver la sintaxis de las estructuras de control más utilizadas en este lenguaje.

Estructuras de control del lenguaje SQL/PSM
Estructura de control	Sintaxis	Ejemplo
Sentencia IF	IF Condición1 THEN Sentencias1 [ELSEIF Condición2 THEN Sentencias2] [ELSE Sentencias_Else] END IF;	IF num1 >num2 THEN SELECT 'El mayor es: ', num1; ELSEIF num2>num1 THEN SELECT 'El mayor es: ', num2; ELSE SELECT 'Los dos números son iguales '; END IF;
Sentencia CASE	CASE Expresión WHEN Valor1 THEN Sentencias1 [WHEN Valor2 THEN Sentencias2] …………………………… [WHEN ValorN THEN SentenciasN] [ELSE Sentencias_Else] END CASE;	CASE num WHEN 1 THEN SELECT 'Valor 1'; WHEN 2 THEN SELECT 'Valor 2'; WHEN 3 THEN SELECT 'Valor 3'; WHEN 4 THEN SELECT 'Valor 4'; WHEN 5 THEN SELECT 'Valor 5'; ELSE; SELECT 'Valor no valido, solo entre 1 y 5'; END CASE;
Sentencia REPEAT	[Etiqueta_Inicio:] REPEAT Sentencias; UNTIL Condición END REPEAT [Etiqueta_Fin];	IF num <= 0 THEN SELECT 'Debe ser positivo'; ELSE REPEAT -- REPITE sentencias SELECT num, ' '; SET num = num-1; UNTIL num<1 -- hasta valor true END REPEAT; END IF;
Sentencia WHILE	[Etiqueta_Inicio:] WHILE Condición DO Sentencias END WHILE [Etiqueta_Fin];	IF num <= 0 THEN SELECT 'Introduce valor positivo'; ELSE --Si es positivo -- Mientras condición cierta WHILE num >= 1 DO SELECT num, ' '; SET num = num-1; END WHILE; END IF;

Para saber más

Sentencias de control de flujo MySQL

Puedes consultar el siguiente enlace para más de detalle sobre las sentencias de control de flujo en MySQL y donde se explican algunas más:

6.2.- Procedimientos.

Ilustración de una tuerca gris sobre una pantalla azul.

Los procedimientos son rutinas o subprogramas compuestos por un conjunto nombrado de sentencias SQL agrupados lógicamente para realizar una tarea específica, que se guardan en la base de datos y se ejecutan como una unidad cuando son invocados por su nombre. Al igual que se ha estudiado con el lenguaje PL/SQL para Oracle, ahora en MySQL también podremos aprovechar las ventajas que ofrecen:

Mejoran el rendimiento en la comunicación entre el cliente y el servidor. Dado que un procedimiento consta de varias instrucciones y está almacenado en el servidor, desde el cliente MySQL (Workbench o cliente en modo texto) no hay que enviar todas esas instrucciones una a una, sino simplemente se envía la llamada al procedimiento. Por tanto, con los procedimientos se agiliza el envío de instrucciones desde los clientes al servidor, no recibiendo este tantas peticiones de tareas. Como contrapartida, el servidor tiene una mayor carga de trabajo al tener que buscar y decodificar los procedimientos almacenados cuando son invocados desde los clientes.
Cuando las aplicaciones cliente trabajan con diferentes lenguajes y plataformas, los procedimientos son muy útiles.
Proporcionan mayor seguridad en dos sentidos: por una parte, las aplicaciones y los usuarios no acceden directamente a las tablas, sino que sólo pueden ejecutar algunos procedimientos y no tendrán que construir esos procesos sobre la base de las sentencias que los forman, con el posible riesgo de alteraciones no deseadas de los datos por operaciones indebidamente realizadas; y por otra parte, se pueden establecer autorizaciones de ejecución diferentes, para los usuarios sobre los procedimientos y funciones que se deseen.
Resumir un proceso con varias instrucciones SQL complejas. Se ejecuta más rápido como un procedimiento almacenado que si se trata de un programa instalado en el cliente que envía y recibe consultas SQL al servidor.

Los permisos asociados a las distintas operaciones que se pueden realizar con procedimientos almacenados son: CREATE ROUTINE (creación), EXECUTE (ejecución), ALTER ROUTINE (borrado). Por ejemplo un usuario puede tener permiso para ejecutar un procedimiento (EXECUTE), pero en cambio puede no tener permiso para crear nuevos procedimientos (CREATE ROUTINE).

Hemos dicho que los procedimientos se almacenan en el SGBD, pero ¿dónde se almacenan?

En MySQL los procedimientos se almacenan en:

La tabla proc de la base de datos del sistema mysql. (hasta la versión MySQL 5.7). Esta tabla se crea durante la instalación de MySQL.
La tabla routines de la base de datos de los metadatos information_schema (versiones MySQL 8.x ). Esta tabla se crea durante la instalación de MySQL.

Autoevaluación

Indica si la siguiente afirmación es verdadera o falsa.

Retroalimentación

Verdadero

Precisamente es una de las principales ventajas que tienen los procedimientos al almacenarse en el servidor junto con los datos.

6.2.1.- Creación de un procedimiento.

Everaldo Coelho (YellowIcon) (GNU/GPL)

Para crear un procedimiento en MySQL utilizamos la siguiente sintaxis:

CREATE PROCEDURE NombreProcedimiento ([parámetro1 [, parámetro2,..]])
[características …]
BEGIN
    CuerpoDelProcedimiento
END;

Los parámetros, como ya sabemos, permiten al procedimiento recibir y/o devolver información. Y pueden ser [IN | OUT | INOUT] NombreParámetro TipoDato. Donde:
- IN: el procedimiento recibe el parámetro y no lo modifica. Lo usa para consultar y utilizar su valor.
- OUT: el procedimiento únicamente puede escribir en el parámetro, no puede consultarlo.
- INOUT: el procedimiento recibe el parámetro y puede consultarlo y modificarlo
- TipoDato: es el tipo de datos devuelto, y puede ser cualquier tipo de datos válido de MySQL (INT, DATE, CHAR, VARCHAR, etc).
En la sección de características se puede especificar la siguiente información:

LANGUAGE SQL
    | [NOT] DETERMINISTIC
    | { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }
    | SQL SECURITY { DEFINER | INVOKER }
    | COMMENT 'CadenaComentario'

LANGUAGE SQL significa que el cuerpo del procedimiento está escrito en SQL. Por defecto se tiene esa característica para prever la posible construcción de procedimientos almacenados con otros lenguajes como Java.
DETERMINISTIC / NOT DETERMINISTIC. El procedimiento se considera “determinista” si siempre produce el mismo resultado para los mismos parámetros de entrada, y “no determinista” si no es así. Por defecto es NOT DETERMINISTIC.
SQL SEQURITY sirve especificar si el procedimiento es llamado, usando los permisos del usuario que lo creó (DEFINER, que es el valor por defecto), o usando los permisos del usuario que está haciendo la llamada (INVOKER).
COMMENT se usa para escribir el comentario que aparecerá cuando se ejecute una sentencia para ver el contenido de un procedimiento o de una función con:

SHOW CREATE PROCEDURE o SHOW CREATE FUNCTION

CuerpoDelProcedimiento: Casi todas las sentencias SQL válidas. El cuerpo del procedimiento empieza con la sentencia BEGIN y termina con la sentencia END y consta de varias instrucciones. Cada una termina con punto y coma (;).

Las cláusulas de la sección de características tienen como valores predeterminados los siguientes:

LANGUAGE SQL NOT DETERMINISTIC SQL SECURITY DEFINER COMMENT ''

Debes conocer

DELIMITER

En MySQL las sentencias se ejecutan después de escribir el punto y coma (;). Para poder escribir el procedimiento completo evitando que se ejecute al encontrar el símbolo (;) tenemos que asignar la función de delimitador a otro carácter, como por ejemplo la barra (|), o bien los símbolos $$ o //, como veremos en el siguiente ejemplo. Al finalizar asignaremos al punto y coma su función habitual.

Cuando un procedimiento utiliza un parámetro de salida (OUT) o un parámetro de entrada/salida (INOUT), para llamar al procedimiento, es necesario pasar una variable que cargue el dato devuelto por el procedimiento. Para este fin utilizaremos las variables de usuario o sesión.

Para definir una variable desde la línea de comandos, que será una variable temporal de sistema, la variable debe tener el nombre precedido del carácter @ y se usa la sentencia:

SET @NombreVariable=Valor;

--Ejemplos:

SET @Edad=23;

SET @Fecha='2022-03-16';

SET @Nombre='Víctor';

También se puede crear una variable de sistema pasándola como parámetro en la llamada a un procedimiento, tanto si ya se tenía creada la anterior variable @Num como si se crea en la propia llamada al procedimiento:

CALL NombreProcedimiento(@Num);

Una vez cargado ese valor @Num se puede usar en cualquier sentencia como por ejemplo:

SELECT @Num;

Ejercicio Resuelto

En la base de datos ProyectosX vamos a crear un procedimiento que obtenga un listado con todos los empleados de un determinado departamento que pasamos como parámetro de entrada. Además, este procedimiento también debe obtener en un parámetro de salida la media de los salarios de los empleados que trabajan en ese departamento.

Observa el uso de DELIMITER.

Retroalimentación

Con este código en MySQL creamos el procedimiento:

DELIMITER //
CREATE PROCEDURE LISTA_EMPLEADOS_DPTO(IN DEPART char(3), OUT medSal INT)
BEGIN
    /* Obtenemos todos los empleados del departamento pasado como parámetro.*/
    SELECT * FROM EMPLEADO WHERE CDDEP=DEPART;

    /* Calculamos la media de salarios de sus empleados         
        y lo almacenamos en el parámetro de salida. */
    SELECT AVG(salario) INTO medSal FROM EMPLEADO WHERE CDDEP=DEPART;
END//
DELIMITER ;

Después para probar el procedimiento podemos llamarlo pasando como parámetro de entrada '02' que corresponde al departamento de Ventas y como parámetro de salida @media donde almacenamos la media de los salarios de sus empleados.

CALL LISTA_EMPLEADOS_DPTO('02',@media);

Por último si queremos obtener el valor de salida que tiene la variable realizamos la siguiente consulta:

SELECT @media AS 'Media Salario';

6.3.- Funciones.

Ilustración de una cajón marrón con una flecha hacia abajo

Otra de las rutinas que podemos crear y almacenar en el servidor de base de datos son las funciones, que serán similares a las funciones SQL que proporciona el SGBD.

Recordemos que una función es conjunto de instrucciones SQL que después de ejecutarse devuelven un valor.

La forma de crear una función es similar a la de creación de un procedimiento. Las funciones, una vez creadas, quedan almacenadas en el servidor y pueden ser invocadas en cualquier momento por cualquier cliente MySQL.

Aunque las funciones comparten muchas características con respecto a los procedimientos, presentan también algunas diferencias:

Las funciones devuelven siempre un dato a través de una sentencia RETURN. El dato se corresponde con un tipo de dato declarado para la función.
Las funciones no pueden trabajar con parámetros OUT o INOUT, sino únicamente con parámetros de entrada IN, por eso no se especifica el tipo.
En las funciones no se pueden usar sentencias que devuelvan filas de resultados (SELECT, SHOW, DESC). Se pueden usar sentencias SELECT que devuelvan una fila siempre que los datos devueltos se carguen en variables, para sentencias que devuelvan varias filas se utilizan los cursores.
Las funciones son llamadas a ejecución, al igual que las funciones internas de MySQL, escribiendo su nombre y la lista de parámetros pasados a la función encerrados entre paréntesis. Por tanto no usa una sentencia de llamada como la sentencia CALL en el caso de los procedimientos.
Las funciones podrán ser llamadas desde cualquier sentencia SQL como SELECT, UPDATE, INSERT, DELETE. Los procedimientos nunca pueden ser llamados a ejecución dentro de otra sentencia.
Las funciones se llaman usando: NombreFunción(parámetros).

Las funciones definidas por el usuario están disponibles en versiones anteriores de MySQL. Actualmente se soportan junto con los procedimientos almacenados. En el futuro será posible un marco para procedimientos almacenados externos en lenguajes distintos a SQL, por ejemplo PHP.

Los permisos asociados a las distintas operaciones que se pueden realizar con funciones almacenadas son: CREATE ROUTINE (creación), EXECUTE (ejecución), ALTER ROUTINE (borrado).

Hemos dicho que las funciones se almacenan en el SGBD, pero ¿dónde se almacenan?

En MySQL las funciones se almacenan en:

La tabla func de la base de datos del sistema mysql. (hasta la versión MySQL 5.7). Esta tabla se crea durante la instalación de MySQL.
La tabla routines de la base de datos de los metadatos information_schema (versiones MySQL 8.x ). Esta tabla se crea durante la instalación de MySQL.

Autoevaluación

Solución

6.3.1.- Creación de una función.

Vamos a describir detalladamente la sintaxis para crear funciones:

CREATE FUNCTION NombreFuncion ([parámetro1 [, parámetro2,..]])

    RETURNS Tipo

[características …]

BEGIN

    CuerpoDeLaFunción

END;

Kurt Kaiser (CC0)

Aunque las funciones comparten muchas características con respecto a los procedimientos, presentan también algunas diferencias:

Como hemos dicho en el punto anterior con relación a los parámetros, no es necesario especificar el tipo porque no trabajan con parámetros OUT o INOUT.
La cláusula RETURNS es obligatoria e indica el tipo de retorno que nos va a devolver la función.
En el cuerpo de la función debe incluirse un comando RETURN valor o expresión, debiendo ser expresión del mismo tipo que la función. Generalmente la sentencia RETURN para devolver un resultado es la última del cuerpo de la función.
En las funciones, en las sentencias de su cuerpo, no se pueden usar sentencias que devuelvan filas de resultados (SELECT, SHOW, DESC). Se pueden usar sentencias SELECT que devuelvan una fila siempre que los datos devueltos se carguen en variables; para sentencias que devuelvan varias filas trataremos los cursores.
Tipo: El Tipo de datos devuelto puede ser cualquier tipo de datos válido de MySQL.
Las funciones son llamadas a ejecución, al igual que las funciones internas de MySQL, escribiendo su nombre y la lista de parámetros pasados a la función encerrados entre paréntesis. Por tanto no usa una sentencia de llamada como en el caso de los procedimientos.
Las funciones podrán ser llamadas desde cualquier sentencia SQL como SELECT, UPDATE, INSERT, DELETE. Los procedimientos nunca pueden ser llamados a ejecución dentro de otra sentencia.
Las funciones se invocan usando: NombreFunción(parámetros).

Las características:

LANGUAGE SQL
    | [NOT] DETERMINISTIC
    | { CONTAINS SQL | NO SQL | READS SQL DATA | MODIFIES SQL DATA }
    | SQL SECURITY { DEFINER | INVOKER }
    | COMMENT 'CadenaComentario'

La descripción de las características que puede incorporar una función es similar a la que hemos visto para los procedimientos.

Como por ejemplo:

Function DETERMINISTIC es la que no realiza cambios en los datos, o para los mismos parametros de entrada produce los mismos resultados, en otro caso es NOT DETERMINISTIC. Por defecto MySQL supone que son NO DETERMINISTIC. En nuestro caso, la mayoría de las funciones que diseñemos serán DETERMINISTIC.

Por último está el CuerpoDeLaRutina: que contiene el código ejecutable de la función entre las sentencias BEGIN y END.

Ejercicio Resuelto

Vamos a crear una función que se llamará Edad y a la que pasaremos como parámetro de entrada una fecha. La función tendrá que devolver la cantidad de años que han pasado desde esa fecha hasta la fecha actual.

Retroalimentación

Con este código en MySQL creamos la función solicitada:

DELIMITER//
CREATE FUNCTION edad (f_nac DATE)
RETURNS INT
DETERMINISTIC
BEGIN
    -- Declaramos una variable
    DECLARE a INT;
    
    -- Asignamos a la variable el cálculo de la edad.
    SET a=truncate(datediff(sysdate(), f_nac)/365,0);
    
    -- Devolvemos la variable.
    RETURN a; 
END//
DELIMITER ;

Después para probar la función tan sólo tendremos que llamarla como hacemos con cualquier función predefinida de MySQL.

SELECT edad('1995-11-06'); -- Nos devolverá la edad según la fecha actual.

También podemos usar la función Edad con algún campo de nuestra tabla, por ejemplo Empleados y el campo fecha_ingreso para saber cuántos años llevan trabajando cada uno de los empleados de la empresa:

SELECT nombre, edad(fecha_ingreso) AS 'Años de antigüedad' FROM empleado;

Para saber más

Si necesitas consultar el significado de alguna función y ver algún ejemplo de su aplicación acude al manual de MySQL en los siguientes enlaces:

Funciones en MySQL

6.4.- Disparadores.

Ilustración de un rayo de color amarillo.

Tal y como hemos visto en Oracle, un trigger o disparador es una rutina asociada con una tabla, que se activa o ejecuta automáticamente cuando se produce algún evento sobre la tabla.

Aunque ya lo vimos anteriormente, ten en cuenta que:

Un trigger siempre se invoca antes o después de que una fila se inserta, modifica o elimina.
Un trigger siempre está asociado con una tabla de la base de datos.
Cada base de datos puede o no, tener uno o más triggers.
Un trigger se ejecuta como parte de la transacción que lo activó.

¿Recuerdas para qué se utilizan los disparadores?

Implementar restricciones definidas en el diseño de la base de datos.
Automatizar acciones críticas suministrando avisos y sugerencias cuando haya que reparar alguna acción.
Actualizar los valores de una tabla, insertar registros en una tabla o llamar a otros procedimientos almacenados.

La sintaxis de creación de un trigger es muy similar a la que ya conoces.

CREATE TRIGGER trigger_nombre
{ BEFORE | AFTER } { INSERT | UPDATE | DELETE } ON NombreTabla

FOR EACH ROW
[{ FOLLOWS | PRECEDES } otro_trigger]

BEGIN

Sentencias;

END

trigger_nombre: nombre que recibe el desencadenador, disparador o trigger.
BEFORE|AFTER: determina si las instrucciones asociadas al trigger se ejecutarán antes (BEFORE) o después (AFTER) de la operación o evento que lo activó.
INSERT|UPDATE|DELETE: es el evento u operación sobre la tabla que activará al desencadenador.
tabla: nombre de la tabla con la que está asociado el desencadenador o trigger.
FOLLOWS/PRECEDES: determina el orden en el que se ejecutará ese trigger en relación al trigger otro_trigger (trigger asociado a la misma tabla, el mismo evento y mismo momento de disparo)
Entre BEGIN y END van las sentencias asociadas al desencadenador.

Recuerda que tal y como aprendimos en PL/SQL en Oracle, ahora también debes tener en cuenta que para acceder a los valores de las columnas de la tabla asociada al trigger, se utilizan OLD y NEW.

Debes tener en cuenta que:

No se puede asociar un trigger a una tabla temporal o a una Vista (VIEW)
No puede haber dos triggers o más para una misma tabla, que respondan al mismo evento y en el mismo momento de disparo, en versiones anteriores a MySQL 8.0.x.
Si puede haber dos o más triggers asociados a una tabla, respondiendo al mismo evento y que se diparen en el mimso momento a partir de la versión MySQL 8.0.x, y en este caso hay que gestionar el orden o prioridad de ejecución de cada uno de ellos mediante las opciones FOLLOW/PRECED. En otro caso, se activan según el orden de creación..
No pueden incluirse sentencias de control de transacción, tales como COMMIT y ROLLBACK en el código de un trigger.
Dado que los triggers son rutinas, podemos usar para ellos las mismas sentencias que en los procedimientos y en las funciones.
Para crear y ejecutar TRIGGERS se necesita el privilegio TRIGGER.
Para eliminar un trigger se utiliza la siguiente sintaxis:
```
DROP TRIGGER NombreTabla.NombreTrigger;
```
Para ver los triggers en uso en una base de datos usamos la sintaxis:

SHOW TRIGGERS;

Ejercicio Resuelto

Crear un disparador que se ejecute automáticamente cada vez que se inserte un nuevo registro en la tabla TRABAJA cuando se asigna un empleado a un proyecto con un número de horas que va a dedicar. El disparador tendrá que aumentar el salario del empleado en 50 € si la suma total de horas que trabaja ese empleado supera las 100. En cualquier otro caso no tendrá que aumentar el salario.

Retroalimentación

Con este código en MySQL creamos el disparador o trigger:

USE proyectosx; -- Utilizamos la BD Proyectosx.
DROP TRIGGER if exists subir_salario; --Lo borramos si ya existía.<br />
/* Código para crear el Trigger */
DELIMITER//
CREATE TRIGGER subir_salario 
AFTER INSERT ON trabaja
FOR EACH ROW
BEGIN
  /*Declaración de variable local */
  DECLARE totalHoras INT;
  /*Obtenemos la suma de horas del empleado en los proyectos donde trabaja */
  SELECT SUM(nhoras) INTO totalHoras
  FROM TRABAJA
  WHERE cdemp=NEW.cdemp;
  IF totalHoras>100 THEN  /*Si supera las 100 horas trabajadas incrementamos su salario */
	UPDATE EMPLEADO SET SALARIO = SALARIO + 50 WHERE cdemp=NEW.cdemp;
  END IF;
END//
DELIMITER ;

Después para probar que funciona correctamente podemos introducir un registro en la tabla TRABAJA donde asignamos a un empleado a un proyecto y le ponemos una duración de horas que supere en total las 100 si ya tenía anteriormente más y hacemos otra inserción de otro empleado donde no sobrepase las 100 horas en total con otros proyectos en los que ya podía trabajar anteriormente. Por ejemplo:

INSERT INTO TRABAJA VALUES('A14','MES',150);-- Le asignamos 150 horas al empleado A14 en el proyecto MES

INSERT INTO TRABAJA VALUES('A03','DAG',10); -- Le asignamos 10 horas al empleado A03 en proyecto DAG

Después de insertar ambos registros comprobamos que en la tabla TRABAJA se han insertado correctamente pero ¿qué ha ocurrido con el salario de los empleados afectados? Si obtenemos el resultado de la tabla EMPLEADO, sólo tendría que haber subido el sueldo en 50 el empleado A14 mientras que el empleado A03 se mantiene el mismo salario ya que no ha trabajado en total más de 100 horas. Se puede comprobar ejecutando la siguiente instrucción:

SELECT * FROM empleado;

Autoevaluación

Indica si la siguiente afirmación es verdadera o falsa:

Retroalimentación

Verdadero

Sí es posible definir dos o más triggers a una misma tabla e incluso que respondan al mismo evento, en ese caso habrá que gestionar la prioridad de cada uno, pero sí es posible.

6.5.- Manipulación de errores o excepciones.

Everaldo Coelho (YellowIcon) (GNU/GPL)

Cuando se ejecuta una sentencia SQL, el servidor devuelve un código de error (numérico) relativo a esa sentencia. Por ejemplo, se devuelve un código de error, cuando se ejecuta una sentencia que trata de insertar una fila con un valor que ya existe en la columna que es clave primaria.

Si la sentencia no ha generado ningún error, entonces devuelve 0 como código de error.
Si una sentencia forma parte de un procedimiento o función y genera un error, entonces se termina automáticamente la ejecución del procedimiento o función.

Esto, generalmente, es un grave problema ya que es normal que, aunque una sentencia de una rutina produzca error, se desee procesar las siguientes sentencias de la rutina. Para solucionar este problema, MySQL permite usar manipuladores de errores o handler que sirven para indicar como debe responder el servidor MySQL, en procedimientos y funciones, a situaciones de error.

Además del código de error, MySQL también devuelve un estado de error, que es algo más genérico que el propio código de error. Un estado de error engloba varios códigos de errores. El estado de error suele aparecer encerrado entre paréntesis.

Por ejemplo, si intentamos insertar una fila en una tabla y esa fila no se puede insertar porque el valor de la clave primaria ya existe, MySQL devuelve una indicación de error cuyo estado de error o SQLSTATEes '23000' y cuyo código de error MySQL es 1062 (los valores o códigos de estado devueltos para las sentencias ejecutadas son cadenas de caracteres mientras que los códigos de error son números enteros).

Para declarar un manipulador de errores o de excepción hay que usar la sintaxis:

DECLARE TipoManipulador HANDLER FOR ValorCondicion[,...] sentencia;
TipoManipulador:  CONTINUE | EXIT
ValorCondicion:   SQLSTATE ValorEstado
                  | NombreCondicion
                  | SQLWARNING
                  | NOT FOUND
                  | SQLEXCEPTION
                  | CódigoErrorMySQL

Si se produce cualquiera de las condiciones de error declaradas en el manipulador, se ejecutará la sentencia especificada para el manipulador. Si es más de una sentencia las que se debe ejecutar, éstas deben ir entre BEGIN ... END.

TipoManipulador: puede ser EXIT o CONTINUE.
- Un manipulador de tipo CONTINUE hace que prosiga la ejecución de la siguiente sentencia a aquella donde se hay producido un error controlado por el manipulador.
- Un manipulador de tipo EXIT hace que se termine el bloque en el que se encuentra la sentencia que ha producido el error controlado por el manipulador y, por tanto, termine la rutina en la que se encuentra.
ValorCondicion:
- SQLWARNING se usa para referenciar a todos los valores de estado que comienzan por 01.
- NOT FOUND< se usa para referenciar a todos valores de estado que comienzan por 02.
- SQLEXCEPTION se usa para referenciar a todos los valores de estado que no son controlados por SQLWARNING y por NOT FOUND.

Es el momento de aprender con un ejemplo cómo crear un manipulador de errores para que nos muestre el mensaje apropiado en caso de que se produzca algún fallo en la ejecución. En el siguiente ejercicio resuelto podrás entender y practicar mejor todo lo aprendido.

Ejercicio Resuelto

Crea un procedimiento donde se inserte un nuevo departamento y obtenga después todos los departamentos que existen en la base de datos proyectosx.

Retroalimentación

Con este código en MySQL creamos el procedimiento incluyendo el manipulador de errores:

DELIMITER |
CREATE PROCEDURE Manipuladores()

BEGIN

    /*Declaramos el manipulador de errores*/

    DECLARE CONTINUE HANDLER FOR SQLSTATE '23000' SELECT 'Clave repetida.';

    BEGIN
         /*Insertamos un nuevo departamento con clave repetida*/
         INSERT INTO DEPARTAMENTO VALUES ('01','Comercial','Jaén');
    END;

    /*Mostramos todos los departamentos de la BD*/

    SELECT * FROM DEPARTAMENTO; 

END|
DELIMITER ;

Para llamar al procedimiento ejecutamos:

 CALL Manipuladores();

Si en la base de datos ProyectosX ya teníamos un departamento con clave primaria '01' y ahora estamos intentando hacer una inserción nueva repitiendo la clave primaria vemos en el primer resultado de la ejecución que se ha producido un error y tal y como lo hemos recogido en el manipulador le hemos indicado con una sentencia SELECT que nos muestre el mensaje 'Clave repetida'

Elaboración propia en MySQL (Dominio público)

El manipulador por tanto ha funcionado y como lo hemos declarado de forma CONTINUE ha seguido con las demás instrucciones del procedimiento y por tanto ha ejecutado la sentencia donde se obtienen todos los departamentos de la base de datos tal y como se aprecia en la siguiente imagen del segundo resultado que muestra este procedimiento:

Elaboración propia con MySQL (Dominio público)

Para saber más

Manajadores de error MySQL

En el siguiente enlace puedes ver la documentación oficial MySQL de Manejadores de error.

En el siguiente enlace tienes todos los códigos de error que nos puede devolver MySQL:

Códigos de error de MySQL.

6.6.- Cursores en MySQL.

Ministerio de Educación - ITE (CC BY-NC)

¿Recuerdas para qué utilizamos los cursores explícitos en Oracle con el lenguaje PL/SQL? Ahora en MySQL también podemos usar este tipo de cursores y también tendremos que:

Declarar el cursor (después de las variables locales).
Abrir el cursor.
Asignar las filas al cursor según tarea a realizar.
Cerrar el cursor una vez finalizada la tarea.

A diferencia de PL/SQL, en este lenguaje las declaraciones van dentro del bloque BEGIN...END. A continuación tienes un ejercicio resuelto donde se utiliza un cursor dentro de una función.

Ejercicio Resuelto

Crear una función que obtenga como resultado una cadena de caracteres con todos los nombres de los empleados que son jefes separados por comas.

Retroalimentación

Con este código en MySQL creamos la función que nos piden:

USE proyectosx;
DROP FUNCTION IF EXISTS ListadoEmpleados;

DELIMITER $$
CREATE FUNCTION ListadoEmpleados()
RETURNS VARCHAR(200)
DETERMINISTIC
BEGIN
/*Declaración de variables*/
DECLARE ultima_fila INT DEFAULT 0;
DECLARE SNombre VARCHAR(50) default '';
DECLARE Resultado VARCHAR(200) default '';
/*Declaración del cursor*/
DECLARE Cur_1 CURSOR FOR
SELECTdistinct j.nombre 
FROM empleado e, empleado j
WHERE e.cdjefe=j.cdemp;
/*Declaración del manipulador de error*/   
DECLARE CONTINUE HANDLER FOR NOT FOUND SET ultima_fila=1;
/*Abrimos el cursor*/
OPEN Cur_1;
/* Creamos un bucle para recorrer el cursor */
c1_loop: LOOP
    /*Cogemos el primer nombre de jefe en la varible*/
    FETCH Cur_1 INTO SNombre;

    /*Comprobamos si es la última fila para salir del bucle*/
    IF (ultima_fila=1) THEN
         LEAVE c1_loop;
    END IF;

/*Vamos concatenando los nombres de los jefes en la variable Resultado*/

     IF Resultado ='' THEN
         SET Resultado = (SNombre);
     ELSE
         SET Resultado = CONCAT(Resultado ,', ' ,(SNombre));
     END IF;
END LOOP c1_loop;

/*Cerramos el cursor*/
CLOSE Cur_1;

/*Devolvemos la variable de la función*/
RETURN Resultado;
END $$
DELIMITER ;

Para comprobar que la función realiza lo que se pide podemos realizar la llamada con la siguiente sentencia y obtendremos la cadena de caracteres con todos los jefes.

SELECT ListadoEmpleados();

Autoevaluación

Indica si la siguiente afirmación es verdadera o falsa

Retroalimentación

Falso

Un cursor se puede usar tanto el código de una función como en el de un procedimiento, pues el cursor nos muestra el resultado de la consulta SELECT, sino que la deja en una tabla temporal para operar con ella.

7.- Interfaces de programación de aplicaciones para lenguajes externos.

Caso práctico

Dibujo en el que se representa un chico con un bocadillo en el que se puede leer un signo de interrogación.

Ministerio de Educación - ITE (Abraham Pérez Pérez) (CC BY-NC)

Juan y María tienen la base de datos de juegos on-line lista, pero no tienen claro si todo lo que han hecho lo tienen que utilizar desde dentro de la base de datos o si pueden reutilizar todo ese trabajo desde otro lenguaje de programación desde el que están creando la interfaz web desde la que los jugadores y jugadoras se conectarán para jugar y desde la que también se conectará la administradora para gestionar la base de datos de una forma más amigable.

En ese momento pasa Ada al lado y ambos la asaltan con su gran duda. Ada, muy segura, les responde que para eso existen las interfaces de programación de aplicaciones o APIs, que les permiten acceder desde otros lenguajes de programación a la base de datos.

Llegados a este punto ya sabemos programar nuestra base de datos, pero al igual que a Juan y María te surgirá la duda de si todo lo que has hecho puedes aprovecharlo desde cualquier otro lenguaje de programación. La respuesta es la misma que dio Ada: SÍ.

En este apartado te vamos a dar algunas referencias sobre las APIs para acceder a las bases de datos desde un lenguaje de programación externo. No vamos a ser exhaustivos ya que eso queda fuera del alcance de esta unidad e incluso de este módulo. Todo ello lo vas a estudiar con mucha más profundidad en otros módulos de este ciclo (o incluso ya lo conoces). Aquí sólo pretendemos que sepas que existen y que las puedes utilizar.

Las primeras APIs utilizadas para acceder a bases de datos Oracle fueron las que el mismo Oracle proporcionaba: Pro*C, Pro*Fortran y Pro*Cobol. Todas permitían embeber llamadas a la base de datos en nuestro programa y a la hora de compilarlo, primero debíamos pasar el precompilador adecuado que trasladaba esas llamadas embebidas en llamadas a una librería utilizada en tiempo de ejecución. Sin duda, el más utilizado fue Pro*C, ya que el lenguaje C y C++ tuvieron un gran auge.

Hoy día existen muchas más APIs para acceder a las bases de datos ya que tanto los lenguajes de programación como las tecnologías han evolucionado mucho. Antes la programación para la web casi no existía y por eso todos los programas que accedían a bases de datos lo hacían bien en local o bien a través de una red local. Hoy día eso sería impensable, de ahí que las APIs también hayan evolucionado mucho y tengamos una gran oferta a nuestro alcance para elegir la que más se adecue a nuestra necesidades.

Para saber más

Tecnologías Java para acceder a bases de datos.

En los siguientes enlaces podrás ampliar información sobre algunas APIs muy comunes para acceder a bases de datos.

Conectividad abierta de bases de datos.

Anexo I.- Excepciones predefinidas en Oracle.

Las excepciones predefinidas son:

Excepciones predefinidas en Oracle.
Excepción.	SQLCODE	Lanzada cuando ...
ACCES_INTO_NULL	-6530	Intentamos asignar valor a atributos de objetos no inicializados.
COLECTION_IS_NULL	-6531	Intentamos asignar valor a elementos de colecciones no inicializadas, o acceder a métodos distintos de EXISTS.
CURSOR_ALREADY_OPEN	-6511	Intentamos abrir un cursor ya abierto.
DUP_VAL_ON_INDEX	-1	Índice único violado.
INVALID_CURSOR	-1001	Intentamos hacer una operación con un cursor que no está abierto.
INVALID_NUMBER	-1722	Conversión de cadena a número falla.
LOGIN_DENIED	-1403	El usuario y/o contraseña para conectarnos a Oracle no es válido.
NO_DATA_FOUND	+100	Una sentencia SELECT no devuelve valores, o intentamos acceder a un elemento borrado de una tabla anidada.
NOT_LOGGED_ON	-1012	No estamos conectados a Oracle.
PROGRAM_ERROR	-6501	Ha ocurrido un error interno en PL/SQL.
ROWTYPE_MISMATCH	-6504	Diferentes tipos en la asignación de 2 cursores.
STORAGE_ERROR	-6500	Memoria corrupta.
SUBSCRIPT_BEYOND_COUNT	-6533	El índice al que intentamos acceder en una colección sobrepasa su límite superior.
SUBSCRIPT_OUTSIDE_LIMIT	-6532	Intentamos acceder a un rango no válido dentro de una colección (-1 por ejemplo).
TIMEOUT_ON_RESOURCE	-51	Un timeout ocurre mientras Oracle espera por un recurso.
TOO_MANY_ROWS	-1422	Una sentencia SELECT...INTO... devuelve más de una fila.
VALUE_ERROR	-6502	Ocurre un error de conversión, aritmético, de truncado o de restricción de tamaño.
ZERO_DIVIDE	-1476	Intentamos dividir un número por 0.

Anexo II.- Evaluación de los atributos de un cursor explícito.

Evaluación de los atributos de un cursor explícito según las operaciones realizadas con él.
Operación realizada.	%FOUND	%NOTFOUND	%ISOPEN	%ROWCOUNT
Antes del OPEN	Excepción.	Excepción.	FALSE	Excepción.
Después del OPEN	NULL	NULL	TRUE	0
Antes del primer FETCH	NULL	NULL	TRUE	0
Después del primer FETCH	TRUE	FALSE	TRUE	1
Antes de los siguientes FETCH	TRUE	FALSE	TRUE	1
Después de los siguientes FETCH	TRUE	FALSE	TRUE	Depende datos.
Antes del último FETCH	TRUE	FALSE	TRUE	Depende datos.
Después del último FETCH	FALSE	TRUE	TRUE	Depende datos.
Antes del CLOSE	FALSE	TRUE	TRUE	Depende datos.
Después del CLOSE	Excepción.	Excepción.	FALSE	Excepción.

Anexo.- Licencias de recursos.

Ningún recurso de fuentes externas que requiera citar explícitamente sus datos de licencia ha sido usado en esta unidad, por lo que este anexo queda vacío. Todos los recursos utilizados, de fuentes internas, se acogen al Aviso Legal de la plataforma.

Condiciones y términos de uso de los materiales

Materiales desarrollados inicialmente por el Ministerio de Educación, Cultura y Deporte y actualizados por el profesorado de la Junta de Andalucía bajo licencia Creative Commons BY-NC-SA.

Antes de cualquier uso leer detenidamente el siguente Aviso legal