MANUAL DB2-SQL

Manual DB2-SQL.:1
 INDICE

1. INTRODUCCIN.........................................................................................4
2. SQL EN PROGRAMAS DE APLICACIN...............................................................5
2.1. DB2 EMBEBIDO. REA DE COMUNICACIONES SQLCA.............................................................................5
2.2. DECLARACIONES EN WORKING-STORAGE SECTION..............................................................................6
2.2.1. DEFINICIONES DE CAMPOS DE TRABAJO............................................................................................6
2.2.2. FORMATO DE SENTENCIAS DB2-SQL EMBEBIDO.............................................................................7
2.2.3. SENTENCIA INCLUDE....................................................................................................................................7
2.2.3.1. DECLARACIN DE TABLAS...................................................................................................................8
2.2.4. VARIABLES HOST............................................................................................................................................9
3. RECUPERACIN DE DATOS...........................................................................11
3.1. CLASULA SELECT..................................................................................................................................................11
3.2. CLASULA INTO....................................................................................................................................................12
3.3. CLASULA FROM....................................................................................................................................................13
3.4. CLASULA WHERE.................................................................................................................................................13
3.4.1. CLAVES E NDICES........................................................................................................................................16
3.5. CLASULA ORDER BY. CONSULTAS ORDENADAS....................................................................................17
3.6. CLASULA GROUP BY / HAVING. CONSULTAS AGRUPADAS................................................................18
3.7. SUBCONSULTAS....................................................................................................................................................20
3.7.1.SUBCONSULTAS EN LA CLASULA WHERE.........................................................................................20
3.8. FUNCIONES DE COLUMNA................................................................................................................................22
3.8.1. SUM( ).................................................................................................................................................................22
3.8.2. AVG( )..................................................................................................................................................................23
3.8.3. MIN( ) Y MAX( )..............................................................................................................................................23
3.8.4. COUNT( ) Y COUNT(*)..................................................................................................................................23
3.9. OPERACIONES ARITMTICAS.........................................................................................................................24
3.10. RECUPERACIN DE DATOS DESDE 2 O MS TABLAS: JOIN............................................................24
4. MODIFICACIN DE DATOS..........................................................................26
4.1. UPDATE.......................................................................................................................................................................26
4.2. INSERT......................................................................................................................................................................27
4.3. DELETE.......................................................................................................................................................................29
5. CURSORES. TRABAJO CON MS DE UNA FILA...................................................31
5.1.DECLARE......................................................................................................................................................................32
5.2.OPEN............................................................................................................................................................................33
5.3.FETCH..........................................................................................................................................................................34
5.4.CLOSE..........................................................................................................................................................................36
5.5. MODIFICACIONES BASADAS EN CURSOR.................................................................................................36
5.5.1. DELETE...............................................................................................................................................................37
5.5.2. UPDATE..............................................................................................................................................................37
6. CONTROL DE TRANSACCIONES.....................................................................39
6.1. COMMIT.....................................................................................................................................................................39
6.2. ROLLBACK.................................................................................................................................................................39
7. LENGUAJE DE DEFINICION DE DATOS (DDL).....................................................41
7.1. CREACIN DE TABLAS.........................................................................................................................................41
7.2. MODIFICACIN DE TABLAS.............................................................................................................................41
7.3. CREACIN DE SINNIMOS..............................................................................................................................42
7.4. CREACIN DE INDICES......................................................................................................................................42
7.5. CREACIN DE VISTAS........................................................................................................................................43
 7.5.1. ACTUALIZACIONES EN VISTAS Y EL ESTNDAR ANSI/ISO....................................................45
7.6. CREACIN DE AGRUPAMIENTOS O CLUSTERS.........................................................................................46
7.7. SUPRESIN DE OBJETOS..................................................................................................................................46
8. AUTORIZACIONES....................................................................................48
8.1. SENTENCIA GRANT..............................................................................................................................................48
8.2. SENTENCIA REVOKE............................................................................................................................................49
9. OPERADORES RELACIONALES.......................................................................50
9.1. UNION........................................................................................................................................................................50
9.2. INTERSECCION......................................................................................................................................................52
9.3. DIFERENCIA............................................................................................................................................................52
10. SENTENCIA INITIALIZE SOBRE TABLAS........................................................53
11. CONCEPTOS VARIOS................................................................................54
1. INTRODUCCIN

Una base de datos es un conjunto de informacin organizada e

interrelacionada de una forma especfica, sin redundancia de los datos y que
facilitan el acceso a la informacin por mltiples caminos basndose en la
interrelacin de los datos.

Representa la visin externa de los datos que tiene el usuario, sin tener en
cuenta la organizacin interna de los datos ni los dispositivos utilizados para su
almacenamiento.

El DB2 est basado en un modelo relacional representado en tablas que

contienen un nmero determinado de columnas. En este modelo el usuario ve los
datos como un conjunto de tablas relacionadas entre s a travs de algn campo
comn.

Es un sistema de gestin de base de datos compuesto por programas,

procedimientos y lenguajes que otorga las facilidades necesarias para las
funciones de creacin, recuperacin y actualizacin de la informacin contenida
en la base de datos.

El SQL (Structured Query Language) es el lenguaje en el que se codifican las

instrucciones para DB2. Proporciona sentencias para una gran variedad de
trabajos:

Bsqueda de datos.
Crear, modificar y borrar objetos.
Crear, modificar y borrar los datos en los objetos.
Controlar el acceso a la base de datos y a los objetos.
Garantizar la consistencia de la B.D.
2. SQL EN PROGRAMAS DE APLICACIN

2.1. DB2 EMBEBIDO. REA DE COMUNICACIONES SQLCA

El utilizar dentro de un programa COBOL sentencias de DB2-SQL , implica que

el propio DB2-SQL estar embebido en el programa, por lo que ser necesario
controlar la comunicacin que se establece, entre el programa y el DB2-SQL,
as como los posibles errores que se produzcan a lo largo de la ejecucin del
programa.

Todas las sentencias DB2-SQL pueden producir dos tipos de errores:

Errores en tiempo de compilacin. Cualquier error de tipo sintctico en

las rdenes DB2-SQL producir el consiguiente error de precompilacin,
el cual ser comunicado al programador, en el momento de la
compilacin del propio programa COBOL, gracias a la comunicacin
establecida entre el COBOL y el DB2.

Errores en tiempo de ejecucin. Pueden ser errores de inconsistencia con

respecto a la base de datos, del tipo de referencias a columnas
inexistentes, falta de permisos de insercin, borrado o
modificacin,...,etc.

La SQLCA es una estructura de datos (realmente es una variable de entorno

DB2-SQL), que contiene variables de error e indicadores de estado,
conteniendo, entre otros, la variable SQLCODE. Al ejecutarse una sentencia
de DB2-SQL embebido, el SQLCODE contendr un cdigo numrico, que
establecer si la operacin DB2-SQL ltimamente ejecutada, lo ha sido
satisfactoriamente o no. La SQLCA tomar el valor del SQLCODE para indicar
al programa de la aplicacin, el resultado de la finalizacin de la sentencia DB2-
SQL.:

SQLCODE igual a 0 indica que la operacin ha concluido

satisfactoriamente.

SQLCODE igual a un valor negativo indica que, al ejecutarse la operacin,

se ha producido un error.
 SQLCODE igual a una valor superior a 0 indica que, al ejecutarse la
operacin, se ha producido un aviso, que no es error. Durante la ejecucin
del programa de la aplicacin, cada nuevo aviso producir un valor DB2-
SQL CODE diferente.

Como la SQLCA constituye, en realidad, una variable de entorno DB2-SQL, ha

de ser incluida, en la WORKING-STORAGE SECTION del programa de
aplicacin COBOL. Por otro lado, en dicho programa, inmediatamente despus
de formular una sentencia DB2-SQL, hemos de controlar el valor devuelto por
el SQLCODE, con el fin de evaluarle, para, en funcin del posible error,
ejecutar el proceso correspondiente.

2.2. DECLARACIONES EN WORKING-STORAGE SECTION.

Al codificar SQL en un programa hay que desarrollar varias actividades:

- Delimitar las sentencias SQL.

- Declarar un rea de comunicacin con el DB2.

- Declarar las tablas que se usen.

- Declarar las unidades de datos usados para pasar datos entre DB2 y
COBOL.

- Codificar sentencias SQL para recuperar, actualizar, insertar o borrar

datos en DB2.

- Manejar condiciones excepcionales, indicadas con cdigos de retorno desde

DB2.

2.2.1. DEFINICIONES DE CAMPOS DE TRABAJO

La finalidad principal de la SQLCA es la de informar, a lo largo del

