QMF basico

A lo ya explicado en una entrada anterior (pichar aquí), podemos ampliar alguna cosilla con el magnífico post elaborado por Consultorio Cobol acerca del QMF basico.

DB2 - filas leídas por un cursor

Primero refrescaremos la memoria con los cursores y las operaciones básicas que se pueden realizar con los cursores. Para ello pincharemos aquí (eso sí, si consideras necesario refrescar la memoria; en caso contrario, no es necesario).

En ocasiones es necesario utilizar un cursor por las especificaciones dadas para implementar en un determinado programa. Si además queremos saber cuántas filas ha leído dicho cursor, ¿cómo se puede hacer? En un principio puede parecer un tanto complejo por los siguientes motivos:

1. En la copy SQLCA no existe una variable para tal efecto.
2. Si consultas diferentes foros en los que se trata esta duda, se llega a esta conclusión: no se puede saber de antemano cuántas filas va a leer dicho cursor.
3. La variable ROWCOUNT se utiliza en gestores de BBDD como Sql Server  para saber cuántas filas devuelve una consulta, pero en DB2 no existe y, por tanto, en Cobol no encontrarás una variable que se use con tal fin (a menos que no definas por programa una variable auxiliar con dicho nombre).

Por lo tanto, llegados a este punto, ¿cómo podemos saber cuántas filas ha leído un cursor? A continuación explicamos una posible solución.

Al realizar el FETCH del cursor, cuando el SQLCODE es igual a 0 podemos incrementar en 1 una variable auxiliar, por ejemplo AUX-ROWCOUNT, que previamente estará inicializada a 0 (si se inicializa antes de abrir/tratar/cerrar el cursor, mejor que mejor).

Cuando hayamos realizado el tratamiento del cursor, con lo que ello implica, podremos saber cuántas filas han sido leídas por el cursor. Tratar un cursor implicaría lo siguiente:

1. Abrir cursor
2. Leer cursor
3. Tratar cursor hasta el final del mismo, en donde se realizan dos operaciones:
1. Operaciones a realizar con la fila recuperada del cursor
2. Leer cursor
4. Cerrar cursor

Y tras tratar el cursor dando estos pasos sabremos las filas leídas por el cursor gracias a la variable auxiliar que habremos ido incrementando en 1 con cada FETCH. En el caso de que el cursor no recuperara ninguna fila tendríamos dicha variable auxiliar con su valor de inicialización (es decir, 0).

¿Qué sucede si el cursor está dentro de un módulo o rutina? No es mayor problema. En la copy de E/S de dicho módulo o rutina, si estuviera correctamente codificada, debería haber una variable dentro de las variables de salida de la misma que se encargara de informarnos de cuántas filas han sido leídas por el cursor en cuestión. Dicha variable se podría llamar, por ejemplo, COPY-S-FIL-RECU-CURSOR o COPY-S-ROWCOUNT.

Si el programa o módulo/rutina no tiene definida una variable a tal efecto puesss....va a ser difícil saber cuántas filas ha leído el cursor. Es difícil pero no imposible, ¿sabéis por qué? Porque se puede aprovechar una modificación en el código para incluir dicha variable que cuente las filas leídas por el cursor y en ese momento ya tendríamos dicha información.

Pues esto ha sido todo, espero que os haya servido de ayuda.

Sentencias SQL

En un post anterior, titulado Consultar dudas, ya hablamos de la página web de w3schools (también la puedes localizar en la sección "Webs de interés" de este mismo blog).

Se resaltaba lo útil que es para consultar dudas.

Hoy queremos resaltar el tutorial de SQL que dispone dicha página web (puedes acceder a él pinchando aquí). Como podrás observar es bastante completo así como útil para resolver dudas.

Un tutorial que merece no ser perdido de vista cuando trabajamos con sentencias SQL con independencia de que estemos utilizando DB2, Oracle, Access o MySQL.

QMF

