Notas del release
Las sentencias de control son sentencias de SQL que permiten utilizar SQL
de forma similar a como se escribe un programa en un lenguaje de programación
estructurada. Las sentencias de control de SQL se pueden utilizar en el
cuerpo de una rutina, en un desencadenante o en una sentencia compuesta
dinámica.
Este capítulo describe las sentencias de control de SQL soportadas y su
sintaxis, junto con la sentencia de procedimiento SQL.
La información sobre la Sentencia de Procedimiento SQL ha cambiado a lo
siguiente:
Este capítulo contiene los diagramas de sintaxis, las descripciones
semánticas, la normas y ejemplos sobre el uso de las sentencias que forman el
cuerpo de procedimiento de una rutina de SQL, un desencadenante o una
sentencia compuesta dinámica.
Sintaxis
>>-+------------+---+-| sentencia-control-SQL |-+--------------><
'-etiqueta:--' '-| sentencia-SQL |---------'
sentencia-control-SQL
(1)
|---+-sentencia ALLOCATE CURSOR-----------------+---------------|
| (1) |
+-sentencia de asignación-------------------+
| (1) |
+-sentencia ASSOCIATE LOCATORS--------------+
| (1) |
+-sentencia CASE----------------------------+
| (2) |
+-sentencia compuesta dinámica--------------+
+-sentencia FOR-----------------------------+
+-sentencia GET DIAGNOSTICS-----------------+
| (1) |
+-sentencia GOTO----------------------------+
+-sentencia IF------------------------------+
+-sentencia ITERATE-------------------------+
+-sentencia LEAVE---------------------------+
| (1) |
+-sentencia LOOP----------------------------+
| (1) |
+-sentencia compuesta de procedimiento------+
| (1) |
+-sentencia REPEAT--------------------------+
| (1) |
+-sentencia RESIGNAL------------------------+
+-sentencia RETURN--------------------------+
+-sentencia SIGNAL--------------------------+
'-sentencia WHILE---------------------------'
Notas:
- Esta sentencia sólo se puede utilizar dentro del ámbito de un
procedimiento SQL.
- Esta sentencia sólo se puede utilizar dentro de un desencadenante, una
función SQL o un método SQL. Debe ser la sentencia de nivel más
externo.
Descripción
- etiqueta:
- Especifica la etiqueta de una sentencia de procedimiento SQL. La
etiqueta debe ser exclusiva dentro de una lista de sentencias de procedimiento
SQL, incluidas las sentencias compuestas que estén anidadas dentro de la
lista. Las sentencias compuestas que no estén anidadas puede utilizar
la misma etiqueta. Se puede utilizar una lista de sentencias de
procedimiento SQL en varias sentencias de control SQL.
Dentro del ámbito de un desencadenante, una función o método SQL, o de una
sentencia compuesta dinámica, sólo pueden tener etiqueta la sentencia
compuesta dinámica y las sentencias FOR y WHILE.
- sentencia-SQL
- El cuerpo de un procedimiento SQL puede contener todas las sentencias SQL
ejecutables, con excepción de las siguientes:
- CONNECT
- CREATE, para objetos que no sean índices, tablas ni vistas
- DESCRIBE
- DISCONNECT
- DROP, para objetos que no sean índices, tablas ni vistas
- FLUSH EVENT MONITOR
- REFRESH TABLE
- RELEASE (sólo para una conexión)
- RENAME TABLE
- RENAME TABLESPACE
- REVOKE
- SET CONNECTION
- SET INTEGRITY
- Nota:
- El cuerpo del procedimiento SQL puede contener sentencias CALL, pero estas
sentencias sólo pueden invocar otro procedimiento SQL o un procedimiento en
lenguaje C. Las sentencias CALL incluidas dentro de un procedimiento
SQL no pueden invocar otros tipos de procedimientos almacenados.
La sentencia FOR ejecuta una sentencia o grupo de sentencias para cada fila
de una tabla.
Sintaxis
>>-+------------+---FOR--nombre-bucle-for--AS------------------->
'-etiqueta:--'
>-----+---------------------------------+--sentencia-select----->
| (1) |
'-nombre-cursor--CURSOR FOR-------'
.-----------------------------------.
V |
>----DO-------sentencia-procedimiento-SQL--;---+--END FOR------->
>-----+-----------+--------------------------------------------><
'-etiqueta--'
Notas:
- Esta opción sólo se puede utilizar dentro del ámbito de un procedimiento
SQL.
Descripción
- etiqueta
- Especifica la etiqueta de la sentencia FOR. Si se especifica la
etiqueta inicial, esa etiqueta se puede utilizar en sentencias LEAVE e
ITERATE. Si se especifica la etiqueta final, debe ser igual a la
etiqueta inicial.
- nombre-bucle-for
- Especifica una etiqueta para la sentencia compuesta implícita que se
genera para ejecutar la sentencia FOR. Esta etiqueta cumple las reglas
aplicables a la etiqueta de una sentencia compuesta, salvo que no se puede
utilizar con una sentencia ITERATE ni LEAVE dentro de la sentencia FOR.
El nombre-bucle-for se utiliza para calificar los nombres de columna
devueltos por la sentencia-select especificada.
- nombre-cursor
- Designa el cursor que se utiliza para seleccionar filas de la tabla
resultante de ejecutar la sentencia SELECT. Si no se especifica un
nombre de cursor, DB2 genera un nombre de cursor exclusivo.
- sentencia-select
- Especifica la sentencia SELECT del cursor. Todas las columnas de la
lista de selección deben tener un nombre y no pueden existir dos columnas con
el mismo nombre.
Dentro de un desencadenante, función, método o sentencia compuesta
dinámica, la sentencia-select de constar sólo de una
selección-completa con expresiones de tabla común opcionales.
- sentencia-procedimiento-SQL
- Especifica una sentencia (o sentencias) que se debe invocar para cada fila
de la tabla.
Reglas
- La lista de selección debe constar de nombres de columna exclusivos y la
tabla especificada en la lista de selección debe existir cuando se crea el
procedimiento, o debe ser una tabla creada en una sentencia anterior de
procedimiento SQL.
- El cursor especificado en una sentencia FOR no se puede referenciar fuera
de la sentencia FOR y no se puede especificar en las sentencias OPEN, FETCH ni
CLOSE.
Ejemplos
El ejemplo siguiente utiliza la sentencia FOR para ejecutar un proceso
iterativo sobre la tabla employee completa. Para cada fila
de la tabla, la variable de SQL fullname toma el valor formado por
el primer apellido del empleado, una coma, el nombre, un espacio en blanco y
la inicial del segundo apellido. Cada valor de fullname se
inserta en la tabla tnames.
BEGIN
DECLARE fullname CHAR(40);
FOR vl AS
SELECT firstnme, midinit, lastname FROM employee
DO
SET fullname = lastname || ',' || firstnme ||' ' || midinit;
INSERT INTO tnames VALUE (fullname);
END FOR
END
Una sentencia compuesta de procedimiento agrupa varias sentencias para
formar un procedimiento SQL. Dentro de una sentencia compuesta, puede
declarar variables SQL, cursores y gestores de condiciones.
El diagrama de sintaxis ahora tiene un título:
sentencia-compuesta-procedimiento.
.-NOT ATOMIC--.
>>-+------------+--BEGIN----+-------------+--------------------->
'-etiqueta:--' '-ATOMIC------'
>-----+--------------------------------------------------+------>
| .--------------------------------------------. |
| V | |
'-----+-| declaración-variable-SQL |----+---;---+--'
+-| declaración-condición |-------+
'-| declaración-códigos-retorno |-'
>-----+--------------------------------------+------------------>
| .--------------------------------. |
| V | |
'----| declaración-sentencia |--;---+--'
>-----+-------------------------------------+------------------->
| .-------------------------------. |
| V | |
'----sentencia-DECLARE-CURSOR--;---+--'
>-----+-----------------------------------+--------------------->
| .-----------------------------. |
| V | |
'----| declaración-gestor |--;---+--'
.-----------------------------------.
V |
>--------sentencia-procedimiento-SQL--;---+--------------------->
>-----END--+-----------+---------------------------------------><
'-etiqueta--'
declaración-variable-SQL
.-,----------------------.
V |
|---DECLARE-------nombre-variable-SQL---+----------------------->
.-DEFAULT NULL--------.
>-----+-tipo-datos----+---------------------+-+-----------------|
| '-DEFAULT--constante--' |
'-RESULT_SET_LOCATOR--VARYING-----------'
declaración-condición
|---DECLARE--nombre-condición--CONDITION--FOR------------------->
.-VALUE-.
.-SQLSTATE--+-------+---.
>----+-----------------------+---constante-de-tipo-serie--------|
declaración-sentencia
.-,-------------------.
V |
|---DECLARE-----nombre-sentencia---+---STATEMENT----------------|
declaración-códigos-retorno
|---DECLARE----+-SQLSTATE--CHAR (5)--+-------------------------->
'-SQLCODE--INTEGER----'
>-----+---------------------+-----------------------------------|
'-DEFAULT--constante--'
declaración-gestor
|---DECLARE----+-CONTINUE-+---HANDLER--FOR---------------------->
+-EXIT-----+
'-UNDO-----'
.-,----------------------------------.
V .-VALUE-. |
>---------+-SQLSTATE--+-------+--serie--+--+-------------------->
+-nombre-condición------------+
+-SQLEXCEPTION----------------+
+-SQLWARNING------------------+
'-NOT FOUND-------------------'
>----sentencia-procedimiento-SQL--------------------------------|
- declaración-sentencia
- Una declaración-sentencia declara una lista de uno o más nombres
que son locales respecto a la sentencia compuesta. Un nombre de
sentencia no puede ser igual que otro nombre de sentencia dentro de la misma
sentencia compuesta.
La sentencia RETURN se utiliza para finalizar la ejecución de la
rutina. Para las funciones o métodos de SQL, esta sentencia devuelve el
resultado de la función o método. Para un procedimiento SQL, devuelve
opcionalmente un valor de estado entero.
Sintaxis
>>-RETURN--+---------------------------------------------------------------+->
+-expresión-----------------------------------------------------+
+-NULL----------------------------------------------------------+
'-+-------------------------------------+---selección-completa--'
| .-,------------------------. |
| V | |
'-WITH-----expresión-tabla-común---+--'
>--------------------------------------------------------------><
Descripción
- expresión
- Especifica un valor que es devuelto por la rutina:
- Si la rutina es una función o método, se debe especificar una
expresión, NULL o selección-completa (SQLSTATE 42630) y el
tipo de datos del resultado se debe poder asignar al tipo RETURNS de la rutina
(SQLSTATE 42866).
- No se puede especificar una expresión escalar (salvo una selección
completa escalar) para una función de tabla (SQLSTATE 428F1).
- Si la rutina es un procedimiento, el tipo de datos de expresión
debe ser INTEGER (SQLSTATE 428E2). Un procedimiento no puede devolver
un valor NULL ni una selección completa.
- NULL
- Especifica que la función o método devuelve un valor nulo cuyo tipo de
datos es el definido en la cláusula RETURNS. No se puede especificar
NULL para la sentencia RETURN de un procedimiento.
- WITH expresión-tabla-común
- Define una expresión de tabla común para ser utilizada en la selección
completa que sigue a continuación.
- selección-completa
- Especifica la fila o filas que se deben devolver para la función.
El número de columnas de la selección completa debe coincidir con el número de
columnas del resultado de la función (SQLSTATE 42811). Además, los
tipos de columnas estáticos de la selección completa se deben poder asignar a
los tipos de columna declarados del resultado de la función, utilizando las
normas de asignación a columnas (SQLSTATE 42866).
La selección-completa no se puede especificar para la sentencia
RETURN de un procedimiento.
Si la rutina es una función o método escalar, la selección completa debe
devolver una sola columna (SQLSTATE 42823) y, como máximo, una fila (SQLSTATE
21000).
Si la rutina es una función de fila, debe devolver, como máximo, una fila
(SQLSTATE 21505).
Si la rutina es una función de tabla, puede devolver ninguna o más filas y
una o más columnas.
Reglas
- La ejecución de una función o método de SQL debe terminar con una
sentencia RETURN (SQLSTATE 42632).
- En una función de tabla o de fila de SQL donde se utilice una
sentencia-compuesta-dinámica, la única sentencia RETURN permitida es
la situada al final de la sentencia compuesta (SQLSTATE 429BD).
Notas
- Cuando un procedimiento devuelve un valor, el invocador del procedimiento
puede acceder al valor de estas formas:
- utilizando la sentencia GET DIAGNOSTICS para recuperar el estado de
terminación (RETURN_STATUS) cuando el procedimiento SQL se invocó desde otro
procedimiento SQL
- utilizando el parámetro asociado al marcador de parámetros de valor de
retorno en la sintaxis de la cláusula CALL de escape
(?=CALL...) en una aplicación CLI
- directamente de la SQLCA devuelta por la invocación de un procedimiento de
SQL, recuperando el valor de SQLERRD[0] cuando SQLCODE no es
menor que cero (se supone el valor -1 si SQLCODE es menor que
cero).
Ejemplos
Utilización de una sentencia RETURN para finalizar la ejecución de
procedimiento almacenado de SQL, cuyo valor de estado de terminación es 0 si
la ejecución es satisfactoria y -200 en caso contrario.
BEGIN
...
GOTO FAIL
...
SUCCESS: RETURN 0
FAIL: RETURN -200
END
La sentencia SIGNAL SQLSTATE ya no se utiliza.
La sentencia SIGNAL se utiliza para señalar un error o condición de
aviso. Hace que se devuelva un error o aviso junto con el SQLSTATE
especificado y un mensaje opcional.
Sintaxis
>>-SIGNAL------------------------------------------------------->
.-VALUE-.
>-----+-SQLSTATE--+-------+--cadena-constante-sqlstate--+------->
'-nombre-condición--------------------------------'
>-----+----------------------------------------------------------+>
+-SET--MESSAGE_TEXT-- = --+-nombre-variable--------------+-+
| '-cadena-constante-diagnóstico-' |
| (1) |
'-(--cadena-diagnóstico--)---------------------------------'
>--------------------------------------------------------------><
Notas:
- Esta opción sólo es válida dentro del ámbito de una sentencia CREATE
TRIGGER y se proporciona para mantener la compatibilidad con versiones
anteriores de DB2.
Descripción
- SQLSTATE VALUE cadena-constante-sqlstate
- Es la cadena de caracteres constante que representa un SQLSTATE.
Debe contener 5 caracteres y seguir las normas que se aplican a un
SQLSTATE:
- Cada carácter debe ser un dígito del 0 al 9 o bien una letra mayúscula no
acentuada de la A a la Z.
- La clase SQLSTATE (primeros dos caracteres) no puede ser '00',
pues esto significa una finalización satisfactoria.
En el contexto de una sentencia compuesta dinámica, un desencadenante,
una función de SQL o un método de SQL, son aplicables también las normas
siguientes:
- La clase SQLSTATE (dos primeros caracteres) no puede ser '01' ni
'02',, pues no representan clases de error.
- Si la clase SQLSTATE comienza con un número del '0' al '6'
o con las letras de la 'A' a la 'H',, la subclase
(últimos tres caracteres) debe comenzar con una letra de la 'I' a la
'Z'.
- Si la clase SQLSTATE comienza con los números '7',
'8', '9', o las letras de la 'I' a la
'Z', la subclase puede ser un número del '0' al
'9' o una letra de la 'A' a la 'Z'.
Si el SQLSTATE no cumple estas normas, se emite un error (SQLSTATE
428B3).
- nombre-condición
- Especifica el nombre de la condición. El nombre de la condición
debe ser exclusivo dentro del procedimiento y sólo puede aparecer dentro de la
sentencia compuesta en la que está declarada la condición.
- SET MESSAGE_TEXT=
- Especifica una cadena de texto que describe el error o aviso. La
cadena de texto se devuelve en el campo SQLERRMC de la SQLCA. Si la
cadena tiene más de 70 bytes, se trunca sin avisar. Esta cláusula sólo
se puede especificar si también se especifica un SQLSTATE o nombre de
condición (SQLSTATE 42601).
- nombre-variable
- Identifica una variable SQL que debe declarar dentro de la sentencia
compuesta. El tipo de datos de la variable SQL debe estar definido como
CHAR o VARCHAR.
- cadena-constante-diagnóstico
- Especifica una cadena de caracteres constante donde está contenido el
texto del mensaje.
- cadena-diagnóstico
- Es una expresión, cuyo tipo es CHAR o VARCHAR, que devuelve una cadena de
caracteres de hasta 70 bytes la cual describe la condición de error. Si
la cadena tiene más de 70 bytes, se trunca. Esta opción sólo es válida
dentro del ámbito de una sentencia CREATE TRIGGER y se proporciona para
mantener la compatibilidad con versiones anteriores de DB2. No es
recomendable su utilización habitual.
Notas
- Si se emite una sentencia SIGNAL, el SQLCODE asignado es:
+438 si SQLSTATE comienza con '01' o '02'
-438 en otro caso
- Si el SQLSTATE o condición indica la existencia de una excepción (clase de
SQLSTATE distinta de '01' y '02'):
- Se gestiona la excepción y el control se transfiere a un gestor de
excepciones, si éste existe en la misma sentencia compuesta (o sentencia
compuesta más externa) que la sentencia SIGNAL, y la sentencia compuesta
contiene un gestor para el SQLSTATE, nombre de condición o SQLEXCEPTION
especificado
- Si no se puede gestionar la excepción, el control se traslada
inmediatamente al final de la sentencia compuesta.
- Si el SQLSTATE o condición indica la existencia de un aviso (clase de
SQLSTATE igual a '01') o una condición de no encontrado (clase de
SQLSTATE igual a '02'):
- Se gestiona el aviso o condición de no encontrado y el control se
transfiere a un gestor de excepciones, si éste existe en la misma sentencia
compuesta (o sentencia compuesta más externa) que la sentencia SIGNAL, y la
sentencia compuesta contiene un gestor para el SQLSTATE, nombre de condición,
aviso (clase de SQLSTATE = 01), o condición de no encontrado (clase de
SQLSTATE = 02) especificado
- Si no se puede gestionar el aviso, el proceso continúa con la sentencia
siguiente.
- Los valores SQLSTATE constan de un código de clase de 2 caracteres seguido
de un código de subclase de 3 caracteres. Los códigos de clase
representan condiciones de ejecución satisfactoria y no satisfactoria.
Puede utilizarse cualquier valor SQLSTATE válido en la sentencia
SIGNAL. Sin embargo, es recomendable que el programador defina nuevos
valores SQLSTATE basados en rangos reservados para aplicaciones. Esto
impide la utilización involuntaria de un valor SQLSTATE que el gestor de bases
de datos pueda definir en una versión futura del producto.
- Se pueden definir clases de SQLSTATE que comiencen con los caracteres del
'7' al '9', o de la 'I' a la 'Z'.
Dentro de estas clases, se puede definir cualquier subclase.
- Las clases de SQLSTATE que comienzan con los caracteres del '0' al
'6', o de la 'A' a la 'H' están reservadas para el
gestor de bases de datos. Dentro de estas clases, las subclases que
comienzan con los caracteres de la 'A' a la 'H' están
reservadas para el gestor de bases de datos. Se pueden definir
subclases que comiencen con los caracteres de la 'I' a la
'Z'.
Ejemplos
Este ejemplo muestra un procedimiento SQL para un sistema de gestión de
pedidos que señala un error de aplicación cuando la aplicación no reconoce un
número de cliente. La tabla ORDERS incluye una clave externa para la
tabla CUSTOMER, que hace que el número de cliente (CUSTNO) deba existir para
poder insertar un pedido.
CREATE PROCEDURE SUBMIT_ORDER
(IN ONUM INTEGER, IN CNUM INTEGER,
IN PNUM INTEGER, IN QNUM INTEGER)
SPECIFIC SUBMIT_ORDER
MODIFIES SQL DATA
LANGUAGE SQL
BEGIN
DECLARE EXIT HANDLER FOR SQLSTATE VALUE '23503'
SIGNAL SQLSTATE '75002'
SET MESSAGE_TEXT = 'Número de cliente no conocido';
INSERT INTO ORDERS (ORDERNO, CUSTNO, PARTNO, QUANTITY)
VALUES (ONUM, CNUM, PNUM, QNUM);
END
[ Principio de página | Página anterior | Página siguiente ]