funcionamiento del programa de todo posible error producido como resultado
de la ejecucin de una sentencia DB2-SQL, y recibe valor desde el SQLCODE.
Por ello, si se desean conservar ambos valores, previo a la ejecucin de la
siguiente instruccin DB2-SQL, se habrn de definir en WORKING dos campos
de tipo y longitud compatibles, respectivamente con uno u otro. Para la variable
SQLCODE sera del tipo S9(03), y, para la SQLCA X(136).

Ejemplo:

WS-SQLCA PIC X(136).

WS-SQLCODE PIC S9(03).

Tambin convendra definir los literales de error, correspondientes a cada uno

de los errores que se deseara controlar.

2.2.2. FORMATO DE SENTENCIAS DB2-SQL EMBEBIDO

Las sentencias SQL debern codificarse a partir de la columna 12 del

programa y deben ir delimitadas por una sentencia EXEC. Su formato es el
siguiente:
EXEC SQL
<instruccin DB2-SQL >
END-EXEC

Estos delimitadores indican al precompilador cundo empieza una sentencia y

cundo acaba.

2.2.3. SENTENCIA INCLUDE

La finalidad principal de esta sentencia es la inclusin de cualquier estructura

de entorno DB2-SQL en el programa de la aplicacin, sea una variable, una
tabla, etc.
Todas las instrucciones INCLUDE, sern formuladas en la WORKING. Se
incluirn al final de ella, despus de toda declaracin y definicin de variables
y campos de trabajo, aunque esto ltimo, no sea obligatorio.

Formato:
EXEC SQL
INCLUDE <estructura-sql>
END-EXEC
donde estructura-sql ser el identificador de la estructura DB2-SQL,
generalmente una tabla, que ser incluida para obtener su imagen de definicin.
Nunca podr exceder de los ocho caracteres.

El INCLUDE referente al SQLCA sera como sigue:

EXEC SQL
INCLUDE SQLCA
END-EXEC

2.2.3.1. DECLARACIN DE TABLAS

Para declarar una tabla en un programa se puede hacer de 2 formas:

- Usando la sentencia DECLARE TABLE.

- Usando DCLGEN para generar e incluir la declaracin de la tabla. Esto se

hace con la sentencia INCLUDE.

El DCLGEN de una tabla crea un miembro en una librera de includes, en el que

tendremos por una parte, la declaracin de la tabla en forma de una sentencia
SQL y adems, las columnas de la tabla modificadas de tal forma que puedan
ser utilizadas en el programa como variables COBOL.

Al ejecutarse el INCLUDE se crea de forma automtica, una imagen en COBOL

de la estructura DB2-SQL correspondiente, con lo que se crear en
WORKING, durante la compilacin del programa, un registro de trabajo con
definicin compatible con el tipo de dicha estructura., siendo empleado como
campo de trabajo en cualquier operacin a realizar a lo largo de la ejecucin
del programa.

Ejemplo: Tabla PICTA_INTERV

EXEC SQL
INCLUDE PICTA_IN
END-EXEC
Como tal tabla tiene la estructura:

PICI_COD9-EXPEDI CHAR(9)
PICI_PERSONA CHAR(8)
PICI_EMPRESA CHAR(4)
PICI_CENTRO CHAR(4)
PICI_TIPOCTA CHAR(2)
PICI_NUMECTA CHAR(7)

el registro working que se crear ser el siguiente:

01 PICTA-INTERV.
10 PICI-COD9-EXPEDI PIC X(9).
10 PICI-PERSONA PIC X(8).
10 PICI-EMPRESA PIC X(4).
10 PICI-CENTRO PIC X(4).
10 PICI-TIPOCTA PIC X(2).
10 PICI-NUMECTA PIC X(7).

Cada campo de la tabla tiene idntico nombre que el correspondiente en el

registro working, pero con la diferencia de que los guiones en los atributos de
la tabla, son guiones bajos, como, por ejemplo PICI_NUMECTA, mientras que
los del registro working sern guiones altos, como, por ejemplo PICI-
NUMECTA. Es muy importante no confundir un atributo de la tabla con su
correspondiente campo WORKING.

2.2.4. VARIABLES HOST

Una variable HOST es una unidad declarada en el lenguaje de programacin que

soporta el DB2. Generalmente deber estar precedida con : dentro de la
sentencia SQL.

Los datos recuperados por el DB2 son almacenados en las variables HOST para
usarlos en el programa. A su vez, los datos que van insertados o modificados
tambin estn referenciados en las variables.

Ejemplo: EXEC SQL

SELECT col1, col2, ...
INTO :var1, :var2, ...
FROM nombre-tabla
WHERE condicin
END-EXEC
La clasula WHERE usa una variable HOST que debe ser compatible con el tipo
de dato que contiene la columna implicada en la comparacin.

La clasula INTO nombra las variables HOST del programa usadas para
recuperar los valores de las columnas seleccionadas por la sentencia SELECT.
3. RECUPERACIN DE DATOS

Mediante la sentencia SELECT se realizan consultas a la base de datos.

Formato:

SELECT [ALL|DISTINCT][{lista-de-items-de-seleccin|*}]
[INTO lista-de-variables]
FROM lista-de-tablas
[WHERE condicin-de-bsqueda ]
[GROUP BY columna-de-agrupacin ]
[HAVING condicin-de-bsqueda ]
[ORDER BY especificacin-de-ordenacin,..., ]

El resultado de la consulta ser devuelto en forma de columnas. En realidad,

constituye una tabla de datos, de igual estructura que la tabla de datos
efectiva.

3.1. CLASULA SELECT

- Lista-de-items-de-seleccin: establece la lista de atributos, campos o

datos a recuperar en la consulta. Tambin podrn ser columnas a calcular.
Las columnas aparecen en el orden especificado en la SELECT y no en el
orden en que estn en la tabla.

SELECT DIVI_DIVISA, DIVI_IMPORTE

FROM DIEXTR.DIVISAS

- * : si en lugar de lista-de-items-de-seleccin, especificamos el carcter *,

se seleccionarn todos los campos de los que se compongan la tabla o tablas
especificadas. No obstante, en ningn caso, se emplear *, ya que puede
provocar errores posteriores al aadir columnas a la tabla accedida, si no
que se especificarn los items de seleccin estrictamente necesarios.

SELECT *
FROM DIEXTR.DIVISAS
- ALL: si se utiliza ALL no se puede utilizar la clusula WHERE, ya que con
aquella, se seleccionan todos los registros, tuplas o filas de la tabla
especificada. Si no indicamos ninguna condicin WHERE no ser necesario el
incluir ALL, ya que, por defecto de condicin en la seleccin, se asume el
rango total de registros de la tabla.

As, por ejemplo, la sentencia:

SELECT ALL DIVI_DIVISA

FROM DIEXTR.DIVISAS

producira el mismo resultado que:

SELECT DIVI_DIVISA
FROM DIEXTR.DIVISAS

- DISTINCT: asegura que las filas que se recuperen no contengan

duplicados.

SELECT DISTINCT nombre-columna

FROM nombre-tabla

3.2. CLASULA INTO

La clusula opcional INTO nicamente se utiliza en DB2-SQL embebido.

- Lista-de-variables se refiere a las variables que recibirn cada una de las

columnas resultado de la consulta, por lo que se habr de tomar especiales
precauciones al definirlas, en cuanto a su tipo y longitud. En la mayora de
los casos, se emplearn los campos imagen en COBOL de la tabla; y aqu se
tendr especial cuidado en que la colocacin de stos se corresponda en
orden fsico con los respectivos en la tabla.

SELECT DIVI_DIVISA, DIVI_IMPORTE

INTO :DIVI-DIVISA, :DIVI-IMPORTE
FROM DIEXTR.DIVISAS
3.3. CLASULA FROM

En lista-de-tablas se especificarn cada una de las tablas sobre las que se

realizar la consulta. Cada una de ellas habr de estar declarada mediante la
sentencia INCLUDE.

3.4. CLASULA WHERE

La clusula WHERE se emplea para especificar la condicin de recuperacin de

las filas que se deseen recuperar. Como hemos visto, el formato de esta
clusula es:

WHERE condicin-de-bsqueda

donde:

condicin-de-bsqueda: tem-de-bsqueda | tem-de-bsqueda { AND | OR }

tem-de-bsqueda

tem-de-bsqueda: [ NOT ] { test-de-bsqueda |(condicin-de-bsqueda ) }

test-de-bsqueda: test-de-comparacin | test-entre | test-como | test-nulo |test-

conjunto | test-cuantificado |test-existencia

test-de-comparacin: expresin { | <> | < | <= | > | >= } { expresin

|subconsulta }

test-entre: expresin [ NOT ] BETWEEN expresin AND expresin