Una utilidad existente en el mundo HOST es la siguiente: Query Management Facility (QMF), una herramienta que realiza consultas y crea informes para los sistemas de gestión de bases de datos relacionales de DB2 de IBM.

Generalmente nos encontramos el acceso de QMF en el menú inicial del TSO, dependiendo de la instalación.

Accedemos al QMF. Al acceder encontramos un pantalla en donde escribiríamos la sentencia select que queremos ejecutar y a continuación pulsamos PF2 (o la tecla que haya definida al efecto de ejecutar la sentencia). Tras realizar esto veríamos el resultado de la SELECT.

En este punto tenemos dos opciones: teclear F6 ó F9.

Con F6 volveríamos a la pantalla antes mencionada teniendo opción de escribir una nueva SELECT.

 

Con F9 nos da la opción de elegir qué campos queremos que se muestren al ejecutar la query, es tan sencillo como poner una O de Ommit en la columna USAGE en aquellos campos que queremos que NO se muestren.

 

Si pinchamos F3 volvemos a la pantalla inicial, en la que podemos volver a escribir una nueva SELECT. Si estando en dicha pantalla pulsamos F3, nos saldríamos del QMF.

Cobol: Utilizar sentencias SQL: count

Si queremos realizar un select count(*), la sentencia sería:

              SELECT COUNT(*) INTO :NUM-REG :IND-NULL
              FROM {TABLA,}[WHERE CONDICIÓN]

Teniendo en cuenta lo siguiente:

• Se deben definir NUM-REG e IND-NULL como PIC S9(04) COMP
• A la hora de controlar el SQLCODE devuelto por esta sentencia SQL es muy importante la variable IND-NULL por lo siguiente:

               IF SQLCODE EQUAL ZEROES

                      IF IND-NULL EQUAL -1

                          MOVE ZEROES TO NUM-REG

                      END-IF

               ELSE

                   PERFORM ERROR-DB2

               END-IF

Esto es todo lo que hay que tener en cuenta sobre esta sentencia SQL.

Cobol: Utilizar sentencias SQL: eliminar.

     Para eliminar filas de una tabla lo haremos mediante la sentencia DELETE cuya sintaxis es la siguiente:

              DELETE FROM TABLA[WHERE CONDICIÓN]

     La cláusula WHERE se utiliza para borrar aquellas filas que cumplan dicha condición. Si no se utiliza esta cláusula se borraría la tabla entera.

Cobol: Utilizar sentencias SQL: modificar.

     Para modificar filas en una tabla lo haremos mediante la sentencia UPDATE cuya sintaxis es la siguiente:

                 UPDATE TABLA SET {COLUMNA = VALOR,}[WHERE CONDICIÓN]

     En la cláusula SET indicaremos las columnas que queremos modificar y después del igual indicaremos el valor que queremos asignar.
     Con la cláusula WHERE indicaremos una condición de modo que sólo se modificarán las filas que cumplan dicha condición. Se puede omitir pero en este caso las modificaciones indicadas en la cláusula SET se aplicarían en todas las filas de la tabla.

