Notas del release

38.6 Capítulo 7. Procedimientos de SQL (ahora llamado "Sentencias de control de SQL")

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.

38.6.1 Sentencia de procedimiento SQL

La información sobre la Sentencia de Procedimiento SQL ha cambiado a lo siguiente:

Sentencia de procedimiento SQL

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:

  1. Esta sentencia sólo se puede utilizar dentro del ámbito de un procedimiento SQL.

  2. 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:

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.

38.6.2 FOR

FOR

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:

  1. 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

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

38.6.3 Sentencia compuesta (ahora pasa a llamarse "Sentencia compuesta (procedimiento)"

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.

38.6.4 RETURN

RETURN

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:

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

Notas

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

38.6.5 SIGNAL

La sentencia SIGNAL SQLSTATE ya no se utiliza.

SIGNAL

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:

  1. 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:

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:

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

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 ]