test-como: columna [ NOT ] LIKE valor [ ESCAPE ] valor

test-nulo: columna IS [ NOT ] NULL

test-conjunto: expresin [ NOT ] IN { lista-de-valores | subconsulta }

test-cuantificado: expresin { = | <> | < | <= | > | >= } [ ALL | ANY | SOME|
SOME ] subconsulta

test-existencia: EXISTS subconsulta

subconsulta: cualquier sentencia SELECT

Hay distintos tipos de condicin-de-bsqueda:

Test de comparacin: compara el valor de una expresin con el de otra.

SELECT OFICINA
FROM REPVENTAS
WHERE REGION = ESTE
OR REGION = Este

Test de rango: examina si el valor de una expresin se encuentra

comprendido dentro de un rango de valores.

Una seleccin del tipo

SELECT OFCINA
FROM REPVENTAS
WHERE INGRESOS >= 1000000
AND INGRESOS <= 1900000

se podra construir como:

SELECT OFICINA
FROM REPVENTAS
WHERE INGRESOS BETWEEN 1000000 AND 1900000

Test de pertenencia a un conjunto: Comprueba si el valor de una expresin

se encuentra dentro de un conjunto de valores.
Una seleccin del tipo:

SELECT OFICINA
FROM REPVENTAS
WHERE REGION = ESTE
OR REGION = Este
OR REGION = este

se podra construir como:

SELECT OFICINA
FROM REPVENTAS
WHERE REGION IN (ESTE,Este,este)
 Test de correspondencia patrn: Se comprueba si el valor de una columna
que contiene datos de una cadena de caracteres se corresponde con el
patrn especificado.

% se utiliza para indicar cualquier conjunto de caracteres o ninguno.

_ se utiliza para indicar un solo carcter.

Como ejemplo, se seleccionarn aquellos clientes cuyos nombres comiencen

por la letra E:

SELECT NOMBRE
FROM CLIENTES
WHERE NOMBRE LIKE E%

Test de valor nulo: Comprueba si una columna tiene un valor NULL

(desconocido). Se puede aplicar tanto sobre campos alfanumricos como
numricos:

SELECT OFICINA
FROM REPVENTAS
WHERE COMISION IS NULL

Otro ejemplo:
SELECT NOMBRE
FROM VENDEDOR
WHERE OFICINA IS NULL

Nota: Si al crear la estructura de la tabla, un campo es declarado como NOT

NULL, en ningn caso podr recibir valor nulo.

El operador de negacin NOT no se emplear ya que DB2-SQL transforma

primero la negacin en su opuesta, lo que supondra un gasto adicional.

As mismo, se usar siempre la misma longitud de datos para la columna y la

constante o variable con la que se compare aquella.

Nota: La sentencia SELECT, en cualquiera de los formatos que se van a ver, si

estamos trabajando con DB2-SQL embebido, slo podr ser utilizada cuando
se obtenga una nica fila como resultado de la consulta, ya que, de no ser as,
se devolvera el error de ejecucin 811: en una sentencia SELECT o en una
subconsulta, se ha obtenido ms de una fila.

Si, por el contrario, al ejecutarse una sentencia SELECT de consulta o

subconsulta, no se ha obtenido ninguna fila, se producira el error de ejecucin
+100: no se ha encontrado ninguna fila que cumpla el criterio de bsqueda o la
tabla consultada est vaca.

3.4.1. CLAVES E NDICES

Un ndice es una herramienta para ayudar al DB2 a encontrar filas a travs de

valores especificados en la clasula WHERE. Permite el acceso directo a las
filas de la tabla reduciendo el tiempo de acceso.

Clases de claves

Clave primaria: clave definida para la tabla como principal, identifica

nicamente una fila de sta, por lo tanto, a cada clave nica le corresponde
una fila de la tabla y viceversa.

Generalmente ser nica aunque no es obligatorio.

Clave secundaria: definida para la tabla como posible acceso, no siendo la

clave principal. Sirve para relacionarla con otras tablas.

Indice Cluster: indica el almacenamiento fsico ordenado por el ndice. Se

utiliza para almacenar los datos ordenados por el camino ms
frecuentemente utilizado. Slo se puede crear un ndice cluster para cada
tabla.

Se pueden crear varios ndices sobre la misma tabla, stos se establecen, por
defecto, de forma ascendente.

La utilizacin de los ndices se realiza cuando:

- se accede a las columnas ndice de las tablas

- se realiza una seleccin de datos sobre las columnas especificadas como
ndice.

Por lo tanto, el ndice ralentizar las inserciones, borrados y modificaciones

sobre las columnas ndice, ya que stas deben ser tambin modificadas.

3.5. CLASULA ORDER BY. CONSULTAS ORDENADAS

Cuando estemos seguros de que como resultado de nuestra operacin de

consulta se vaya a obtener ms de una fila, y necesitemos que dicho resultado
aparezca en pantalla segn un criterio de ordenacin, incluiremos la clusula
ORDER BY siempre en la ltima posicin:

ORDER BY especificacin-de-ordenacin,...,

especificacin-de-ordenacin: se especificarn los campos de la tabla o

tablas referenciadas en la clusula FROM, segn los que se realizar la
ordenacin. Obligatoriamente, para que un campo o atributo pueda ser
especificado en la clusula ORDER BY , deber ser uno de los seleccionados, ya
que, de no ser as, se producira error. Unicamente se podrn indicar en la
clusula ORDER BY campos o atributos pertenecientes a la tabla o tablas
consultadas.

Ejemplo:

SELECT DIVI_DIVISA,DIVI_DESCRIP,DIVI_CAMBDIV_ALTO
FROM DIEXTR.DIVISAS
ORDER BY DIVI_DIVISA,DIVI_DESCRIP

Los datos se recuperan en orden ascendente, para recuperarlos en orden

descendente

ORDER BY nombre-columna DESC

3.6. CLASULA GROUP BY / HAVING. CONSULTAS
AGRUPADAS

Las consultas, tal y como las hemos visto hasta ahora, condensan todos los
datos detallados del informe en una nica fila resumen de datos. Pero en
ocasiones es necesario resumir los resultados de la consulta a un nivel
subtotal por grupos, operacin que se realiza incluyendo en la sentencia
SELECT la clusula GROUP BY.

- Ejemplo 1.: Obtencin del importe medio de pedido

SELECT AVG(IMPORTE)
FROM PEDIDOS

AVG(IMPORTE)
$8,256.37

- Ejemplo 2.: Obtencin del importe medio de pedido para cada vendedor

SELECT REP, AVG(IMPORTE)

FROM PEDIDOS
GROUP BY REP

REP AVG(IMPORTE)
101 $8,876.00
102 $5,694.00
103 $1,350.00
104 $7,685.40
105 $16,479.00
106 $11,477.33
107 $3,552.50
108 $11,566.00

En el primer ejemplo, se trata de una consulta simple como las vistas hasta
ahora.
En el segundo ejemplo, la consulta se realiza del modo siguiente:

1 DB2-SQL divide los pedidos en grupos de pedidos, un grupo por cada

vendedor. A cada pedido del mismo grupo le corresponder el mismo valor en la
columna REP.

2 DB2-SQL calcula, para cada grupo, el valor medio de la columna

IMPORTE, operacin que se realiza por medio de la funcin AVG( ), con lo que
se genera una nica fila resumen de resultados. Cada fila contendr el valor de
la columna REP del grupo y el pedido medio calculado.

Una consulta de este tipo, recibe el nombre de consulta agrupada.

Otro ejemplo:

Cuntos clientes diferentes son atendidos por cada vendedor?

SELECT COUNT (DISTINCT NUM_CLIE), clientes por rep. de ventas,

REP_CLIE
FROM CLIENTES
GROUP BY REP_CLIE

COUNT(DISTINCT NUM_CLIE) CLIENTES POR REP. DE VENTAS REP_CLIE

3 clientes por rep. de ventas 101
4 clientes por rep. de ventas 102
6 clientes por rep. de ventas 103
6 clientes por rep. de ventas 104
7 clientes por rep. de ventas 105
7 clientes por rep. de ventas 106

Al igual que la clusula WHERE se utiliza para establecer la condicin de

seleccin de filas individuales, la clusula HAVING se utiliza para establecer la
condicin de seleccin de grupos de filas. El formato de esta clusula es el
mismo que el de WHERE.
Ejemplo:

Importe medio de cada vendedor cuyos importes de pedidos superen

30.000 ptas

SELECT REP, AVG(IMPORTE)

FROM PEDIDOS
GROUP BY REP
HAVING SUM(IMPORTE) > 30000

La clusula HAVING puede utilizarse sin la GROUP BY, funcionando