Cobol: Utilizar sentencias SQL: seleccionar 2.

     Como indicamos en la anterior entrada, en la cláusula WHERE se utilizan una serie de operadores para construir la condición a emplear en dicha cláusula. Esos operadores son los operadores de comparación:

         1) Igualdad (=).

         2) Desigualdad (!=, <>, ^=).

         3) Menor que (<).

         4) Mayor que (>).

         5) Menor o igual que (<=).

         6) Mayor o igual que (>=).

         7) Igual a cualquiera de los miembros entre paréntesis (IN). Ejemplo:

                       WHERE COD_DEP IN (100, 200, 300)

         8) Distinto a cualquiera de los miembros entre paréntesis (NOT IN).

             Ejemplo:

         9) Contenido en el rango (BETWEEN). Ejemplo:

                       WHERE COD_EMP BETWEEN 100 AND 199

         10) Fuera del rango (BETWEEN). Ejemplo:

         11) Contiene una determinada cadena (LIKE). Cuando se utiliza el LIKE

               es frecuente el uso de los comodines. Dichos comodines pueden

               equivaler a un caracter ( _ ) o a varios caracteres (%): '_abc%',

               '%abc%', 'abc_' o 'abc%'. Ejemplo:

                       WHERE NOMBRE LIKE 'MA%';

     También existen operadores aritméticos u operadores de cadenas de caracteres. Los primeros pueden emplearse no sólo en la cláusula WHERE sino que también para mostrar información de una determinada manera a partir de las columnas existentes en las tablas. Mientras que los segundos se utilizan para mostrar información de una determinada manera a partir de las columnas existentes en las tablas (NO se utilizan en la cláusula WHERE).

     Dentro de los operadores aritméticos tenemos:

         1) Suma (+). Ejemplo:

                       SELECT NOMBRE, SALARIO+COMISION FROM EMPLEADO

                       WHERE OFICIO='VENDEDOR'

         2) Resta (-). Ejemplo:

                       SELECT NOMBRE FROM EMPLEADO

                       WHERE SYSDATE - FEC_ALTA > 365

         3) Producto (*). Ejemplo:

                       SELECT NOMBRE, SALARIO*12 FROM EMPLEADO

         4) División (/). Ejemplo:

                       SELECT NOMBRE, SALARIO/31 FROM EMPLEADO

     Dentro de los operadores de cadenas de caracteres tenemos:

         1) Concatenación (||). Ejemplo:

                       SELECT NOMBRE||OFICIO FROM EMPLEADO

                       WHERE COD_EMP NOT BETWEEN 100 AND 199

                       WHERE COD_DEP NOT IN (300, 500)

Cobol: Utilizar sentencias SQL: seleccionar 1.

     Para seleccionar filas en una tabla lo haremos mediante la sentencia SELECT cuya sintaxis es la siguiente:

              SELECT {*|{columna,}} FROM {TABLA,}[WHERE CONDICIÓN]
                         [ORDER BY {COLUMNA [ASC|DESC],}

     A tener en cuenta:


        1) Después de escribir SELECT debemos indicar * (se mostraría todas las columnas existentes en la tabla) o indicamos aquellas columnas que queremos ver. Ejemplos:

               SELECT * FROM TABLA


               SELECT COLUMNA3, COLUMNA7 FROM TABLA


        2) Después de escribir FROM debemos indicar la tabla o tablas de donde queremos ver la información. Ejemplos:


               SELECT * FROM TABLA1


               SELECT * FROM TABLA1, TABLA2

               SELECT A.COLUMNA1, B.COLUMNA8 FROM TABLA1 A, TABLA2 B


        3) Cláusula WHERE: se utiliza para seleccionar aquellas filas que cumplan la condición indicada. En esta cláusula se utilizan una serie de operadores que veremos en la siguiente entrada. Ejemplos:


               SELECT * FROM TABLA1 WHERE FECHA_ANTIG >= '20110101'


               SELECT A.NOMBRE, B.SALARIO FROM TABLA1 A, TABLA2 B
               WHERE (B.FECHA_ANTIG >= '20110101' AND
                           A.COD_EMPL = B.COD_EMPL)

        4) Cláusula ORDER BY: se utiliza para ordenar las filas devueltas por la select. Podemos indicar ASC para que muestre los datos ordenados de manera ascendente (de menor a mayor) o DESC para que muestre los datos ordenados de manera descendente (de mayor a menor). Ejemplos:


               SELECT * FROM TABLA1
               WHERE FECHA_ANTIG >= '20110101'
               ORDER BY FECHA_ANTIG         (1)


               SELECT * FROM TABLA1
               WHERE FECHA_ANTIG >= '20110101'
               ORDER BY FECHA_ANTIG ASC         (2)


               SELECT A.NOMBRE, B.SALARIO FROM TABLA1 A, TABLA2 B
               WHERE (B.FECHA_ANTIG >= '20110101' AND
                           A.COD_EMPL = B.COD_EMPL)
               ORDER BY B.FECHA_ANTIG DESC

               (1) y (2) son equivalentes.

