Notas del release
Ahora se da soporte a la actualización de la clave de
particionamiento. El siguiente texto procedente del Capítulo 6 debe
suprimirse únicamente si DB2_UPDATE_PART_KEY=ON:
- Nota:
- Si DB2_UPDATE_PART_KEY=OFF, las restricciones siguen siendo válidas.
Reglas
- Una columna de clave de particionamiento de una tabla no puede
actualizarse (SQLSTATE 42997).
- Una columna con posibilidad de nulos de una clave de particionamiento no
puede incluirse como columna de clave externa cuando la relación se defina con
ON DELETE SET NULL (SQLSTATE 42997).
Reglas
- Una columna de clave de particionamiento de una tabla no puede
actualizarse (SQLSTATE 42997).
- Una columna con posibilidad de nulos de una clave de particionamiento no
puede incluirse como columna de clave externa cuando la relación se defina con
ON DELETE SET NULL (SQLSTATE 42997).
- Nota:
- Las columnas de clave de particionamiento no pueden actualizarse (SQLSTATE
42997).
Notas a pie de página
- 108 Una columna de una clave de particionamiento no resulta actualizable
(SQLSTATE 42997). La fila de datos debe suprimirse e insertarse para
cambiar columnas en una clave de particionamiento.
La longitud de las columnas de longitud variable que forman parte de un
índice cualquiera, incluidas las claves principales y exclusivas, definidas
cuando la variable del registro DB2_INDEX_2BYTEVARLEN tenía el valor ON, se
puede modificar para que sea mayor que 255 bytes. El hecho de que una
columna de longitud variable esté asociada a una clave externa ya no impide
que modificar la longitud de esa columna para que sea mayor que 255 bytes,
para cualquiera sea el valor de la variable del registro. Sin embargo,
los datos más largos de 255 bytes no se pueden insertar en la tabla a menos
que la columna de la correspondiente clave primaria sea mayor que 255 bytes,
lo cual sólo es posible si la clave primaria se creó cuando la variable del
registro tenía el valor ON.
Se pueden definir índices en columnas de longitud variable cuya longitud
sea mayor que 255 bytes si la variable del registro DB2_INDEX_2BYTEVARLEN
tiene el valor ON.
Las claves principales y exclusivas con partes variables pueden tener un
tamaño mayor que 255 si la variable de registro DB2_INDEX_2BYTEVARLEN tiene el
valor ON (activado). Se pueden definir claves externas en columnas de
longitud variable cuya longitud sea mayor que 255 bytes.
La sentencia ALTER SEQUENCE modifica los atributos de una secuencia
mediante las acciones siguientes:
- Reinicio de la secuencia
- Cambio del incremento existente entre los valores subsiguientes de la
secuencia
- Definición de un valor máximo o mínimo
- Cambio del número de números de secuencia que se ponen en antememoria
- Cambio de la especificación de si la secuencia puede generar valores de
forma cíclica
- Cambio de la especificación de si los valores de la secuencia se deben
generar en orden de petición
Invocación
Esta sentencia se puede intercalar en un programa de aplicación o se puede
emitir mediante el uso de sentencias de SQL dinámicas. Es una sentencia
ejecutable que se puede preparar de forma dinámica. Sin embargo, si es
aplicable la opción de enlace DYNAMICRULES BIND, la sentencia no se puede
preparar de forma dinámica (SQLSTATE 42509).
Autorización
El ID de autorización de la sentencia debe contener como mínimo uno de los
privilegios siguientes:
- Definidor de la secuencia
- Privilegio ALTERIN para el esquema especificado implícita o explícitamente
- Autorización SYSADM o DBADM
Sintaxis
>>-ALTER SEQUENCE--nombre-secuencia----------------------------->
.---------------------------------------------.
V |
>-------+-RESTART--+---------------------------+-+--+----------><
| '-WITH--constante-numérica--' |
+-INCREMENT BY--constante-numérica-------+
+-+-MINVALUE--constante-numérica--+------+
| '-NO MINVALUE-------------------' |
+-+-MAXVALUE--constante-numérica--+------+
| '-NO MAXVALUE-------------------' |
+-+-CYCLE----+---------------------------+
| '-NO CYCLE-' |
+-+-CACHE--constante-entera--+-----------+
| '-NO CACHE-----------------' |
'-+-ORDER----+---------------------------'
'-NO ORDER-'
Descripción
- nombre-secuencia
- Identifica la secuencia específica. La combinación nombre de
secuencia - nombre de esquema implícito/explícito no debe designar una
secuencia ya existente en el servidor actual. Si en el esquema
especificado explícita o implícitamente no existe ninguna secuencia cuyo
nombre sea el indicado, se emite un error (SQLSTATE 42704).
- RESTART
- Reinicia la secuencia. Si constante-numérica no se
especifica, la secuencia se reinicia en el valor especificado implícita o
explícitamente como valor inicial en la sentencia CREATE SEQUENCE, cuando se
creó originalmente la secuencia.
- WITH constante-numérica
- Reinicia la secuencia en el valor especificado. Este valor puede
ser cualquier valor positivo o negativo que pueda asignarse a una columna del
tipo de datos asociado a la secuencia (SQLSTATE 42820), sin dígitos distintos
de cero a la derecha de la coma decimal (SQLSTATE 42894).
- INCREMENT BY
- Especifica el intervalo existente entre valores consecutivos de la
secuencia. Este valor puede ser cualquier valor positivo o negativo que
pueda asignarse a una columna del tipo de datos asociado a la secuencia
(SQLSTATE 42820), sin exceder el valor de una constante entera grande (SLSTATE
42815) y sin dígitos distintos de cero a la derecha de la coma decimal
(SQLSTATE 428FA).
Si este valor es negativo, la secuencia de valores es decreciente.
Si este valor es positivo, la secuencia de valores es creciente. Si
este valor es 0 o mayor que el rango definido por MINVALUE y MAXVALUE, se
genera un solo valor, pero por lo demás la secuencia se trata como una
secuencia ascendente.
- MINVALUE o NO MINVALUE
- Especifica el valor mínimo en el que se reinicia o detiene una secuencia
descendente de valores, o el valor al que vuelve una secuencia ascendente
después de alcanzar el valor máximo.
- MINVALUE constante-numérica
- Especifica la constante numérica que es el valor mínimo. Este valor
puede ser cualquier valor positivo o negativo que pueda asignarse a una
columna del tipo de datos asociado a la secuencia (SQLSTATE 42820), sin
dígitos distintos de cero a la derecha de la coma decimal (SQLSTATE 428FA),
pero el valor debe ser menor o igual que el valor máximo (SQLSTATE
42815).
- NO MINVALUE
- Para una secuencia ascendente, es igual al valor de START WITH, o 1 si
START WITH no se especifica. Para una secuencia descendente, es igual
al valor mínimo del tipo de datos asociado a la secuencia. Éste es el
valor por omisión.
- MAXVALUE o NO MAXVALUE
- Especifica el valor máximo en el que se reinicia o detiene una secuencia
ascendente de valores, o el valor al que vuelve una secuencia ascendente
después de alcanzar el valor mínimo.
- MAXVALUE constante-numérica
- Especifica la constante numérica que es el valor máximo. Este valor
puede ser cualquier valor positivo o negativo que pueda asignarse a una
columna del tipo de datos asociado a la secuencia (SQLSTATE 428FA), sin
dígitos distintos de cero a la derecha de la coma decimal (SQLSTATE 428FA),
pero el valor debe ser mayor o igual que el valor mínimo (SQLSTATE
42815).
- NO MAXVALUE
- Para una secuencia ascendente, es igual al valor máximo del tipo de datos
asociado a la secuencia. Para una secuencia descendente, es igual al
valor de START WITH, o -1 si START WITH no se especifica. Éste es el
valor por omisión.
- CYCLE o NO CYCLE
- Especifica si la secuencia debe seguir generando valores después de
alcanzar su valor máximo o mínimo. El límite de la secuencia se puede
alcanzar con el valor siguiente que coincida exactamente con el límite, o bien
superando el límite, en cuyo caso el valor siguiente se obtiene reiniciando la
secuencia en el valor de START WITH si está permitida la reanudación del
ciclo.
- CYCLE
- Especifica que la secuencia siga generando valores después de alcanzar su
valor máximo o mínimo. Si se utiliza esta opción, cuando una secuencia
ascendente alcanza su valor máximo, genera su valor mínimo; en el caso de
secuencia descendente, cuando alcanza su valor mínimo, genera su valor
máximo. Los valores máximo y mínimo de la secuencia determinan el rango
utilizado para la generación cíclica de valores.
Si el parámetro CYCLE está en vigor, se pueden generar valores duplicados
para la secuencia.
- NO CYCLE
- Especifica que no se generen valores para la secuencia una vez alcanzado
el valor máximo o mínimo de la secuencia. Éste es el valor por
omisión.
- CACHE o NO CACHE
- Especifica si deben guardarse en la memoria algunos valores preasignados
para acceder a ellos más rápidamente. Ésta es una opción para el
rendimiento y ajuste del sistema.
- CACHE constante-entera
- Especifica el número máximo de valores de la secuencia que se preasignan y
guardan en la memoria. La preasignación y mantenimiento de valores en
la antememoria disminuye la E/S síncrona en el archivo de anotaciones cuando
se generan valores para la secuencia.
Si se produce un error del sistema, los valores de secuencia puestos en
antememoria que no se han utilizado en sentencias confirmadas se pierden (es
decir, no se utilizarán nunca). El valor especificado para la opción
CACHE es el número máximo de valores de secuencia que se podrían perder si se
produce un error del sistema.
El valor mínimo es 2 (SQLSTATE 42815). El valor por omisión es CACHE
20.
- NO CACHE
- Especifica que no se deben preasignar valores de la secuencia. Esta
opción asegura que no haya pérdida de valores en el caso de un error del
sistema, cierre del sistema o desactivación de la base de datos. Si se
especifica esta opción, los valores de la secuencia no se ponen en la
antememoria. En este caso, cada petición de un nuevo valor para la
secuencia origina una E/S síncrona en el archivo de anotaciones.
- NO ORDER o ORDER
- Especifica si los valores de la secuencia se deben generar en orden de
petición.
- ORDER
- Especifica que los valores de la secuencia se generan en orden de
petición.
- NO ORDER
- Especifica que no es necesario que los valores de la secuencia se generen
en orden de petición. Éste es el valor por omisión.
Después de reiniciar una secuencia o especificar el atributo CYCLE, la
secuencia puede generar valores que son un duplicado de valores creados
anteriormente por la secuencia.
Notas
- La sentencia ALTER SEQUENCE sólo afecta a los números subsiguientes de la
secuencia.
- El tipo de datos de una secuencia no se puede cambiar. En lugar de
esto, puede eliminar la secuencia y volver a crearla especificando el tipo de
datos deseado para la nueva secuencia.
- Los valores puestos en la antememoria se pierden cuando se modifica una
secuencia.
Ejemplos
Ejemplo 1: Puede especificar RESTART sin un valor numérico
cuando desee reiniciar la secuencia en el valor de START WITH. El
objetivo del presente ejemplo es generar números comprendidos entre 1 y el
número de filas de una tabla y luego insertar los números en una columna
añadida a la tabla utilizando tablas temporales. Otro posible uso sería
volver a colocar los resultados donde todas las filas resultantes están
numeradas:
ALTER SEQUENCE org_seq
RESTART
SELECT NEXTVAL for org_seq, org.*
FROM org
Cambios en fragmentos de la sintaxis:
alteración-columna
|--nombre-columna----------------------------------------------->
>-----+-SET--+-DATA TYPE--+-VARCHAR-----------+---(--entero--)--+---------+>
| | +-CHARACTER VARYING-+ | |
| | '-CHAR VARYING------' | |
| '-EXPRESSION AS--(--expresión-generación--)--------' |
+-ADD SCOPE--+-nombre-tabla-escrita-+-------------------------------+
| '-nombre-vista-escrita-' |
'-+-| alteración-identidad |--------------------------------------+-'
'-SET GENERATED--+-ALWAYS-----+---+---------------------------+-'
'-BY DEFAULT-' '-| alteración-identidad |--'
>---------------------------------------------------------------|
alteración-identidad
|---+-RESTART--+----------------------------+-+-----------------|
| '-WITH--constante-numérica---' |
+-SET INCREMENT BY--constante-numérica----+
| (1) |
+-SET--+-NO MINVALUE-------------------+--+
| '-MINVALUE--constante-numérica--' |
+-SET--+-NO MAXVALUE-------------------+--+
| '-MAXVALUE--constante-numérica--' |
+-SET--+-CYCLE----+-----------------------+
| '-NO CYCLE-' |
+-SET--+-NO CACHE-----------------+-------+
| '-CACHE--constante-entera--' |
'-SET--+-NO ORDER-+-----------------------'
'-ORDER----'
Notas:
- Estos parámetros se pueden especificar sin espacios en blanco:
NOMINVALUE, NOMAXVALUE, NOCYCLE, NOCACHE y NOORDER. Se pueden utilizar
estas formas abreviadas de una sola palabra como alternativa a las expresiones
que constan de dos palabras.
Añada los parámetros siguientes:
- SET GENERATED
- Especifica si deben generarse valores para la columna siempre o sólo
cuando sea necesario un valor por omisión.
- ALWAYS
- Se genera siempre un valor para la columna cada vez que se inserta o
actualiza una fila en la tabla. La columna ya debe estar definida como
columna generada (SQLSTATE 42837).
- BY DEFAULT
- Se genera el valor para la columna cuando se inserta o actualiza una fila
en la tabla, a menos que se especifique un valor. La columna ya debe
estar definida como columna generada (SQLSTATE 42837).
- RESTART o RESTART WITH constante-numérica
- Inicializa el estado de la secuencia asociada a la columna de
identidad. Si no se especifica WITH constante-numérica, la
secuencia de la columna de identidad se reinicia en el valor especificado,
implícita o explícitamente, como valor inicial cuando se creó originalmente la
columna de identidad. constante-numérica es una constante
numérica exacta que puede ser cualquier valor positivo o negativo que pueda
asignarse a la columna (SQLSTATE 42820), y que no tenga dígitos distintos de
cero a la derecha de la coma decimal (SQLSTATE 42894). La columna ya
debe estar definida con el atributo IDENTITY (SQLSTATE 42837). El valor
de constante-numérica se utilizará como valor siguiente de la
columna.
- SET INCREMENT BY constante-numérica
- Especifica el intervalo existente entre valores consecutivos de la columna
de identidad. La columna ya debe estar definida con el atributo
IDENTITY (SQLSTATE 42837). Este valor puede ser cualquier valor
positivo o negativo que pueda asignarse a la columna (SQLSTATE 42820), que no
exceda el valor de una constante entera grande (SLSTATE 42815), y sin dígitos
distintos de cero a la derecha de la coma decimal (SQLSTATE 42894).
Si este valor es negativo, la secuencia de valores en la columna de
identidad es decreciente. Si este valor es positivo, la secuencia de
valores en la columna de identidad es creciente. Si este valor es 0 o
mayor que el rango definido por MINVALUE y MAXVALUE, DB2 genera un solo valor,
pero por lo demás la secuencia se trata como una secuencia ascendente.
- SET MINVALUE constante-numérica o NO MINVALUE
- Especifica el valor mínimo en el que se reinicia o detiene una columna de
identidad descendente, o el valor al que vuelve una columna de identidad
ascendente después de alcanzar el valor máximo. La columna ya debe
estar definida con el atributo IDENTITY (SQLSTATE 42837).
- MINVALUE constante-numérica
- Especifique el valor mínimo de la constante numérica. Este valor
puede ser cualquier valor positivo o negativo que pueda asignarse a la columna
(SQLSTATE 42820), sin dígitos distintos de cero a la derecha de la coma
decimal (SQLSTATE 42894), pero el valor debe ser menor que el valor máximo
(SQLSTATE 42815).
- NO MINVALUE
- Para una secuencia ascendente, es igual al valor de START WITH, o 1 si
START WITH no se especifica. Para una secuencia descendente, el valor
es el valor mínimo del tipo de datos de la columna.
- SET MAXVALUE constante-numérica o NO MAXVALUE
- Especifica el valor máximo en el que se reinicia o detiene una columna de
identidad ascendente, o el valor al que vuelve una columna de identidad
descendente después de alcanzar el valor mínimo. La columna ya debe
estar definida con el atributo IDENTITY (SQLSTATE 42837).
- MAXVALUE constante-numérica
- Especifica la constante numérica que es el valor máximo. Este valor
puede ser cualquier valor positivo o negativo que pueda asignarse a la columna
(SQLSTATE 42820), sin dígitos distintos de cero a la derecha de la coma
decimal (SQLSTATE 42894), pero el valor debe ser mayor que el valor mínimo
(SQLSTATE 42815).
- NO MAXVALUE
- Para una secuencia ascendente, el valor es el valor máximo del tipo de
datos de la columna. Para una secuencia descendente, el valor es el
valor de START WITH, o -1 si START WITH no se especifica.
- SET CYCLE o NO CYCLE
- Especifica si la columna de identidad debe seguir generando valores
después de alcanzar el valor máximo o mínimo. La columna ya debe estar
definida con el atributo IDENTITY (SQLSTATE 42837).
- CYCLE
- Especifica que se sigan generando valores para la columna después de
alcanzar el valor máximo o mínimo. Si se utiliza esta opción, cuando
una columna de identidad ascendente alcanza su valor máximo, genera su valor
mínimo; en el caso de secuencia descendente, cuando alcanza su valor
mínimo, genera su valor máximo. Los valores máximo y mínimo de la
columna de identidad determinan el rango utilizado para la generación cíclica
de valores.
Si el parámetro CYCLE está en vigor, se pueden generar valores duplicados
para una columna de identidad. Si se desea obtener valores únicos, se
puede utilizar un índice de unicidad de una sola columna sobre la columna de
identidad para asegurar la unicidad. Si existe un índice de unicidad
para la columna de identidad y se genera un valor no único, se produce un
error (SQLSTATE 23505).
- NO CYCLE
- Especifica que no se generen valores para la columna de identidad una vez
alcanzado el valor máximo o mínimo.
- SET CACHE constante-entera o NO CACHE
- Especifica si deben guardarse en la memoria algunos valores preasignados
para acceder a ellos más rápidamente. Ésta es una opción para el
rendimiento y ajuste del sistema. La columna ya debe estar definida con
el atributo IDENTITY (SQLSTATE 42837).
- CACHE constante-entera
- Especifica cuántos valores de la secuencia de identidad se preasignan y
guardan en la memoria. Cuando se generan valores para la columna de
identidad, la preasignación y mantenimiento de valores en la antememoria
disminuye la E/S síncrona en el archivo de anotaciones.
Si es necesario un nuevo valor para la columna de identidad y la
antememoria no contiene valores sin utilizar disponibles, la asignación del
valor requiere esperar a que se realicen operaciones de E/S en el archivo de
anotaciones. En cambio, si es necesario un nuevo valor para la columna
de identidad y la antememoria contiene un valor sin utilizar, la asignación de
ese valor de identidad puede realizarse más rápidamente, pues se evitan
operaciones de E/S en el archivo de anotaciones.
Cuando se detiene un gestor de bases de datos (por ejemplo, desactivación
de la base de datos, error o cierre del sistema), los valores de secuencia
puestos en antememoria que no se han utilizado en sentencias confirmadas se
pierden (es decir, no se utilizarán nunca). El valor especificado para
la opción CACHE es el número máximo de valores de la columna de identidad que
se podrían perder si se produce un error del sistema.
El valor mínimo es 2 (SQLSTATE 42615).
- NO CACHE
- Especifica que no se deben preasignar valores para la columna de
identidad.
Si se especifica esta opción, los valores de la columna de identidad no se
guardan en la antememoria. En este caso, cada petición de un nuevo
valor de identidad origina una E/S síncrona en el archivo de
anotaciones.
- SET ORDER o NO ORDER
- Especifica si los valores de la columna de identidad se deben generar en
orden de petición. La columna ya debe estar definida con el atributo
IDENTITY (SQLSTATE 42837).
- ORDER
- Especifica que los valores de la columna de identidad se generan en orden
de petición.
- NO ORDER
- Especifica que no es necesario que los valores de la columna de identidad
se generen en orden de petición.
La sentencia ATOMIC del SQL compuesto no permite utilizar una sentencia
COMMIT preparada.
Una sentencia compuesta agrupa varias sentencias para formar un bloque
ejecutable. Se pueden declarar variables de SQL dentro de una sentencia
compuesta atómica preparada dinámicamente.
Invocación
Esta sentencia se puede intercalar en un desencadenante, función de SQL o
método de SQL, o se puede emitir mediante el uso de sentencias de SQL
dinámicas. Es una sentencia ejecutable que se puede preparar de forma
dinámica.
Autorización
No son necesarios privilegios para invocar una sentencia compuesta
dinámica. Pero el ID de autorización de la sentencia compuesta debe
contener los privilegios necesarios para invocar las sentencias de SQL
incluidas en la sentencia compuesta.
Sintaxis
sentencia-compuesta-dinámica
>>-+-----------------+--BEGIN ATOMIC---------------------------->
| (1) |
'-etiqueta:-------'
>-----+-----------------------------------------------+--------->
| .-----------------------------------------. |
| V | |
'-----+-| declaración-variable-SQL |-+---;---+--'
'-| declaración-condición |----'
.-,---------------------------------.
V |
>--------sentencia-procedimiento-SQL--;---+--------------------->
>-----END--+-----------+---------------------------------------><
'-etiqueta--'
declaración-variable-SQL
.-,----------------------.
V |
|---DECLARE-------nombre-variable-SQL---+--tipo-datos----------->
.-DEFAULT NULL------------------.
>-----+-------------------------------+-------------------------|
'-DEFAULT--valores-por-omisión--'
declaración-condición
|---DECLARE--nombre-condición--CONDITION--FOR------------------->
.-VALUE-.
.-SQLSTATE--+-------+---.
>----+-----------------------+---constante-de-tipo-serie--------|
Notas:
- Se puede especificar una etiqueta sólo cuando la sentencia está incluida
en la definición de una función, método o desencadenante.
Descripción
- etiqueta
- Define la etiqueta del bloque de código ejecutable. Si se
especifica la etiqueta inicial, se puede utilizar para calificar variables de
SQL declaradas en la sentencia compuesta dinámica, y también se puede
especificar en una sentencia LEAVE. Si se especifica la etiqueta final,
debe ser igual a la etiqueta inicial.
- ATOMIC
- ATOMIC indica que, si se produce un error en la sentencia compuesta, se
retrotraerán todas las sentencias de SQL de la sentencia compuesta y las
sentencias restantes no se procesarán.
- sentencia-procedimiento-SQL
- Las siguientes sentencias de control de SQL se pueden utilizar
dentro de la sentencia compuesta dinámica:
- Sentencia FOR
- Sentencia GET DIAGNOSTICS
- Sentencia IF
- Sentencia ITERATE
- Sentencia LEAVE
- Sentencia SIGNAL
- Sentencia WHILE
Las sentencias de SQL que se pueden emitir son:
- Selección completa
6
- UPDATE de búsqueda
- DELETE de búsqueda
- INSERT
- Sentencia "SET variable"
- declaración-variable-SQL
- Declara una variable que es local respecto a la sentencia compuesta
dinámica.
- nombre-variable-SQL
- Define el nombre de una variable local. DB2 convierte a mayúsculas
todos los nombres de variables de SQL. El nombre debe cumplir estas
condiciones:
- No puede ser igual que otro nombre de variable de SQL existente en la
misma sentencia compuesta.
- No puede ser igual que el nombre de un parámetro.
- No puede ser igual que el nombre de una columna.
Si una sentencia de SQL contiene un identificador que tiene el mismo
nombre que una variable de SQL y que una referencia de columna, DB2 interpreta
el identificador como una columna.
- tipo-datos
- Especifica el tipo de datos de la variable.
- DEFAULT valores-por-omisión o NULL
- Define el valor por omisión de la variable de SQL. La variable se
inicializa cuando se invoca la sentencia compuesta dinámica. Si no se
especifica un valor por omisión, la variable toma el valor NULL.
- declaración-condición
- Declara un nombre de condición y el correspondiente valor de
SQLSTATE.
- nombre-condición
- Especifica el nombre de la condición. El nombre de la condición
debe ser exclusivo dentro del cuerpo del procedimiento y sólo puede aparecer
dentro de la sentencia compuesta en la que está declarada la condición.
- FOR SQLSTATE serie-caracteres-constante
- Especifica el SQLSTATE asociado a la condición. La
serie-caracteres-constante se debe especificar en forma de cinco
caracteres encerrados entre comillas simples, y no puede ser
'00000'.
Notas
- Las sentencias compuestas dinámicas son compiladas por DB2 como si se
tratara de una sentencia individual. Estas sentencias son útiles para
escribir scripts pequeños en los que hay poco código de control del flujo,
pero un flujo de datos importante. Para estructuras mayores que
requieren un control complejo del flujo, con uso del anidamiento, es
preferible utilizar procedimientos de SQL.
El diagrama de sintaxis se ha cambiado a lo siguiente:
>>-CREATE FUNCTION--nombre-función------------------------------>
>----(--+---------------------------------------------+---)----->
| .-,-------------------------------------. |
| V | |
'----+-------------------+---tipo-datos1---+--'
'-nombre-parámetro--'
>----*---RETURNS--tipo-datos2---*------------------------------->
>-----+------------------------------+--*----------------------->
'-SPECIFIC--nombre-específico--'
>-----+-SOURCE--+-nombre-función---------------------------------+----------------+>
| +-SPECIFIC--nombre-específico--------------------+ |
| '-nombre-función--(--+--------------------+---)--' |
| | .-,------------. | |
| | V | | |
| '----tipo-datos---+--' |
| .-NOT DETERMINISTIC--. .-EXTERNAL ACTION----. |
'-AS TEMPLATE--*----+--------------------+--*----+--------------------+--*--'
'-DETERMINISTIC------' '-NO EXTERNAL ACTION-'
>----*---------------------------------------------------------><
Añada lo siguiente a la sección "Descripción":
- DETERMINISTIC o NOT DETERMINISTIC
- Esta cláusula opcional especifica si la función devuelve siempre los
mismos resultados para unos valores argumento determinados (DETERMINISTIC) o
si la función depende de algunos valores de estado que afectan a los
resultados (NOT DETERMINISTIC). Es decir, una función definida como
DETERMINISTIC (determinista) debe siempre devolver la misma tabla para
entradas de datos sucesivas idénticas. Cuando se especifica NOT
DETERMINISTIC, se impiden las optimizaciones basadas en el hecho de que
entradas de datos idénticas producen resultados idénticos.
Debe especificarse NOT DETERMINISTIC, ya sea explícita o implícitamente, si
el cuerpo de la función accede a un registro especial o invoca otra función no
determinista (SQLSTATE 428C2).
- NO EXTERNAL ACTION o EXTERNAL ACTION
- Esta cláusula opcional especifica si la función realiza alguna acción que
cambia el estado de un objeto no gestionado por el gestor de bases de
datos. Cuando se especifica NO EXTERNAL ACTION, el sistema puede
realizar determinadas optimizaciones basadas en el hecho de que las funciones
no tienen ningún efecto externo.
Debe especificarse EXTERNAL ACTION, ya sea explícita o implícitamente, si
el cuerpo de la función invoca otra función que tiene una acción externa
(SQLSTATE 428C2).
El diagrama de sintaxis se ha cambiado a lo siguiente:
>>-CREATE FUNCTION--nombre-función------------------------------>
>----(--+---------------------------------------+---)---*------->
| .-,-------------------------------. |
| V | |
'----nombre-parámetro--tipo-datos1---+--'
>----RETURNS--+-tipo-datos2----------------------+--*----------->
'--+-ROW---+---| lista-columnas |--'
'-TABLE-'
.-LANGUAGE SQL--.
>-----+------------------------------+--*----+---------------+-->
'-SPECIFIC--nombre-específico--'
.-NOT DETERMINISTIC--. .-EXTERNAL ACTION----.
>----*----+--------------------+--*----+--------------------+--->
'-DETERMINISTIC------' '-NO EXTERNAL ACTION-'
.-READS SQL DATA--. .-STATIC DISPATCH--.
>----*----+-----------------+--*----+------------------+--*----->
'-CONTAINS SQL----'
(1)
.-CALLED ON NULL INPUT-------.
>-----+----------------------------+--*------------------------->
>-----+------------------------------------------------------+-->
| (2) |
'-PREDICATES--(--| especificación-predicado |--)-------'
>----| cuerpo-función-SQL |------------------------------------><
lista-columnas
.-,------------------------------.
V |
|---(-----nombre-columna--tipo-datos3---+---)-------------------|
cuerpo-función-SQL
|---+-Sentencia RETURN-------------+----------------------------|
'-sentencia-compuesta-dinámica-'
Notas:
- Se puede especificar NULL CALL en lugar de CALLED ON NULL INPUT
- Sólo es válido si RETURNS especifica un resultado escalar (tipo-datos2)
Cambie los parámetros siguientes:
- LANGUAGE SQL
- Especifica que la función se escribe utilizando SQL.
Esta sección de parámetros sustituyes a la sección de parámetros "RETURN
expresión, NULL, WITH expresión-tabla-común, selección-completa".
- cuerpo-función-SQL
- Especifica el cuerpo de la función. Los nombres de los parámetros
pueden aparecer en el cuerpo de la función SQL. Los nombres de los
parámetros pueden estar calificados con el nombre de la función para evitar
referencias ambiguas.
Si el cuerpo de la función SQL es una sentencia compuesta dinámica, debe
contener como mínimo una sentencia RETURN y se debe ejecutar una sentencia
RETURN cuando se invoca la función (SQLSTATE 42632). Si la función es
una función de tabla o de fila, entonces puede contener una sola sentencia
RETURN, la cual debe ser la última sentencia en la sentencia compuesta
dinámica (SQLSTATE 429BD).
Para obtener más información, vea Sentencia compuesta (dinámica) y RETURN.
El diagrama de sintaxis se ha cambiado por lo siguiente:
Sintaxis
>>-CREATE------------------------------------------------------->
>-----+-METHOD--+-nombre-método--------+---FOR--nombre-tipo--+-->
| '-| signatura-método |-' |
'-SPECIFIC METHOD--nombre-específico-------------------'
>-----+-*----EXTERNAL--+-------------------------------+--*----+--------------------------------+--*--+>
| '-NAME--+-'serie-caracteres'-+--' '-TRANSFORM GROUP--nombre-grupo--' |
| '-identificador------' |
'-| cuerpo-método-SQL |-------------------------------------------------------------------------'
>--------------------------------------------------------------><
signatura-método
|---nombre-método--(--+------------------------------------------------------------+---)-->
| .-,-----------------------------------------------------. |
| V | |
'----+-------------------+---tipo-datos1--+-------------+--+-'
'-nombre-parámetro--' '-AS LOCATOR--'
>----+--------------------------------------------------------------------+->
'-RETURNS--+-tipo-datos2--+-------------+-------------------------+--'
| '-AS LOCATOR--' |
'-tipo-datos3--CAST FROM--tipo-datos4--+-------------+-'
'-AS LOCATOR--'
>---------------------------------------------------------------|
cuerpo-método-SQL
|---+-Sentencia RETURN-------------+----------------------------|
'-sentencia-compuesta-dinámica-'
Los parámetros siguientes sustituyen a la sección "RETURN expresión-escalar
o NULL":
- cuerpo-método-SQL
- El cuerpo del método SQL define cómo se aplica el método si la
especificación de método en CREATE TYPE es LANGUAGE SQL.
El cuerpo del método SQL debe cumplir las partes siguientes de la
especificación de método:
- DETERMINISTIC o NOT DETERMINISTIC (SQLSTATE 428C2)
- EXTERNAL ACTION o NO EXTERNAL ACTION (SQLSTATE 428C2)
- CONTAINS SQL o READS SQL DATA (SQLSTATE 42985)
Los nombres de los parámetros pueden aparecer en el cuerpo del método
SQL. El sujeto del método se pasa a la implementación del método como
primer parámetro implícito llamado SELF.
Para obtener más información, vea Sentencia compuesta (dinámica) y RETURN.
La sentencia CREATE SEQUENCE crea una secuencia en el servidor de
aplicaciones.
Invocación
Esta sentencia se puede intercalar en un programa de aplicación o se puede
emitir mediante el uso de sentencias de SQL dinámicas. Es una sentencia
ejecutable que se puede preparar de forma dinámica. Sin embargo, si es
aplicable la opción de enlace DYNAMICRULES BIND, la sentencia no se puede
preparar de forma dinámica (SQLSTATE 42509).
Autorización
El ID de autorización de la sentencia debe contener como mínimo uno de los
privilegios siguientes:
- Privilegio CREATEIN para el esquema especificado implícita o
explícitamente
- Autorización SYSADM o DBADM
Sintaxis
.-AS INTEGER------.
>>-CREATE SEQUENCE--nombre-secuencia---*----+-----------------+->
'-AS--tipo-datos--'
>----*----+---------------------------------+--*---------------->
'-START WITH--constante-numérica--'
.-INCREMENT BY 1--------------------.
>-----+-----------------------------------+--*------------------>
'-INCREMENT BY--constante-numérica--'
(1)
.-NO MINVALUE-------------------.
>-----+-------------------------------+--*---------------------->
'-MINVALUE--constante-numérica--'
.-NO MAXVALUE-------------------. .-NO CYCLE--.
>-----+-------------------------------+--*----+-----------+--*-->
'-MAXVALUE--constante-numérica--' '-CYCLE-----'
.-CACHE 20-----------------. .-NO ORDER--.
>-----+--------------------------+--*----+-----------+--*------><
+-CACHE--constante-entera--+ '-ORDER-----'
'-NO CACHE-----------------'
Notas:
- Estos parámetros se pueden especificar sin espacios en blanco:
NOMINVALUE, NOMAXVALUE, NOCYCLE, NOCACHE y NOORDER. Se pueden utilizar
estas formas abreviadas de una sola palabra como alternativa a las expresiones
que constan de dos palabras.
Descripción
- nombre-secuencia
- Designa la secuencia. La combinación nombre de secuencia - nombre
de esquema implícito/explícito no debe designar una secuencia ya existente en
el servidor actual (SQLSTATE 42710).
La forma no calificada del nombre de secuencia es un identificador de
SQL. La forma calificada es un calificador seguido de un punto y un
identificador de SQL. El calificador es un nombre de esquema.
Si el nombre de secuencia está calificado explícitamente con un nombre de
esquema, el nombre de esquema no puede comenzar con 'SYS'; de
lo contrario se producirá un error (SQLSTATE 42939).
- AS tipo-datos
- Especifica el tipo de datos que se deben utilizar para el valor de
secuencia. El tipo de datos puede ser cualquier tipo numérico exacto
(SMALLINT, INTEGER, BIGINT o DECIMAL) cuya escala sea 0, o un tipo
diferenciado definido por el usuario cuyo tipo fuente es un tipo numérico
exacto con escala 0 (SQLSTATE 42815). El valor por omisión es
INTEGER.
- START WITH constante-numérica
- Especifica el primer valor de la secuencia. Este valor puede ser
cualquier valor positivo o negativo que pueda asignarse a una columna del tipo
de datos asociado a la secuencia (SQLSTATE 42820), sin dígitos distintos de
cero a la derecha de la coma decimal (SQLSTATE 428FA). El valor por
omisión es MINVALUE para secuencias ascendentes, y MAXVALUE para las
secuencias descendentes.
Este valor no es necesariamente igual al valor que una secuencia alcanza
después de llegar al valor máximo o mínimo de la secuencia. La cláusula
START WITH se puede utilizar para iniciar una secuencia fuera del rango
utilizado para los ciclos de valores. El rango utilizado para los
ciclos se define mediante MINVALUE y MAXVALUE.
- INCREMENT BY constante-numérica
- Especifica el intervalo existente entre valores consecutivos de la
secuencia. Este valor puede ser cualquier valor positivo o negativo que
pueda asignarse a una columna del tipo de datos asociado a la secuencia
(SQLSTATE 42820), sin exceder el valor de una constante entera grande (SLSTATE
42815) y sin dígitos distintos de cero a la derecha de la coma decimal
(SQLSTATE 428FA).
Si este valor es negativo, la secuencia de valores es decreciente.
Si este valor es positivo, la secuencia de valores es creciente. Si
este valor es 0 o mayor que el rango definido por MINVALUE y MAXVALUE, se
genera un solo valor, pero por lo demás la secuencia se trata como una
secuencia ascendente. El valor por omisión es 1.
- MINVALUE o NO MINVALUE
- Especifica el valor mínimo en el que se reinicia o detiene una secuencia
descendente de valores, o el valor al que vuelve una secuencia ascendente
después de alcanzar el valor máximo.
- MINVALUE constante-numérica
- Especifica la constante numérica que es el valor mínimo. Este valor
puede ser cualquier valor positivo o negativo que pueda asignarse a una
columna del tipo de datos asociado a la secuencia (SQLSTATE 42820), sin
dígitos distintos de cero a la derecha de la coma decimal (SQLSTATE 428FA),
pero el valor debe ser menor o igual que el valor máximo (SQLSTATE
42815).
- NO MINVALUE
- Para una secuencia ascendente, es igual al valor de START WITH, o 1 si
START WITH no se especifica. Para una secuencia descendente, es igual
al valor mínimo del tipo de datos asociado a la secuencia. Éste es el
valor por omisión.
- MAXVALUE o NO MAXVALUE
- Especifica el valor máximo en el que se reinicia o detiene una secuencia
ascendente de valores, o el valor al que vuelve una secuencia ascendente
después de alcanzar el valor mínimo.
- MAXVALUE constante-numérica
- Especifica la constante numérica que es el valor máximo. Este valor
puede ser cualquier valor positivo o negativo que pueda asignarse a una
columna del tipo de datos asociado a la secuencia (SQLSTATE 428FA), sin
dígitos distintos de cero a la derecha de la coma decimal (SQLSTATE 428FA),
pero el valor debe ser mayor o igual que el valor mínimo (SQLSTATE
42815).
- NO MAXVALUE
- Para una secuencia ascendente, es igual al valor máximo del tipo de datos
asociado a la secuencia. Para una secuencia descendente, es igual al
valor de START WITH, o -1 si START WITH no se especifica. Éste es el
valor por omisión.
- CYCLE o NO CYCLE
- Especifica si la secuencia debe seguir generando valores después de
alcanzar su valor máximo o mínimo. El límite de la secuencia se puede
alcanzar con el valor siguiente que coincida exactamente con el límite de la
condición o bien superándola.
- CYCLE
- Especifica que la secuencia siga generando valores después de alcanzar su
valor máximo o mínimo. Si se utiliza esta opción, cuando una secuencia
ascendente alcanza su valor máximo, genera su valor mínimo; en el caso de
secuencia descendente, cuando alcanza su valor mínimo, genera su valor
máximo. Los valores máximo y mínimo de la secuencia determinan el rango
utilizado para la generación cíclica de valores.
Si el parámetro CYCLE está en vigor, se pueden generar valores duplicados
para la secuencia.
- NO CYCLE
- Especifica que no se generen valores para la secuencia una vez alcanzado
el valor máximo o mínimo de la secuencia. Éste es el valor por
omisión.
- CACHE o NO CACHE
- Especifica si deben guardarse en la memoria algunos valores preasignados
para acceder a ellos más rápidamente. Ésta es una opción para el
rendimiento y ajuste del sistema.
- CACHE constante-entera
- Especifica el número máximo de valores de la secuencia que se preasignan y
guardan en la memoria. La preasignación y mantenimiento de valores en
la antememoria disminuye la E/S síncrona en el archivo de anotaciones cuando
se generan valores para la secuencia.
Si se produce un error del sistema, los valores de secuencia puestos en
antememoria que no se han utilizado en sentencias confirmadas se pierden (es
decir, no se utilizarán nunca). El valor especificado para la opción
CACHE es el número máximo de valores de secuencia que se podrían perder si se
produce un error del sistema.
El valor mínimo es 2 (SQLSTATE 42815). El valor por omisión es CACHE
20.
- NO CACHE
- Especifica que no se deben preasignar valores de la secuencia. Esta
opción asegura que no haya pérdida de valores en el caso de un error del
sistema, cierre del sistema o desactivación de la base de datos. Si se
especifica esta opción, los valores de la secuencia no se ponen en la
antememoria. En este caso, cada petición de un nuevo valor para la
secuencia origina una E/S síncrona en el archivo de anotaciones.
- NO ORDER o ORDER
- Especifica si los valores de la secuencia se deben generar en orden de
petición.
- ORDER
- Especifica que los valores de la secuencia se generan en orden de
petición.
- NO ORDER
- Especifica que no es necesario que los valores de la secuencia se generen
en orden de petición. Éste es el valor por omisión.
Notas
- Se puede definir una secuencia constante, es decir, una secuencia que
siempre devuelve un valor constante. Para ello, especifique el mismo
valor para MINVALUE y MAXVALUE, o especifique 0 para el valor de
INCREMENT. En ambos casos, para permitir que NEXTVAL genere el mismo
valor más de una vez, debe especificar CYCLE. Una secuencia constante
se puede utilizar como variable global numérica. Puede utilizar ALTER
SEQUENCE para ajustar los valores que se generarán para una secuencia
constante.
- Puede utilizar la sentencia ALTER SEQUENCE para hacer que la secuencia
genere valores de forma cíclica. Si se especifica NO CYCLE, ya sea
implícita o explícitamente, la secuencia se puede reiniciar o ampliar
utilizando la sentencia ALTER SEQUENCE, para que se sigan generando valores
una vez alcanzado el valor máximo o mínimo de la secuencia.
- La puesta en antememoria de números de secuencia permite un acceso más
rápido a un rango de números de secuencia. Cuando una aplicación accede
a una secuencia que puede asignar el siguiente número de secuencia a partir de
la antememoria, la asignación de números de secuencia se puede producir con
rapidez. Si no es posible la asignación del siguiente número de la
secuencia a partir de la antememoria, el proceso de asignación puede tener que
esperar a que se realicen operaciones de E/S en un dispositivo de
almacenamiento permanente. La selección de un valor para CACHE debe
hacerse teniendo en cuenta los efectos sobre el rendimiento del sistema y los
requisitos de la aplicación utilizada.
- El propietario tiene los privilegios ALTER y USAGE sobre la nueva
secuencia. El propietario sólo puede otorgar el privilegio USAGE y el
otorgamiento sólo puede hacerse a PUBLIC.
- La sintaxis siguiente también recibe soporte: NOMINVALUE,
NOMAXVALUE, NOCYCLE, NOCACHE y NOORDER.
Ejemplos
Ejemplo 1: Creación de una secuencia llamada
org_seq:
CREATE SEQUENCE org_seq
START WITH 1
INCREMENT BY 1
NO MAXVALUE
NO CYCLE
CACHE 24
Sintaxis
>>-CREATE TRIGGER--nombre-desencadenante------------------------>
>-----+-NO CASCADE BEFORE-+------------------------------------->
'-AFTER-------------'
>-----+-INSERT--------------------------------+----------------->
+-DELETE--------------------------------+
'-UPDATE--+---------------------------+-'
| .-,-----------------. |
| V | |
'-OF----nombre-columna---+--'
>----ON--nombre-tabla------------------------------------------->
>-----+------------------------------------------------------------------------+>
| .------------------------------------------------------. |
| V (1) (2) .-AS-. | |
'-REFERENCING-------------------+-OLD--+----+--nombre-correlación--+--+--'
| .-AS-. |
+-NEW-+----+--nombre-correlación---+
| .-AS-. |
+-OLD_TABLE-+----+--identificador--+
| .-AS-. |
'-NEW_TABLE-+----+--identificador--'
>-----+-FOR EACH ROW---------------+--MODE DB2SQL--------------->
| (3) |
'--------FOR EACH STATEMENT--'
>-----| acción-activada |--------------------------------------><
acción-activada
|--+---------------------------------+-------------------------->
'-WHEN--(--condición-búsqueda--)--'
>----sentencia-procedimiento-SQL--------------------------------|
Notas:
- OLD y NEW se pueden especificar una sola vez cada uno.
- OLD_TABLE y NEW_TABLE se pueden especificar una sola vez cada uno y sólo
para desencadenantes AFTER (desencadenantes posteriores).
- FOR EACH STATEMENT no se puede especificar para desencadenantes BEFORE
(desencadenantes anteriores).
Sustituya la descripción de "acción-activada" por lo siguiente:
- acción-activada
- Especifica la acción que se debe realizar cuando se activa un
desencadenante. Una acción activada consta de una sentencia de
procedimiento SQL y una condición opcional para la ejecución de esa
sentencia de procedimiento.
- WHEN (condición-búsqueda)
- Especifica una condición cuya evaluación da un resultado verdadero, falso
o desconocido. La condición de búsqueda permite determinar si
una determinada acción activada se debe o no ejecutar.
La acción asociada se ejecuta sólo si la evaluación de la condición de
búsqueda especificada da un resultado verdadero. Si se omite la
cláusula WHEN, la correspondiente sentencia de procedimiento SQL se
ejecuta siempre.
- sentencia-procedimiento-SQL
- La sentencia de procedimiento SQL puede contener una sentencia
compuesta dinámica o cualquiera de las sentencias de control SQL listadas en Sentencia compuesta (dinámica).
Si se especifica un desencadenante anterior (BEFORE), la sentencia de
procedimiento SQL puede también contener una selección completa
o una sentencia de variable SET (SQLSTATE 42987).
Si se utiliza un desencadenante posterior (AFTER), una sentencia de
procedimiento SQL puede también incluir uno de los elementos siguientes
(SQLSTATE 42987):
- una sentencia INSERT de SQL
- una sentencia UPDATE de búsqueda de SQL
- una sentencia DELETE de búsqueda de SQL
- una sentencia SET "variable"
- una selección completa 7
La sentencia de procedimiento SQL no puede hacer referencia a una
variable de transición no definida (SQLSTATE 42703) ni a una tabla temporal
declarada (SQLSTATE 42995).
La sentencia de procedimiento SQL contenida en un desencadenante
anterior (BEFORE) no puede hacer referencia a una tabla de resumen definida
con REFRESH IMMEDIATE (SQLSTATE 42997).
La sentencia de procedimiento SQL contenida en un desencadenante
anterior (BEFORE) no puede hacer referencia a una columna generada, que no sea
la columna de identidad, en la nueva variable de transición (SQLSTATE
42989).
La sección de Notas se ha cambiado a lo siguiente:
- El resultado de una selección completa especificada en la sentencia de
procedimiento SQL no es accesible dentro ni fuera del
desencadenante.
- Desencadenantes inoperativos:
Un desencadenante inoperativo es un
desencadenante que ya no puede utilizarse y por tanto no se activa
nunca. Un desencadenante pasa a ser inoperativo cuando se cumple
cualquiera de estas condiciones:
- Se revoca un privilegio que el creador del desencadenante necesita tener
para ejecutar el desencadenante.
- Se elimina un objeto, tal como una tabla, vista o alias, del cual depende
la acción activada.
- Pasa a ser inoperativa una vista de la cual depende la acción
activada.
- Se elimina un alias que es la tabla sujeto del desencadenante.
En términos prácticos, un desencadenante inoperativo es aquél para el cual
se ha eliminado una definición de desencadenante como resultado de la
propagación en cascada de normas para sentencias DROP o REVOKE. Por
ejemplo, cuando se elimina una vista, pasa a ser inoperativo cualquier
desencadenante que tenga una sentencia de procedimiento SQL definida
utilizando esa vista.
Cuando un desencadenante deviene inoperativo, se inhabilitan todos los
paquetes que contienen sentencias con operaciones de activación del
desencadenante. Cuando el paquete se vuelve a enlazar (explícita o
implícitamente), se pasa completamente por alto el desencadenante
inoperativo. De la misma manera, las aplicaciones con sentencias
de SQL dinámicas que activaban el desencadenante también pasarán por alto
cualquier desencadenante inoperativo.
El nombre del desencadenante se puede seguir especificando en las
sentencias DROP TRIGGER y COMMENT ON TRIGGER.
Puede emitir la sentencia CREATE TRIGGER para reconstruir un desencadenante
inoperativo, utilizando el texto de definición del desencadenante. Este
texto de definición de desencadenante se guarda en la columna TEXT de
SYSCAT.TRIGGERS. No es necesario eliminar explícitamente el
desencadenante inoperativo para poder volver a crearlo. Cuando se emite
una sentencia CREATE TRIGGER con un nombre de desencadenante
inoperativo, el desencadenante se sustituye por un aviso (SQLSTATE
01595).
Los desencadenante inoperativos están indicados con una X en la columna
VALID de la vista de catálogo SYSCAT.TRIGGERS.
- Errores al ejecutar desencadenantes:
Los errores que se producen durante la ejecución de sentencias de SQL
activadas por un desencadenante se devuelven utilizando SQLSTATE 09000, a
menos que el error se considere grave. Si el error es grave, se
devuelve el SQLSTATE de error grave. El campo SQLERRMC de la SQLCA para
errores no graves incluye el nombre del desencadenante, el SQLCODE, el
SQLSTATE y todos los símbolos resultantes del error que sean
aplicables.
La sentencia de procedimiento SQL puede incluir una sentencia
SIGNAL SQLSTATE o contener una función RAISE_ERROR. En ambos casos, el
SQLSTATE devuelto es el especificado en la sentencia SIGNAL SQLSTATE o
condición RAISE_ERROR.
Linux utiliza bibliotecas llamadas LIBDRDA.SO y
LIBSQLNET.SO, no LIBDRDA.A ni
LIBSQLNET.A.
Dentro de la sentencia "DECLARE CURSOR", casi al final de la sección
Notas, se debe cambiar la siguiente frase:
Un cursor ambiguo se considera de sólo lectura si la opción de vinculación
BLOCKING es ALL; de lo contrario, se considera suprimible.
por:
Un cursor ambiguo se considera de sólo lectura si la opción de vinculación
BLOCKING es ALL; de lo contrario, se considera actualizable.
Se ha cambiado "suprimible" por "actualizable".
El diagrama de sintaxis de la sentencia DELETE de búsqueda se ha cambiado a
lo siguiente:
>>-DELETE FROM----+-nombre-tabla-------------------+------------>
+-nombre-vista-------------------+
'-ONLY--(--+-nombre-tabla-+---)--'
'-nombre-vista-'
>-----+-----------------------------+--------------------------->
| .-AS-. |
'-+----+--nombre-correlación--'
>-----+----------------------------+---+---------------+-------><
'-WHERE--condición-búsqueda--' '-WITH--+-RR-+--'
+-RS-+
+-CS-+
'-UR-'
DELETE de posición:
>>-DELETE FROM----+-nombre-tabla-------------------+------------>
+-nombre-vista-------------------+
'-ONLY--(--+-nombre-tabla-+---)--'
'-nombre-vista-'
>----WHERE CURRENT OF--nombre-cursor---------------------------><
Añada lo siguiente a la sección "Descripción":
- WITH
-
Especifica el nivel de aislamiento utilizado al localizar las filas que deben
suprimirse.
- RR
- Lectura repetida
- RS
- Estabilidad de lectura
- CS
- Estabilidad del cursor
- UR
- Lectura no comprometida
El nivel de aislamiento predefinido de la sentencia es el nivel de
aislamiento del paquete en el que está enlazada la sentencia.
Añada la opción siguiente:
>>-SEQUENCE--nombre-secuencia--RESTRICT------------------------><
Añada los parámetros siguientes:
- SEQUENCE nombre-secuencia RESTRICT
-
Identifica la secuencia determinada que se debe eliminar. El
nombre-secuencia, junto con el nombre de esquema implícito o
explícito, debe designar una secuencia existente en el servidor actual.
Si en el esquema especificado explícita o implícitamente no existe ninguna
secuencia cuyo nombre sea el indicado, se emite un error (SQLSTATE
42704).
La palabra clave RESTRICT evita que la secuencia se elimine si la
definición de una columna de tabla hace referencia a la secuencia (mediante
una columna IDENTITY).
- Nota:
-
- Las secuencias creadas por el sistema para columnas IDENTITY no se pueden
eliminar utilizando el mandato "DROP secuencia".
- Cuando se elimina una secuencia, se eliminan también todos los privilegios
establecidos para ella.
La tabla que muestra las dependencias existentes entre los objetos (Tabla
27) debe actualizarse de la manera siguiente:
Nueva fila: DROP SEQUENCE. La entrada de tabla correspondiente
a la intersección de la fila "DROP SEQUENCE" y la columna "PACKAGE" será una
"A". El resto de las entradas en esta nueva fila será "-"
Esta forma de la sentencia GRANT otorga privilegios para una secuencia
definida por el usuario.
Invocación
Esta sentencia se puede intercalar en un programa de aplicación o se puede
emitir mediante el uso de sentencias de SQL dinámicas. Es una sentencia
ejecutable que se puede preparar de forma dinámica. Sin embargo, si es
aplicable la opción de enlace DYNAMICRULES BIND, la sentencia no se puede
preparar de forma dinámica (SQLSTATE 42509).
Autorización
El ID de autorización de la sentencia debe contener como mínimo uno de los
privilegios siguientes:
- Propietario de la secuencia
- Autorización SYSADM o DBADM
Sintaxis
>>-GRANT--USAGE--ON SEQUENCE--nombre-secuencia--TO PUBLIC------><
Descripción
- USAGE
- Otorga el privilegio USAGE para una secuencia.
- ON SEQUENCE nombre-secuencia
- Identifica la secuencia para la que se debe otorgar el privilegio
USAGE. El nombre-secuencia, junto con el nombre de esquema
implícito o explícito que actúa como calificador, debe designar de forma
exclusiva una secuencia existente en el servidor actual. Si en el
esquema especificado no existe ninguna secuencia cuyo nombre sea el indicado,
se emite un error (SQLSTATE 42704).
- TO PUBLIC
- Otorga el privilegio USAGE a todos los usuarios.
Ejemplos
Ejemplo 1: Otorgamiento del privilegio a cualquier
usuario para una secuencia llamada MYNUM
GRANT USAGE ON SEQUENCE MYNUM TO PUBLIC
El diagrama de sintaxis se ha cambiado a lo siguiente:
>>-INSERT INTO----+-nombre-tabla-+------------------------------>
'-nombre-vista-'
>-----+-------------------------------+------------------------->
| .-,-----------------. |
| V | |
'-(-----nombre-columna---+---)--'
.-,-----------------------------------.
V |
>-----+-VALUES------+-+-expresión-+----------------+--+---------------+>
| | +-NULL------+ | |
| | '-DEFAULT---' | |
| | .-,----------------. | |
| | V | | |
| '-(------+-expresión-+--+---)--' |
| +-NULL------+ |
| '-DEFAULT---' |
'-+-------------------------------------+---selección-completa--'
| .-,------------------------. |
| V | |
'-WITH-----expresión-tabla-común---+--'
>-----+---------------+----------------------------------------><
'-WITH--+-RR-+--'
+-RS-+
+-CS-+
'-UR-'
Añada lo siguiente a la sección "Descripción":
- WITH
-
Especifica el nivel de aislamiento bajo el que se ejecuta la selección
completa (fullselect).
- RR
- Lectura repetida
- RS
- Estabilidad de lectura
- CS
- Estabilidad del cursor
- UR
- Lectura no comprometida
El nivel de aislamiento predefinido de la sentencia es el nivel de
aislamiento del paquete en el que está enlazada la sentencia.
El diagrama de sintaxis se ha cambiado a lo siguiente:
.-,------------------------------.
V |
>>-cláusula-select--INTO-------variable-lenguaje-principal---+-->
>----cláusula-from---------------------------------------------->
>----+----------------+--+-------------------+--+-----------------+->
'-cláusula-where-' '-cláusula-group-by-' '-cláusula-having-'
>-----+---------------+----------------------------------------><
'-WITH--+-RR-+--'
+-RS-+
+-CS-+
'-UR-'
Añada lo siguiente a la sección "Descripción":
- WITH
-
Especifica el nivel de aislamiento bajo el que se ejecuta la sentencia SELECT
INTO.
- RR
- Lectura repetida
- RS
- Estabilidad de lectura
- CS
- Estabilidad del cursor
- UR
- Lectura no comprometida
El nivel de aislamiento predefinido de la sentencia es el nivel de
aislamiento del paquete en el que está enlazada la sentencia.
La sentencia SET ENCRYPTION PASSWORD define la contraseña que se utilizará
en las funciones de cifrado y descifrado. La contraseña no está
vinculada a la autenticación de DB2 y se utiliza sólo para el cifrado de
datos.
Esta sentencia no está bajo el control de las transacciones.
Invocación
Esta sentencia se puede intercalar en un programa de aplicación o se puede
emitir interactivamente. Es una sentencia ejecutable que se puede
preparar de forma dinámica.
Autorización
No es necesaria ninguna autorización para ejecutar esta sentencia.
Sintaxis
.-=-.
>>-SET--ENCRYPTION PASSWORD--+---+--+-variable-lenguaje-principal-+->
'-constante-de-tipo-serie-----'
>--------------------------------------------------------------><
Descripción
La contraseña definida por ENCRYPTION PASSWORD se puede utilizar en las
funciones internas ENCRYPT, DECRYPT_BIN y DECRYPT_CHAR para el cifrado basado
en contraseña. La longitud del valor debe estar comprendida entre 6 y
127, ambos inclusive. Los caracteres se deben especificar utilizando la
combinación exacta deseada de mayúsculas y minúsculas, pues no hay conversión
a mayúsculas.
- variable-lenguaje-principal
- Es una variable de tipo CHAR o VARCHAR. La longitud del contenido
de la variable de lenguaje principal debe estar comprendida entre 6 y 127,
ambos inclusive (SQLSTATE 428FC). Este valor no puede ser nulo.
Los caracteres se deben especificar utilizando la combinación exacta deseada
de mayúsculas y minúsculas, pues no hay conversión a mayúsculas.
- constante-de-tipo-serie
- Es una constante de tipo serie de caracteres. La longitud debe
estar comprendida entre 6 y 127, ambos inclusive (SQLSTATE 428FC).
Reglas
- El valor inicial de ENCRYPTION PASSWORD es la serie de caracteres vacía
('').
- La variable de lenguaje principal o la constante de tipo serie de
caracteres se pasa al servidor de bases de datos utilizando mecanismos
normales de DB2.
Notas
Ejemplos
Ejemplo 1: La sentencia siguiente define la
contraseña de cifrado.
SET ENCRYPTION PASSWORD = 'bubbalu'
Esta sección se ha cambiado a lo siguiente:
La sentencia "SET Variable" asigna valores a variables locales o a nuevas
variables de transición. Esta sentencia está bajo el control de las
transacciones.
Invocación
Esta sentencia sólo se puede utilizar como sentencia de SQL en una
sentencia compuesta dinámica, en un desencadenante, en una función de SQL o en
un método SQL.
Autorización
Para hacer referencia a una variable de transición, el ID de autorización
del creador del desencadenante debe contener como mínimo uno de los
privilegios siguientes:
- Privilegio UPDATE para las columnas referenciadas en el lado izquierdo de
la asignación y privilegio SELECT para las columnas referenciadas en el lado
derecho.
- Privilegio CONTROL para la tabla (tabla sujeto del desencadenante)
- Autorización SYSADM o DBADM.
Para ejecutar esta sentencia con una selección completa de fila
en el lado derecho de la asignación, el ID de autorización del definidor del
desencadenante o el propietario de la sentencia compuesta dinámica debe tener
como mínimo uno de estos privilegios para cada tabla o vista
referenciada:
- Privilegio SELECT
- Privilegio CONTROL
- Autorización SYSADM o DBADM.
Sintaxis
>>-SET---------------------------------------------------------->
.-,--------------------------------------------------------------------------------------.
V |
>--------+-| variable-destino |--=--+-expresión-+-------------------------------------------+--+>
| +-NULL------+ |
| '-DEFAULT---' |
| .-,-----------------------. .-,-------------------. |
| V | V (1) | |
'-(-----| variable-destino |---+---)--=--(--+----+-expresión------+--+------+---)--'
| +-NULL-----------+ |
| '-DEFAULT--------' |
| (2) |
'-selección-completa-fila-------'
>--------------------------------------------------------------><
variable-destino
|---+-nombre-variable-SQL--------+------------------------------>
'-nombre-variable-transición-'
>-----+---------------------------+-----------------------------|
| .---------------------. |
| V | |
'----..nombre-atributo---+--'
Notas:
- El número de expresiones, valores NULL y valores DEFAULT debe coincidir
con el número de variables de destino.
- El número de columnas en la lista de selección debe coincidir con el
número de variables de destino.
Descripción
- variable-destino
- Identifica la variable de destino de la asignación. No puede
especificarse una misma variable de destino más de una vez (SQLSTATE
42701).
- nombre-variable-SQL
- Identifica la variable de SQL que es el destino de la asignación.
Las variables de SQL se deben declarar para poder utilizarlas. Se
pueden definir variables de SQL en una sentencia compuesta dinámica.
- nombre-variable-transición
- Identifica la columna que se debe actualizar en la fila de
transición. El nombre de variable de transición debe
identificar una columna de la tabla sujeto de un desencadenante, que puede
estar calificada por un nombre de correlación correspondiente al nuevo valor
(SQLSTATE 42703).
- ..nombre-atributo
- Especifica el atributo de un tipo estructurado que está definido como una
asignación de atributo. El nombre de variable
SQLo nombre de variable de transición especificado se debe
definir con un tipo estructurado definido por el usuario (SQLSTATE
428DP). El nombre de atributo debe ser un atributo del tipo
estructurado (SQLSTATE 42703). Cuando una asignación no utiliza la
cláusula ..nombre de atributo se denomina asignación
convencional.
- expresión
- Indica el nuevo valor de la variable-destino. El tipo de
la expresión puede ser cualquiera de los descritos en el Capítulo 2 del manual
Consulta de SQL. La expresión no puede incluir una función de columna,
excepto si la expresión aparece dentro de una selección completa escalar
(SQLSTATE 42903). En el contexto de una sentencia CREATE TRIGGER, una
expresión puede contener referencias a variables de transición
nuevas (OLD) y antiguas (NEW), las cuales deben estar calificadas por el
nombre de correlación para especificar qué variable de transición
utilizar (SQLSTATE 42702).
- NULL
- Especifica el valor nulo y sólo se puede especificar para columnas que
pueden contener nulos (SQLSTATE 23502). Una asignación de atributos no
puede tener el valor NULL (SQLSTATE 429B9), a menos que se realizara una
conversión al tipo de datos del atributo.
- DEFAULT
- Especifica que debe utilizarse el valor por omisión.
Si la variable-destino es una columna, el valor insertado depende
de cómo se definió la columna en la tabla.
- Si la columna se definió utilizando la cláusula WITH DEFAULT, se utiliza
el valor por omisión definido para la columna.
- Si la columna se definió utilizando la cláusula IDENTITY, el valor es
generado por el gestor de bases de datos.
- Si la columna se definió sin especificar la cláusula WITH DEFAULT, la
cláusula IDENTITY ni la cláusula NOT NULL, el valor es NULL.
- Si la columna se definió utilizando la cláusula NOT NULL y no se usa la
cláusula IDENTITY o no se usa la cláusula WITH DEFAULT o se usa DEFAULT NULL,
no se puede especificar la palabra clave DEFAULT para esa columna (SQLSTATE
23502).
Si la variable-destino es una variable de SQL, el valor que se
inserta es el valor por omisión, definido explícita o implícitamente en la
declaración de la variable.
- selección-completa-fila
- Es una selección completa que devuelve una fila individual junto con el
número de columnas correspondiente al número de variables de destino
especificadas para la asignación. Los valores se asignan a cada
variable de destino correspondiente. Si el resultado de la selección
completa no devuelve ninguna fila, se asignan valores nulos. En el
contexto de una sentencia CREATE TRIGGER, una selección completa de
fila puede contener referencias a variables de transición antiguas (OLD)
y nuevas (NEW), las cuales deben estar calificadas por su nombre de
correlación para especificar qué variable de transición a utilizar
(SQLSTATE 42702). Se devuelve un error si hay más de una fila en el
resultado (SQLSTATE 21000).
Reglas
- El número de valores que deben asignarse procedentes de expresiones,
valores NULL y valores DEFAULT o valores de la selección completa de
fila debe coincidir con el número de variables de destino especificadas
para la asignación (SQLSTATE 42802).
- La sentencia "SET Variable" no puede asignar una variable SQL y una
variable de transición en una misma sentencia (SQLSTATE 42997).
- Los valores se asignan a las variables de destino de acuerdo con las
reglas de asignación descritas en el Capítulo 2 del manual Consulta de
SQL.
Si la sentencia se utiliza en un desencadenante BEFORE UPDATE, y el
registro contiene la variable DB2_UPDATE_PART_KEY=OFF, una variable de
transición especificada como variable de destino no puede ser
una columna de clave de particionamiento (SQLSTATE 42997).
Notas
- Si se incluye más de una asignación, se evalúan todas las
expresiones y selecciones completas de fila antes de
efectuar las asignaciones. Por tanto, las referencias a variables de
destino en una expresión o selección completa de fila son siempre el valor de
la variable de destino antes de cualquier asignación de la sentencia
SET.
- Cuando se actualiza una columna de identidad definida como tipo
diferenciado, el cálculo completo se realiza sobre el tipo original y el
resultado se convierte al tipo diferenciado antes de asignar realmente el
valor a la columna.
8
- Para hacer que DB2 genere un valor en una sentencia SET para una columna
de identidad, utilice la palabra clave DEFAULT:
SET NEW.EMPNO = DEFAULT
En este ejemplo, NEW.EMPNO está definido como columna de
identidad, y DB2 genera el valor utilizado para actualizar esa columna.
Los ejemplos utilizados para esta sentencia siguen siendo los
mismos.
El diagrama de sintaxis de la sentencia UPDATE de búsqueda se ha cambiado a
lo siguiente:
>>-UPDATE----+-nombre-tabla-------------------+----------------->
+-nombre-vista-------------------+
'-ONLY--(--+-nombre-tabla-+---)--'
'-nombre-vista-'
>-----+-----------------------------+--------------------------->
| .-AS-. |
'-+----+--nombre-correlación--'
>-----SET--| cláusula-asignación |------------------------------>
>-----+----------------------------+---+---------------+-------><
'-WHERE--condición-búsqueda--' '-WITH--+-RR-+--'
+-RS-+
+-CS-+
'-UR-'
Añada lo siguiente a la sección "Descripción":
- WITH
-
Especifica el nivel de aislamiento bajo el que se ejecuta la sentencia
UPDATE.
- RR
- Lectura repetida
- RS
- Estabilidad de lectura
- CS
- Estabilidad del cursor
- UR
- Lectura no comprometida
El nivel de aislamiento predefinido de la sentencia es el nivel de
aislamiento del paquete en el que está enlazada la sentencia.
Notas a pie de página:
- 6
-
La selección completa puede ir precedida por una expresión de tabla común
- 7
-
Una selección completa puede estar precedida por una expresión de tabla
común.
- 8
-
Antes del cálculo no se realiza ninguna conversión del valor anterior al tipo
original.
[ Principio de página | Página anterior | Página siguiente ]