En primer lugar, necesitaremos un proceso en el que se vaya recuperando toda la información del fichero DB2 y cargándola en una tabla. Una vez finalizado dicho proceso, incluiremos una rutina que vaya procediendo a leer los datos de la tabla y los vaya mostrando por pantalla.
Esto sería algo así:
PERFORM 1000-INICIO
THRU 1000-INICIO-EXIT
*
PERFORM 2000-PROCESO
THRU 2000-PROCESO-EXIT
UNTIL FIN-ENTRADA1
*
PERFORM 3000-LISTADO
THRU 3000-LISTADO-EXIT
Rutina de Inicio
Aquí tendremos que hacer un primer acceso al fichero DB2 para recuperar el primer registro y almacenarlo en la variable tabla. Si la rutina que hace eso acceso se denomina, por ejemplo, LEER-ENTRADA, entonces la invocación en la rutina de inicio sería la siguiente.
PERFORM 9100-LEER-ENTRADA1
THRU 9100-LEER-ENTRADA1-EXIT.
*
Lectura de Fichero DB2
En la rutina 2000-PROCESO tendremos que incluir la misma invocación a LEER-ENTRADA que se hizo en la rutina Inicio, con la diferencia de que aquí se ejecutará varias veces, hasta que se llegue al último registro disponible en el fichero DB2.
Este subproceso LEER-ENTRADA tendrá que incluir un acceso a la tabla DB2 mediante la sentencia FETCH. La estructura sería algo similar a la siguiente.
9100-LEER-ENTRADA1.
*
* CARGAMOS REGISTRO DE LA TABLA EN LA VARIABLE DE TRABAJO
* ------------------------------------------------------- INITIALIZE PAR-SALIDA
EXEC SQL
FETCH CUR_JJCLIEM0
INTO
:S-CLIENTE,
:S-NOMBRE,
:S-APELLIDO1,
:S-APELLIDO2,
:S-ALTURA,
:S-PESO,
:S-IMC,
:S-OBSERVACIONES INDICATOR :I-OBS,
:S-FECHA
END-EXEC
*
* VERIFICAMOS SI LAS OBSERVACIONES SON NULAS (NULL)
* -------------------------------------------------
IF I-OBS < 0
MOVE '-' TO S-OBSERVACIONES
END-IF
*
* GESTION DEL SQLCODE
* -------------------
EVALUATE TRUE
WHEN SQLCODE = ZEROES
ADD 1 TO CO-TAB
ADD 1 TO CO-LEIDOS-ENTRADA1
WHEN SQLCODE = +100
SET FIN-ENTRADA1 TO TRUE
WHEN OTHER
MOVE SQLCODE TO SQLCODE-DIS
MOVE SQLCODE-DIS TO WS-FILE-ERROR
MOVE 'ERROR ACCESO DB2' TO WS-DESCRIPCION
PERFORM 9980-GENERAR-ERROR
THRU 9980-GENERAR-ERROR-EXIT
END-EVALUATE
*
* CARGAMOS REGISTRO EN LA TABLA DE DATOS
* --------------------------------------
IF SQLCODE = ZEROS
MOVE S-CLIENTE TO T-CLIENTE(CO-TAB)
MOVE S-NOMBRE TO T-NOMBRE(CO-TAB)
MOVE S-APELLIDO1 TO T-APELLIDO1(CO-TAB)
MOVE S-APELLIDO2 TO T-APELLIDO2(CO-TAB)
MOVE S-ALTURA TO T-ALTURA(CO-TAB)
MOVE S-PESO TO T-PESO(CO-TAB)
MOVE S-IMC TO T-IMC(CO-TAB)
MOVE S-OBSERVACIONES TO T-OBSERVACIONES(CO-TAB)
MOVE S-FECHA TO T-FECHA (CO-TAB)
END-IF.
*
9100-LEER-ENTRADA1-EXIT.
EXIT.
*
Como vemos, la estructura se divide en 3 partes:
1º) Acceso al fichero DB2 mediante FETCH y recogida de los datos en la variable auxiliar correspondiente (incluyendo variables de indicador nulo, si hiciesen falta).
2º) Validación del SQLCODE del acceso al fichero DB2 y actuación en función de su resultado. Hay que observar como, cada vez que el acceso es correcto, se incrementa en 1 unidad el valor del contador de la variable Tabla (CO-TAB).
3º) Finalmente, carga de los datos de la variable auxiliar a la posición correspondiente de la variable Tabla, especificada por CO-TAB (esta tabla nos servirá para almacenar todos los registros del fichero DB2).
Rutina de Listado
Por último, tendremos una rutina que irá accediendo a la variable Tabla donde se almacenaron los datos del fichero DB2 e irá mostrando la información por pantalla. El display de registros se ejecutará hasta que se alcance el número máximo de registros leídos del fichero DB2 (MAX-REG).
3000-LISTADO.
MOVE 1 TO CO-TAB
*
* MOSTRAMOS EL LISTADO DE CLIENTES
* --------------------------------
PERFORM 3100-DISPLAY-REGISTRO
THRU 3100-DISPLAY-REGISTRO-EXIT
UNTIL CO-TAB > MAX-REG.
*
3000-LISTADO-EXIT.
EXIT.
*
La rutina de Display podrá implementarse de muchas formas. Desde una simple sentencia DISPLAY a una carga de datos sobre un MAPA, o incluso a un volcado de datos sobre un fichero secuencial. Eso ya dependerá del objetivo específico del programa Cobol implementado.
Por ejemplo, con un simple DISPLAY sería así.
3100-DISPLAY-REGISTRO.
*
* MOSTRAMOS LA INFORMACION DEL CLIENTE
* ------------------------------------
DISPLAY CO-TAB ' > '
T-CLIENTE(CO-TAB) ' / '
T-NOMBRE(CO-TAB) ' / '
T-APELLIDO1(CO-TAB) ' / '
T-APELLIDO2(CO-TAB) ' / '
T-ALTURA(CO-TAB) ' / '
T-PESO(CO-TAB) ' / '
T-IMC(CO-TAB) ' / '
T-OBSERVACIONES(CO-TAB) ' / '
T-FECHA(CO-TAB) ' / '
*
ADD 1 TO CO-TAB.
*
3100-DISPLAY-REGISTRO-EXIT.
EXIT.
*
Y nada más. Esto sería suficiente para acceder a un fichero DB2, obtener un listado de datos a partir de su lectura y mostrar dicha información por pantalla.
Un problema típico que puede aparecer en estos casos se produce cuando las ocurrencias de la variable Tabla no son suficientes para almacenar todos los registros que existen en el fichero DB2.
En esos casos habría que recurrir a lo que se denomina proceso de Paginación, que consiste en llenar la variable Tabla con datos del fichero DB2, mostrarlos por pantalla, vaciar dicha Tabla y volver a llenarla con los siguientes datos recuperados del DB2 (y así iterativamente hasta llegar al final del fichero DB2). Pero la implementación de este proceso ya la veremos otro día en otro post.
Saludos.
No hay comentarios:
Publicar un comentario