Cobol: Utilizar sentencias SQL: insertar.

     Para insertar filas en una tabla lo haremos mediante la sentencia INSERT cuya sintaxis es la siguiente:

                 INSERT INTO TABLA VALUES (VALOR1, VALOR2, ..., VALORN)

Cobol: Utilizar sentencias SQL. Introducción.

     En los programas se utilizan sentencias SQL para insertar, modificar, seleccionar o eliminar filas en tablas. Estas sentencias se denomina Lenguaje de Manipulación de Datos o DML. En sucesivas entradas iremos viendo la sintaxis de las sentencias SQL mecionadas anteriormente.

     Aprovecho esta entrada, ya que lo que voy a decir es común para las sentencias SQL mencionadas en el anterior párrafo, para hablar de la sentencia COMMIT. Esta sentencia se utiliza para hacer permanentes los cambios realizados a través de cualquiera de las sentencias SQL mencionadas (a excepción de la select ya que sólo recupera información). Hay programas que no la utilizan pero en otros sí. El problema de no usarla es que todas las modificaciones realizadas en una tabla, en caso de que falle un programa en el proceso batch en el que se ejecuta, se pierden pues se hace automáticamente ROLLBACK. En este caso se relanzaría la cadena a partir del paso cascado con todos los registros del fichero de entrada (en ocasiones se elimina el registro que ha provocado el error).

     ¿Cómo se emplea la sentencia COMMIT y en qué casos? Es muy fácil, normalmente se utiliza cuando estamos ante un proceso en el que se quiere, en caso de error en un determinado registro de un fichero y falle el jcl en el que se procesa, procesar aquellos registros no procesados a partir del último registro del que se ha hecho COMMIT. La manera en que normalmente se utiliza es la siguiente: cuando alguna sentencia SQL (insert, update o delete) termina bien (SQLCODE = 0) incrementamos en 1 una variable que previamente hayamos definido, por ejemplo W-COMMIT, e inicializado a 0 ó 1 (esto va en gustos) al inicio del programa, cuando esa variable sea mayor que un determinado valor, por ejemplo 50, se realizarán tres acciones: ejecutar la sentencia COMMIT, inicializar la variable W-COMMIT y mostrar por pantalla qué registro del fichero de entrada ha sido el último que ha provocado la realización del COMMIT. Este proceso supone que para cada cierto número de sentencias SQL hagamos COMMIT y no perdamos los cambios hechos en una tabla. Es importante mostrar en pantalla el registro del fichero a partir del cual se ha hecho la sentencia SQL que ha provocado que el incremento en 1 de la variable W-COMMIT haya cumplido la condición para hacer COMMIT ya que si después del COMMIT se procesan muy pocas filas y casca el proceso debemos saber cuál esl último registro procesado para eliminar del fichero de entrada ese registro y los anteriores y así lanzar de nuevo el jcl desde el paso cascado con aquellos registros del fichero de entrada que queden por procesar.

     Bien es verdad que mediante sentencias SQL podemos manejar tablas (crear una tabla, modificar campos de la tabla, añadir campos nuevos a la tabla,...) pero no lo vamos a ver ya que dichas sentencias no se utilizan en programas cobol.

    Las sentencias SQL que veremos en siguientes entradas, para ser utilizadas en programas cobol, debemos realizar lo siguiente:

                EXEC SQL
                        [sentencia SQL]
                END-EXEC

     En  [sentencia SQL]  se indicará la sentencia SQL que corresponda (y que veremos en sucesivas entradas).

   Se debe controlar el SQLCODE devuelto tras la ejecución de la correspondiente sentencia SQL.

    Lo más importante de todo es no olvidarnos de incluir un INCLUDE muy importante cuando manejamos sentencias SQL en un programa COBOL. Dicho INCLUDE tan importante es: SQLCA.