correctamente, aunque no es corriente hacerlo. En este caso, la nica fila
producida por la consulta sera considerada como un grupo, por lo que no habra
problema alguno.

3.7. SUBCONSULTAS

Una subconsulta es una sentencia SELECT dentro de otra., que se emplear

como miembro de la condicin de la sentencia SELECT principal.

Cuando se trata de consultas complejas, las subconsultas resultan tiles, ya que

permiten descomponer una consulta en partes: consulta principal y
subconsultas.

Toda subconsulta aparecer dentro de una clusula WHERE o HAVING segn

sea el caso, siendo ms normal el primero, aunque en uno u otro funcione de
forma semejante.

3.7.1.SUBCONSULTAS EN LA CLASULA WHERE

Cuando aparece una subconsulta en la clusula WHERE, el valor que devuelva,

funciona como condicin de seleccin de la consulta principal.
Hay cuatro tipos-de-condicin-de-bsqueda en la subconsultas:

Test de comparacin subconsulta: Compara el valor de una expresin, que

tendr que ver con la consulta principal o del nivel superior, con el valor
 nico devuelto por la subconsulta. Este test se asemeja al test de
comparacin simple, ya visto:

SELECT CIUDAD
FROM OFICINAS
WHERE OBJETIVO > (SELECT SUM(CUOTA)
FROM REPVENTAS
WHERE OFICINA_REP = OFICINA)

En este caso, la subconsulta devolver una sola fila.

Test de pertenencia a un conjunto subconsulta : Comprueba si el valor de

una expresin coincide con uno del conjunto de valores devuelto por la
subconsulta. Es semejante al test de pertenencia a un conjunto simple:

SELECT NOMBRE
FROM REPVENTAS
WHERE OFICINA_REP IN (SELECT OFICINA
FROM OFICINAS
WHERE VENTAS > OBJETIVO)

Test de existencia: Comprueba si una subconsulta produce alguna fila de

resultados. Aqu se emplea el operador EXISTS:

SELECT DISTINCT DESCRIPCION

FROM PRODUCTOS
WHERE EXISTS (SELECT NUM_PEDIDO
FROM PEDIDOS
WHERE PRODUCTO = ID_PRODUCTO
AND FAB = ID_FAB
AND IMPORTE >= 25000.00)

Test de comparacin cuantificada : Compara el valor de una expresin con

cada uno del conjunto de valores producida por la subconsulta. Aqu se
emplean los operadores ANY y ALL.

La subconsulta del test ANY comprueba si un dato es igual que algn

valor de la columna devuelta en la subconsulta; mientras que la del test
 ALL comprobar si el dato es igual a todos los valores de la subconsulta.
Los dos test ANY y ALL permiten realizar tal tipo de comprobacin con
cualquiera de los operadores de comparacin.

Utilizando el operador ANY la subconsulta ser cierta cuando alguna de

las comparaciones individuales devuelva un resultado TRUE.

Utilizando el operador ALL la subconsulta ser cierta cuando todas las

comparaciones individuales devuelvan un resultado TRUE.

Ejemplos:

Seleccionar alguna oficina en la que el empleado sea director

SELECT NOMBRE, EDAD

FROM REPVENTAS
WHERE (NUM_EMPL = ANY (SELECT DIR
FROM OFICINAS)

Seleccionar las oficinas y sus objetivos en donde todos los

vendedores tengan ventas que superen el 50% del objetivo de la
oficina

SELECT CIUDAD, OBJETIVO

FROM OFICINAS
WHERE (.50 * OBJETIVO) < ALL (SELECT VENTAS
FROM OFICINAS)
WHERE OFICINA_REP = OFICINA)

3.8. FUNCIONES DE COLUMNA

Estas funciones se aplican a grupos de valores y el resultado es una nica fila,

por lo que todas las columnas seleccionadas debern tener una de estas
funciones, excepto si se usa la clasula GROUP BY.

3.8.1. SUM( )
Totaliza una columna. Esta columna habr de ser de tipo numrico (entero,
decimal, coma flotante o monetario), siendo del mismo tipo el resultado
obtenido.

Ejemplo:

SELECT SUM(CUOTA),
SUM(VENTAS)
FROM REPVENTAS

3.8.2. AVG( )

Calcula el promedio o media aritmtica de la columna. Esta columna habr de

ser de tipo numrico (entero, decimal, coma flotante o monetario), siendo del
mismo tipo el resultado obtenido.

Ejemplo:

SELECT AVG(PRECIO)
FROM PRODUCTOS
WHERE ID_FAB = ACI

3.8.3. MIN( ) Y MAX( )

Devuelven, respectivamente, los valores menor y mayor de la columna. Los

datos de la columna podrn ser de tipo numrico, de cadena o de fecha/hora.

Ejemplo:

SELECT MIN(CUOTA),
MAX(CUOTA),
MIN(FECHA_PEDIDO)
FROM PEDIDOS

3.8.4. COUNT( ) Y COUNT(*)

La primera funcin cuenta el nmero de valores que aparecen en la columna,

mientras que la segunda cuenta el nmero de filas o registros.
Ejemplo:

SELECT COUNT(NUM_PEDIDO)
FROM PEDIDOS
WHERE IMPORTE > 10000.00

SELECT COUNT(*)
FROM PEDIDOS
WHERE IMPORTE > 10000.00

3.9. OPERACIONES ARITMTICAS

En una operacin aritmtica se pueden especificar nombres de columna y

valores constantes.

Se pueden usar expresiones aritmticas:

1. En operaciones: en una clasula WHERE

SELECT nombre-columna1, nombre-columna2

FROM nombre-tabla
WHERE nombre-columna3 /12 < 75000

2. Para ordenar: por una columna que contenga el valor resultante de una
expresin, indicando su nmero de columna.

SELECT nombre-columna1,(nombre-columna3 5)/6

FROM nombre-tabla
ORDER BY 3

3.10. RECUPERACIN DE DATOS DESDE 2 O MS TABLAS:

JOIN
Un JOIN es una operacin relacional que permite realizar operaciones con
varias tablas. Es la forma de combinar filas de una o ms tablas.

Cuando se hace referencia a las columnas de las tablas, es recomendable,

utilizar el nombre de la tabla seguido del nombre de la columna, para evitar
confusiones. En el caso de que existan dos nombres de columnas iguales, ser
obligatorio indicar el nombre de la tabla en cada caso, con el formato:

NOMBRE-DE-TABLA.CAMPO

En este caso, de no hacerlo as, se producira error en tiempo de ejecucin por

ambigedad en los campos seleccionados.

Hay que nombrar las 2 tablas en la clasula FROM. Se pueden especificar

nombres de columnas de ambas tablas en la SELECT.

En la clasula WHERE hay que nombrar las 2 columnas cuyos valores debern
ser iguales para identificar un par de filas (una de cada tabla) desde los cuales
se seleccionarn los datos.
4. MODIFICACIN DE DATOS

4.1. UPDATE

Esta sentencia permite la modificacin del contenido de los campos de la tabla

de la base de datos especificada.

No encontrando ningn registro de la condicin especificada para la

modificacin, se producira el error de ejecucin +100: no se ha encontrado
ninguna fila que cumpla el criterio de bsqueda o la tabla consultada est
vaca..

La sentencia UPDATE slo puede operar sobre una tabla.

El formato de la sentencia es el siguiente:

UPDATE nombre-tabla SET lista-de-asignaciones [ WHERE

condicin-de-bsqueda ]

Donde:

nombre-tabla: se refiere al nombre de la tabla en la que se modificarn los

registros.

lista-de-asignaciones: se refiere a la asignacin del nuevo valor (dato,

expresin o subconsulta devolviendo una nica fila y una nica columna) al
campo. Lgicamente se podrn modificar varios campos de la tabla. Tendr el
formato:

nombre-de-campo = { valor | expresin }

condicin-de-bsqueda: establece los registros que habrn de ser

modificados. Esta clusula tiene las mismas variantes de utilizacin que en la
sentencia SELECT. Por omisin de condicin, se asumen todos los registros.
Ejemplos:

UPDATE OFICINAS
SET CUOTA = 4000000.00, VENTAS = CUOTA
WHERE CUOTA < 4000000.00

UPDATE CLIENTES
SET REP_CLIE = 105
WHERE REP-CLIE IN (SELECT NUM_EMPL
FROM REPVENTAS
WHERE VENTAS < (0.8 * CUOTA)

4.2. INSERT

La sentencia INSERT permite la insercin de registros en las tablas de la base

de datos.

Formato es:

INSERT INTO nombre-de-tabla [(nombre-de-columna,...,)]

{VALUES { constante | NULL } | sentencia SELECT },...,

Donde:

nombre-de-tabla se refiere al nombre de la tabla en la que se insertarn los

nuevos registros. En la misma sentencia nicamente se podrn insertar
registros en una tabla.

nombre-de-columna se refiere al nombre de cada uno de los campos que

contendrn los datos a insertar en la tabla. Irn separados por comas. Deber
haber concordancia de tipo y longitud entre la columna y su contenido.

A continuacin de la clusula VALUES se especificar el contenido para los

campos del registro. Los valores a emplear pueden ser constantes, valores
nulos cuando sea oportuno, o una sentencia SELECT en cualquiera de sus
formatos, siempre y cuando devuelva datos compatibles para los campos
especificados. Pero no se podr asignar valor nulo cuando, al crearse la tabla, el
campo que recibira dicho valor, es declarado como NOT NULL.

Ejemplo:

INSERT INTO
REPVENTAS (NOMBRE, EDAD, NUM_EMPLE, VENTAS)
VALUES (FERNANDEZ PEREZ ANTONIO, 54, A125, 500000.00)

Si alguno de los campos del registro no aparece en la lista de ellos (y,

lgicamente, tampoco, su contenido), al ejecutarse la sentencia, directamente
se le asigna el valor NULL. Para este caso, otra posibilidad, sera el especificar
dicho campo, y, en la lista de valores, asignarle el valor NULL. Pero referente a
esto, tengamos en cuenta lo dicho en el prrafo anterior.

Otra posibilidad, es la de omitir la lista completa de columnas. Haciendo esto,

DB2-SQL generar automticamente una lista formada por todas las columnas
de la tabla, en secuencia, y de izquierda a derecha; y, en esa misma secuencia,
se asignarn los valores especificados en la clusula VALUES. Si no se
especifican valores para todos los campos, no habr problema, siempre y
cuando a los campos intermedios se les asigne valor NULL. Una vez hayamos
dado contenido al ltimo campo que deseemos, no sera necesario el tener en
cuenta los campos que le siguieran para asignarles valor NULL, puesto que DB2-
SQL lo hara de forma automtica.

Ejemplo:

INSERT INTO REPVENTAS

VALUES (111, FERNANDEZ MARTINEZ ANTONIO, NULL, NULL, Dir
ventas)

Slo se desea asignar informacin a los campos primero, segundo y quinto del
registro, no as a los siguientes, por lo que no es preciso especificarlos. Sin
embargo, al tercero y cuarto campo no vamos a asignarles informacin, porque
de momento, es desconocida, por ello, se les asigna valor NULL.

Los tipos de inserciones vistos, se refieren a insertar una sola fila, pero
tambin hay posibilidad de realizar lo que se conoce como inserciones multifila,
en las que los registros a insertar se obtienen a partir de una consulta o
SELECT.

Formato:

INSERT INTO nombre-de-tabla [(nombre-de-columna,...,)]

Sentencia SELECT

Ejemplo:

INSERT INTO ANTPEDIDOS (NUM_PEDIDO, FECHA_PEDIDO, IMPORTE)

SELECT NUM_PEDIDO, FECHA_PEDIDO, IMPORTE
FROM PEDIDOS
WHERE FECHA_PEDIDO < 01-ENE-90

Cuando, como resultado de la ejecucin de una sentencia INSERT no se ha

insertado ninguna fila o registro, se producir el error de ejecucin +100: no
se ha insertado ninguna fila en la tabla.

4.3. DELETE

Esta sentencia permite eliminar uno o ms registros de la tabla especificada.

El formato de la sentencia es:

DELETE FROM nombre-de-tabla [ WHERE condicin-de-bsqueda ]

Donde

nombre-de-tabla es el nombre de la tabla de la cual se van a eliminar o borrar

los registros. Solamente se podr aplicar la sentencia sobre una tabla.

condicin-de-bsqueda establece la condicin que han de cumplir los registros

para ser borrados, pudiendo tener los mismos formatos que en las dems
sentencias que la utilizan. Si no se incluye esta clusula, se borrarn la
totalidad de los registros de la tabla especificada.
Ejemplos:

- Borrado de todos los registros de la tabla PEDIDOS

DELETE FROM PEDIDOS

- Borrado de todos los pedidos remitidos antes del 15 de noviembre de

1989

DELETE FROM PEDIDOS

WHERE FECHA_PEDIDO < 15-NOV-89

Si como resultado de la sentencia DELETE, no se ha podido eliminar ningn

registro, se producira el error de ejecucin +100: no se ha encontrado
ninguna fila que cumpla el criterio de borrado o la tabla consultada est vaca..
5. CURSORES. TRABAJO CON MS DE UNA FILA

El tipo de consultas visto anteriormente, slo puede ser empleado cuando

nicamente vayamos a obtener como resultado una nica fila. Cuando se van a
recuperar ms de una fila se debe usar un cursor.

Un cursor es la utilidad que facilita la opcin de poder leer fila por fila aquellas
que se seleccionaron en la sentencia SELECT. Se basa en las cuatro sentencias
siguientes:

DECLARE CURSOR, que especifica la consulta a efectuar, a la vez que la

asocia un nombre, que ser el del propio cursor.

OPEN, que hace que comience a realizarse la consulta y a generar filas.

Sita el puntero del cursor, delante del primer registro o fila.

FETCH, que realiza la captura o lectura del registro del cursor al que
apunta el puntero del mismo, obteniendo la informacin de cada campo o
atributo. A continuacin, el puntero se colocar sobre el siguiente
registro, para que, en una posterior ejecucin de la sentencia FETCH se
recupere.

CLOSE, que finaliza tanto el acceso a los resultados de la consulta como

la asociacin entre el cursor y los resultados o datos.

Un cursor funciona como si se tratase de un fichero, de la misma forma que,

previamente a la lectura de los registros de un archivo, se ha de proceder a su
apertura, el cursor se habr de abrir, igualmente, para poder acceder a los
resultados de la consulta. De forma anloga, un archivo se cierra para terminar
el acceso al mismo, y tambin se cierra el cursor para finalizar el acceso a los
resultados de la consulta. Tal y como hemos visto, un cursor lleva cuenta de la
posicin en cada momento dentro de los resultados de la consulta, al igual que
un nombre o indicador de archivo le lleva dentro del mismo referente a sus
registros.

No obstante, los cursores presentan los inconvenientes de que implican mucha

ms sobrecarga, en su apertura, que la de un archivo, y de que slo soportan
procesamiento secuencial hacia delante de los resultados de la consulta. La
mayora de las implementaciones en DB2-SQL no soportan el acceso aleatorio o
directo que s permiten los archivos.

5.1.DECLARE

Mediante esta sentencia se define la consulta a efectuar, asociando un nombre

de cursor a dicha consulta. Tal nombre habr de ser un identificador vlido
para DB2-SQL, se utiliza para identificar la consulta y sus resultados en otras
sentencias de DB2-SQL embebido.

El nombre del cursor no constituye una variable del lenguaje que establece el
interface con DB2-SQL, ya que se declara en la propia sentencia DECLARE.

El formato de la sentencia es el siguiente:

DECLARE nombre-de-cursor CURSOR FOR sentencia-de-seleccin

[ FOR UPDATE OF lista-de-campos ]

Donde:

nombre-de-cursor ser el nombre asignado al propio cursor.

sentencia-de-seleccin podr ser una sentencia de seleccin en cualquiera de

los formatos vistos anteriormente. Establecer la consulta asociada al cursor.
Una sentencia de DB2-SQL embebido podr utilizar cualquiera de las
capacidades de consultas que estn disponibles en DB2-SQL interactivo, del
tipo de GROUP BY, ORDER BY, HAVING,...,etc.

No obstante, no se podr utilizar la clusula ORDER BY cuando se incluya la

opcin
FOR UPDATE OF lista-de-campos

ya que la posicin de los registros, una vez ordenados, no se correspondera con

su posicin fsica real en la tabla.
La opcin FOR UPDATE OF se habr de incluir cuando se desee modificar
cualquiera de los campos seleccionados en la declaracin del cursor, a lo largo
del proceso mismo, ya que, de no hacerlo as, no se podr aplicar una sentencia
UPDATE. Todos y cada uno de los campos especificados en esta opcin, habrn
de estarlo igualmente en la sentencia-de-seleccin.

La tabla sobre la que se aplique esta sentencia, previamente deber haber sido
incluida, mediante la sentencia INCLUDE de la forma que ya hemos visto,
porque, de no hacerlo as, se producira error de precompilacin.

Ejemplos:

EXEC SQL
DECLARE DIVISAS FOR
SELECT DIVI_DIVISA,
DIVI_DESCRIP,
DIVI_CAMBDIV_PARID
WHERE DIVI_FECHA_BOLDIA = 01-02-1999
END-EXEC.

EXEC SQL
DECLARE DIVISAS FOR
SELECT DIVI_DIVISA,
DIVI_DESCRIP,
DIVI_CAMBDIV_PARID
WHERE DIVI_FECHA_BOLDIA = 01-02-1999
FOR UPDATE OF DIVI_CAMBDIV_PARID
END-EXEC.

5.2.OPEN

La sentencia OPEN abre el cursor especificado en nombre-de-cursor,

procesando la consulta especificada en la declaracin (DECLARE) del cursor.
DB2-SQL efectuar el mismo trabajo que una sentencia SELECT interactiva,
situando el puntero de registros de la tabla obtenida justo antes del primero.

Formato:

OPEN nombre-de-cursor
El cursor debe haber sido previamente declarado (DECLARE ), porque, de no
hacerlo as, se producira el error 504: El cursor referenciado no ha sido
declarado.

Previo a ejecutarse una sentencia de apertura de cursor, dicho cursor habr

de estar cerrado o no haber sido abierto, ya que, de no ser as, se producira el
error 502: El cursor que se desea abrir ya se encuentra abierto.

Desde el momento en que se abre el cursor, las variables HOST que estn
inmersas en la clasula WHERE tomarn el valor que tengan en ese instante.
Esto es, si se necesitase recuperar ms filas para la misma condicin
expresada en la clasula DECLARE CURSOR, pero con valores de variables
HOST diferentes habra que cerrar el cursor, actualizar las variables y volver
a abrir el cursor.

5.3.FETCH

Esta sentencia permite la lectura o captura de los registros de la consulta para

su proceso en el programa de la aplicacin.

El formato de la sentencia es:

FETCH nombre-de-cursor INTO variable-principal,...,

Donde:

nombre-de-cursor se refiere al nombre dado al cursor en la sentencia

DECLARE que previamente se habr ejecutado en secuencia lgica.

variable-principal recoge el nombre de todas las variables que recogern los

campos recuperados en cada operacin de lectura. Deber haber tantas
variables indicadas en la clusula INTO como campos se recuperen, debindose
dar tambin total concordancia de tipo y longitud. No obstante, en la mayora
de los casos, se suelen emplear los campos imagen de COBOL, correspondientes
a la tabla de que se trate, generados al incluirla (INCLUDE).
El cursor, previamente, deber haber sido abierto satisfactoriamente, ya que,
en caso contrario se producira el error 501: El cursor referenciado por la
sentencia FETCH no ha sido previamente abierto.

Ejemplo:

EXEC SQL
FETCH DIVISAS
INTO :DIVI-DIVISA,
:DIVI-DESCRIP,
:DIVI-CAMBDIV-PARID
END-EXEC.

Puede ocurrir que la tabla resultante de la consulta est vaca, debido a que no
se cumplan las condiciones de declaracin del cursor (SELECT....WHERE... .). En
este caso, se obtendra un valor de SQLCODE igual a +100 al ejecutarse el
primer FETCH. Dicho valor se obtendra, igualmente, al alcanzar el final del
cursor durante la lectura. De esta manera podremos fcilmente controlar el fin
del cursor en una estructura de proceso cclica para su tratamiento.

Nota: Hay otras variantes de sentencia FETCH que, aunque se indiquen

seguidamente, no se utilizarn en ningn caso:

FETCH FIRST Recupera el primer registro

FETCH LAST Recupera el ltimo registro
FETCH PRIOR Recupera el registro anterior a la actual
FETCH NEXT Recupera el registro inmediatamente siguiente
al actual. Es la variante que equivale a la
que utilizaremos
FETCH ABSOLUTE n Recupera el registro de posicin n
FETCH RELATIVE { + | - }n Recupera el registro con posicin relativa
respecto de la actual

El formato para estas formas de lectura o recuperacin, sera:

FETCH { FIRST | LAST | PRIOR | NEXT | ABSOLUTE | RELATIVE }

FROM nombre-de-cursor INTO variable-principal,...,
5.4.CLOSE

Mediante esta sentencia se cierra la tabla de resultados de la consulta

creada por la sentencia OPEN, dando por acabado el acceso a ella. Previo a su
ejecucin, el cursor ha de estar abierto mediante la sentencia OPEN. Es la
ltima sentencia en secuencia lgica en el tratamiento de un cursor, aunque si,
al concluir una transaccin, no se han cerrado todos los cursores abiertos, son
automticamente cerrados.

Una vez cerrado el cursor los resultados de su consulta ya no estarn

disponibles para el programa de aplicacin.

Si, al ejecutarse una sentencia de cierre sobre el cursor, ste no ha sido

previamente abierto de forma satisfactoria, se producir el error 501: Se
pretende cerrar un cursor no abierto.

El formato de esta sentencia es:

CLOSE nombre-de-cursor

donde nombre-de-cursor es el nombre del cursor a cerrar.

Ejemplo:

EXEC SQL
CLOSE DIVISAS
END-EXEC.

5.5. MODIFICACIONES BASADAS EN CURSOR

DB2-SQL embebido soporta la capacidad de eliminar registros y modificarlos

en la tabla a la que se refiera el cursor, a lo largo del recorrido o proceso del
mismo. Aqu se trata de emplear las sentencias DELETE y UPDATE con
formato posicionado.
5.5.1. DELETE

Se borrar de la tabla que se especifique, el registro o fila, que se localizar

estableciendo la posicin que en dicha tabla ocupa el registro o fila a la que
apunta en ese momento el cursor. Tras la supresin de la fila, el cursor no tiene
fila actual. En su lugar, el cursor estar posicionado en el espacio vaco
dejado por la fila suprimida, por lo que, para posicionarnos en una fila
determinada, deberamos recurrir a la sentencia FETCH.

Formato:

DELETE FROM nombre-de-tabla WHERE CURRENT OF nombre-de-cursor

Dado que, al abrir un cursor, nos posicionamos antes del primer registro, que
no sobre l, para poder proceder a su eliminacin mediante esta sentencia y
con este formato, tendramos que previamente realizar un FETCH de dicho
registro para poder proceder a su eliminacin, ya que, de no hacerlo as, se
producira el error de ejecucin +100: no se ha encontrado ninguna fila que
cumpla el criterio de bsqueda o la tabla consultada est vaca.

5.5.2. UPDATE

Esta sentencia har que se modifique en la tabla especificada, el registro o

fila, que se localizar estableciendo la posicin que en ella ocupa, el registro o
fila a la que apunta en ese momento el cursor. Tras la modificacin del registro
o fila, el cursor continuar sobre la fila actual. La modificacin repercutir
sobre la tabla real, no sobre el cursor.

El cursor se habr tenido que definir con la opcin FOR UPDATE OF.

Formato:
UPDATE nombre-tabla SET lista-de-asignaciones
WHERE CURRENT OF nombre-de-cursor
Dado que, al abrir un cursor, nos posicionamos antes del primer registro, que
no sobre l, si deseramos modificarle, para poder hacerlo mediante esta
sentencia y con este formato, tendramos que previamente realizar un FETCH
del mismo para poder proceder a su modificacin, ya que, de no hacerlo as, se
producira el error de ejecucin +100: no se ha encontrado ninguna fila que
cumpla el criterio de bsqueda o la tabla consultada est vaca.

Para este tipo de eliminacin y modificacin, se han de tener en cuenta las

consideraciones y condiciones siguientes:

La consulta asociada con el cursor, ha de extraer los datos de una nica

tabla fuente, por lo que slo se designar una tabla en la clusula FROM
de la sentencia DECLARE CURSOR.

La consulta no podr contener ninguna de las clusulas ORDER BY,

GROUP BY, HAVING ni DISTINCT.
6. CONTROL DE TRANSACCIONES

Una Transaccin es la secuencia de una o mas sentencias DB2-SQL, que juntas

constituyen una unidad de trabajo. Estas sentencias estarn estrechamente
relacionadas pero realizarn tareas independientes unas de otras.

6.1. COMMIT

Establece el final correcto y fsico de la transaccin en vigor. Todos las

sentencias DB2-SQL que impliquen algn tipo de actualizacin previamente
ejecutadas, se harn efectivas sobre la tabla o tablas implicadas.

Formato:

EXEC SQL
COMMIT
END-EXEC

Cuando se tiene mucha informacin actualizada es conveniente poner algn

punto de COMMIT a lo largo del programa, no es necesario poner un punto de
COMMIT al final del mismo porque el DB2 detecta el fin del programa y
genera una instruccin de COMMIT.

6.2. ROLLBACK

Establece el final sin xito de la transaccin en vigor, por lo que no se

completar. Las sentencias DB2-SQL que impliquen algn tipo de actualizacin
sern anuladas, por lo que la base de datos se restaurar al estado previo a
ejecutarse la transaccin.

Formato:

EXEC SQL
ROLLBACK
END-EXEC.
Es conveniente situar puntos de ROLLBACK en las terminaciones por error del
programa, siempre y cuando se trate de un programa de actualizaciones.

Al ejecutarse cualquiera de estas dos sentencias, los cursores que estn

abiertos en el programa se cierran directamente, por lo cual, cuando en un
programa se necesita hacer COMMIT con frecuencia, el cursor debe definirse
con la opcin WITH HOLD FOR, de esta manera se evitar el cierre del
cursor cada vez que se realice COMMIT.

Formato:

DECLARE nombre-cursor CURSOR WITH HOLD FOR sentencia-SQL

7. LENGUAJE DE DEFINICION DE DATOS (DDL)

Este lenguaje agrupa una serie de sentencias que nos van a permitir el definir
los objetos que soportarn los datos.

7.1. CREACIN DE TABLAS

La creacin de una tabla, con sus columnas y caractersticas se realiza

mediante la sentencia CREATE. El formato de sta es:

CREATE TABLE [usuario.]tabla

(columna1 tipo-dato [NOT NULL],
columna2 tipo-dato [NOT NULL],
columna3 tipo-dato [NOT NULL],
columna4 tipo-dato [NOT NULL])

No es obligatorio el indicar el nombre del usuario. El nombre que se asigna a la

tabla no debe coincidir con ningn otro objeto que tenga el usuario.

Si la columna contiene la clasula NOT NULL es obligatorio introducir algn

dato dentro de sta.

En una columna de tipo CHAR o DATE un valor NULL, indica que la fila no
contiene ningn dato, por lo tanto el dato almacenado tiene longitud cero.

En una columna tipo NUMBER los datos NULL no son equivalentes al valor cero.

7.2. MODIFICACIN DE TABLAS

Mediante la sentencia ALTER, se pueden realizar las siguientes operaciones:

- Aadir columnas.

- Modificar definiciones de columnas (NOT NULL).

El formato es el siguiente:

ALTER TABLE tabla

[ADD(col1 tipo, col2 tipo ...)| MODIFY (col1 tipo, col2 tipo...)]

7.3. CREACIN DE SINNIMOS

Permite que el usuario propietario utilice el mismo objeto con nombre distinto.

El formato es el siguiente:

CREATE [PUBLIC] SYNONIM sinnimo

FOR objeto

La creacin de un sinnimo no supone la creacin de nuevos datos, sino una

nueva forma de acceder a los datos contenidos en el objeto sobre el que se
cre.

Si se especifica la clasula PUBLIC se indica la posibilidad de que el objeto sea

accedido por otros usuarios. Por defecto el acceso a un sinnimo est limitado
al usuario que lo ha creado.

7.4. CREACIN DE INDICES

La sentencia CREATE tambin permite la creacin de ndices para las tablas.

El formato de esta sentencia es:

CREATE [UNIQUE] INDEX n-ndice

ON nombre-tabla
(columna1 [ASC|DESC], columna2 [ASC|DESC] ...)

La clasula UNIQUE establece que los valores ndice, formados por las
columnas que se indican, no pueden repetirse en ningn caso, si no se
especifica, el ndice se puede duplicar.

La tabla sobre la que se crea el ndice debe existir previamente.

Si no se indica lo contrario, por defecto, se establecen los ndices de forma
ascendente. Se puede indicar lo contrario mediante las opciones ASC o DESC
de cada columna.

Un ndice puede estar formado por un mximo de 16 columnas concatenadas.

Se pueden crear varios ndices sobre la misma tabla.

7.5. CREACIN DE VISTAS

Cada vez que se realiza una consulta sobre tablas de la base de datos, el
resultado de la misma aparecer segn la estructura de aquellas, y en funcin
de las condiciones enunciadas al formular dichas consultas. Una vez finalizadas,
sus resultados desaparecern, no quedando almacenados de ninguna manera.
Por otro lado, y a no ser que el propio administrador de la base de datos
establezca o gestione permisos de accesos a la misma, a la informacin
contenida en las tablas podr acceder cualquier usuario.

DB2-SQL facilita un procedimiento de filtro y conservacin de resultados de

consultas, que se conoce como Vista.

Una Vista es una definicin almacenada de una sentencia SELECT, a la vez que
de sus resultados, que especifica o limita las columnas que hay que recuperar al
hacer posteriormente alusin a la vista. Podr contener hasta 250 campos, no
habiendo limitacin para el nmero de filas o registros, establecindose en
funcin del nmero de filas que haya en las tablas a las que la propia vista sea
relativa.

La Vista puede ser construida desde ms de una tabla, y se har referencia a

ella como si se tratara de una simple tabla. Pero hay que tener en cuenta que no
se trata de una tabla real almacenada en disco, sino que simplemente es una
tabla virtual, por lo que jams habr problemas de falta de espacio de
almacenamiento en dispositivo alguno.

Otra ventaja ms de la vista, es la de que, pudiendo estar basada en varias

tablas y en mltiples clusulas y condiciones de consulta, se podrn realizar
consultas sobre ella fcilmente como si se tratara de una simple tabla, sin
necesidad de tener que efectuar consultas complejas sobre distintas tablas, ni
combinaciones que podran ser, en muchos casos complicadas, y teniendo que
repetirlas cada vez que se desee realizar la misma consulta.

Tambin se pueden utilizar las vistas para proporcionar seguridad a la base de

datos, pudiendo, igualmente, configurar permisos sobre la vista construida, de
tal modo, que sean diferentes los permisos otorgados sobre las tablas en que
aquella se basa. Se podr otorgar acceso nicamente sobre aquellas filas o
registros a los que la vista se refiera, pero sin implicar acceso a todas las filas
y columnas de las tablas concernidas.

Sobre las vistas creadas se podrn aplicar todas las sentencias de DB2-SQL ya
tratadas.

Formato:

CREATE VIEW nombre-de-vista AS Sentencia-Select

[ WITH CHECK OPTION ]

Se proceder a la creacin de la vista, cuyo nombre ser nombre-de-vista, a

partir de la consulta realizada por medio de la Sentencia-Select que se ha
especificado. La sentencia de consulta podr tener cualquiera de los formatos
y variantes ya vistos.

La opcin WITH CHECK OPTION hace que, si posteriormente a la creacin de

la vista, se pretende realizar cualquier operacin que implique actualizacin,
sobre la tabla o tablas concernidas, DB2-SQL no permita que dicha operacin
se realice si es conflictiva con respecto a la condicin de seleccin del comando
CREATE VIEW. Como ejemplo de esto ltimo, pensemos en insertar en una
tabla un registro que, posteriormente a tal insercin, si se realizara una
consulta sobre la vista de dicha tabla, tal registro no cumpliera la condicin de
la consulta en el comando CREATE VIEW; algo semejante ocurrira con una
operacin UPDATE.
Al crear una vista, no podremos asignarla el nombre de otra ya existente, ya
que se obtendra un error del tipo de que se ha dado el nombre de una vista ya
existente.

7.5.1. ACTUALIZACIONES EN VISTAS Y EL ESTNDAR ANSI/ISO

Ya se ha visto que, cualquier actualizacin sobre una vista, tendr efectos

equivalentes respecto a las tablas fuentes de la misma. As, si se trata de una
vista horizontal (simple copia de registros de la tabla original nica), cualquier
insercin, modificacin o borrado en la vista, repercutir sobre la tabla y a la
inversa. Pero en casos en que no haya correspondencia uno a uno entre las filas
de la vista y la tabla fuente (la vista se obtiene a partir de una consulta
agrupada, etc) no tendra sentido la ejecucin sobre tablas ni sobre vistas de
operacin alguna que implicara actualizacin.

Para evitar en lo posible el problema anterior est lo que se conoce como

estndar SQL1 ANSI/ISO, que especifica los requisitos para que las vistas
sean actualizables:

No debe especificarse la opcin DISTINCT, es decir, las filas

duplicadas no podrn ser eliminadas de los resultados de la consulta.

La clusula FROM debe especificar solamente una tabla actualizable;

es decir, la vista slo puede tener una nica tabla fuente.

Cada elemento de seleccin ha de ser una referencia de columna

simple; la lista de seleccin no podr contener expresiones, columnas
calculadas o funciones de columna.

La clusula WHERE no puede incluir subconsulta alguna; nicamente

podrn aparecer condiciones de bsqueda simples fila a fila.

La consulta no podr incluir las clusulas GROUP BY ni HAVING.

Para que una vista pueda ser actualizable, DB2-SQL deber ser capaz de
relacionar cualquier fila de la vista con su fila fuente en la tabla fuente.
 Anlogamente, el DB2-SQL deber ser capaz de relacionar cada columna
individual a actualizar con su columna fuente en la tabla fuente

7.6. CREACIN DE AGRUPAMIENTOS O CLUSTERS

Estos tipos de datos se crean para que varias tablas se agrupen para compartir
una o varias columnas del mismo tipo, longitud y significado.

Cuando se genera un CLUSTER, cada valor distinto de las columnas se

almacenar una sola vez.

Formato:

CREATE CLUSTER nombre

(col1 tipo, col2 tipo ...)

Posteriormente, para aadir tablas al cluster se utilizar la sentencia CREATE

con el siguiente formato:

CREATE TABLE [usuario.]tabla

(columna1 tipo-dato [NOT NULL],
columna2 tipo-dato [NOT NULL],
columna3 tipo-dato [NOT NULL],
columna4 tipo-dato [NOT NULL])
CLUSTER nombre-cluster (col1, col2,...)

Para crear el CLUSTER la tabla debe tener, al menos, una columna que tenga la
clasula NOT NULL.

7.7. SUPRESIN DE OBJETOS

Para suprimir cualquier objeto se indica de la siguiente forma:

DROP tipo-objeto nombre-objeto

Se debe indicar el mismo objeto que se utiliz en la clasula CREATE y a
continuacin el nombre del mismo.

Ejemplos:

DROP TABLE nombre-tabla

DROP SYNONYM sinnimo

DROP VIEW nombre-vista

8. AUTORIZACIONES

Las tablas en DB2 estn protegidas, no se puede trabajar con ellas amenos que
se tenga la autorizacin para ello.

8.1. SENTENCIA GRANT

Concede autorizacin de acceso a los recursos.

Formato:

GRANT lista de privilegios

(ON recurso)
TO lista ID/PUBLIC
(WITH GRANT OPTION)

Donde:

Lista de privilegios: SELECT, UPDATE, INSERT,...

Recurso: nombre de la tabla

ID: nombre del usuario al que se da la autorizacin

PUBLIC: autorizacin para todos los usuarios

WITH GRANT OPTION: permite al usuario al que se le dio la autorizacin

drsela a su vez a otros usuarios.

La emisin de GRANT requiere autorizacin implcita (si la tabla autorizada es

de otro) o explcita (si la tabla es de uno mismo).

Se puede autorizar en cualquier momento despus de crear el objeto. La

autorizacin se borra de forma automtica del catlogo cuando se borra el
objeto.
La sentencia autorizara la utilizacin de un PLAN:

EXECUTE ON PLAN nombre de plan

Antes de hacer un GRANT hay que crear el PLAN con un primer BIND.

8.2. SENTENCIA REVOKE

Esta sentencia quita la autorizacin.

Formato:

REVOKE lista de privilegios FROM lista ID autor

Slo puede hacerlo el que emiti la sentencia GRANT o el administrador del

sistema.

Slo se les puede dar la sentencia REVOKE a los recursos a los que se dio
GRANT.

Hay 3 categoras de usuarios que estn implcitamente autorizados:

1. El que crea un objeto tiene autorizacin completa automticamente con

WITH GRANT OPTION para este objeto. Esta autorizacin no puede ser
revocada a menos que el objeto se borre.

Cada administrador del sistema tiene, por defecto, acceso total a cualquier
recurso DB2.

2. Puede tambin borrarla pero no puede revocar la autorizacin de acceso al

recurso para el creador.

3. Un administrador de base de datos tiene acceso implcito a todas las tablas

creadas por otros usuarios en las bases que l controla. Sin embargo, no puede
dar autorizacin de estas tablas a otros usuarios.
9. OPERADORES RELACIONALES

9.1. UNION

Se pueden combinar los resultados de dos o ms consultas en forma de una

nica tabla de resultados, mediante el operador UNION colocado entre las
sentencias de seleccin, mediante el formato:

Sentencia-SELECT
UNION
Sentencia-SELECT
UNION
Sentencia_SELECT
...........

Ejemplo:

SELECT ID_FAB, ID_PRODUCTO

FROM PRODUCTOS
WHERE PRECIO > 2000.00
UNION
SELECT DISTINCT FAB, PRODUCTO
FROM PEDIDOS
WHERE IMPORTE > 30000.00

Hay que tener en cuenta una serie de restricciones en las tablas a combinar en
una operacin de UNION:

Las tablas involucradas en la unin han de tener el mismo nmero de

columnas

El tipo de dato de cada columna en la primera tabla debe ser el mismo

que el tipo de datos de la columna correspondiente en la segunda
tabla

Ninguna de las tablas podr estar ordenada con la clusula ORDER

BY, sin embargo los resultados combinados s podrn ser ordenados.
El estndar SQL ANSI/ISO especifica una restriccin adicional para una
sentencia SELECT que participa en una UNION. Solamente permite nombres
de columna o una especificacin de todas las columnas (SELECT *) en la lista de
seleccin.

Haciendo referencia a las UNIONES con filas duplicadas, por omisin, la

operacin UNION elimina las filas duplicadas. Pero si se desea conservar las
filas duplicadas en una operacin UNION, habr que especificar la clusula
ALL inmediatamente despus del operador UNION.

La clusula ORDER BY no puede aparecer en ninguna de las sentencias SELECT

involucradas en la UNION; pero el conjunto combinado de los resultados de la
consulta producidos por la operacin UNION puede ser ordenado,
especificando la clusula ORDER BY despus de la ltima sentencia SELECT.
Puesto que las columnas resultado de la UNION no tienen nombre, sern
referenciadas por el nmero de orden que ocupen en el registro.

Ejemplo:

SELECT IDFAB, ID_PRODUCTO

FROM PRODUCTOS
WHERE PRECIO > 2000.00
UNION
SELECT DISTINCT FAB, PRODUCTO
FROM PEDIDOS
WHERE IMPORTE > 30000.00
ORDER BY 1, 2
9.2. INTERSECCION

La operacin de interseccin (INTERSECT) tiene las mismas propiedades que

la unin y el resultado obtenido ser el de aquellas filas que sean comunes a
ambas tablas.

Formato:

SELECT col1,col2
FROM tabla1
WHERE col3 = constante
INTERSECT
SELECT col1, col2
FROM tabla2
WHERE col4 = constante

9.3. DIFERENCIA

La diferencia es otra operacin relacional que nos permite obtener aquellas

filas de una tabla que no estn en otra.

Formato:

SELECT col1,col2
FROM tabla1
WHERE col3 = constante
MINUS
SELECT col1, col2
FROM tabla2
WHERE col4 = constante
10. SENTENCIA INITIALIZE SOBRE TABLAS

El objeto de la sentencia COBOL INITIALIZE es el de limpiar o inicializar la

variable o estructura a la que se refiera, de acuerdo a su tipo de dato:

INITIALIZE <estructura>

Esta sentencia tambin puede ser aplicada a tablas. En este caso, una vez
ejecutada, el puntero de la tabla a la que se refiera, apuntar al comienzo de la
misma. Se tendr la precaucin de que la tabla especificada en la sentencia
haya sido declarada o incluida, de la forma ya vista, mediante la sentencia
INCLUDE.

Ejemplo:

INITIALIZE DIVISAS

El puntero se colocar al comienzo de la tabla DIVISAS, previo al primer

registro.
11. CONCEPTOS VARIOS

PRECOMPILACIN: este paso de compilacin de programas COBOL-DB2

traduce todas las instrucciones SQL a COBOL.

BIND: valida todas las sentencias SQL en cuanto a autorizaciones, nombres de

columna, vistas y tablas.
Crea un plan de aplicacin al que acudir el programa en el momento de su
ejecucin.

PLAN: objeto DB2 que permite al programa acceder a la tabla ejecutable.

REBIND: actualizar el plan (compara el plan con la tabla actual para ver si ha
cambiado mucho).

DBRM: miembro con informacin de lo que el programa tiene dentro de las

instrucciones EXEC SQL y END-EXEC para poder crear el plan.
Se genera en la compilacin con el ejecutable. Tiene el mismo nombre que el
programa.

El BIND lee lo que hay en el DBRM, lo que hay en la tabla y, de acuerdo a eso
crea el PLAN.
Cada vez que se compile el programa hay que realizar el BIND.

TIMESTAMP: variable con fecha y hora que marca al ejecutable y al DBRM.

Al crearse el PLAN, se marca con el TIMESTAMP del DBRM. Al acceder el
programa a una tabla a travs del plan tiene que coincidir el TIMESTAMP.