En ocasiones, cuando queremos extraer un listado de datos de un fichero DB2 y mostrarlos por pantalla, no tenemos la fortuna de que todos los registros DB2 nos quepan en la variable Tabla que hemos creado para recoger la información. En esos casos no nos queda más remedio que recurrir a un proceso de paginación.
Para implementar una paginación necesitaremos una rutina que acceda al fichero DB2 mediante la sentencia FETCH y obtenga registros del mismo hasta que se produzca el llenado de la variable Tabla, momento en el que se incrementará el contador de páginas. A continuación, se mostrá la información por pantalla y se reseteará la variable Tabla. Así podremos volver a proceder a su llenado una vez más,
lo que sería algo así como la siguiente página del proceso. Todo esto se repetirá hasta que ya no queden más registros que recuperar del DB2.
La estructura básica sería la siguiente.
*
PERFORM 1000-INICIO
THRU 1000-INICIO-EXIT
*
PERFORM 2000-PROCESO
THRU 2000-PROCESO-EXIT
UNTIL FIN-ENTRADA1
*
La rutina PROCESO, que se ejecutará mientras no se recoja hasta el último registro del fichero DB2 (FIN-ENTRADA), tendría la siguiente forma.
2000-PROCESO.
*
* MOSTRAMOS DATOS POR PANTALLA
* ----------------------------
IF CO-PAG > 0
INITIALIZE CO-TAB
INITIALIZE TAB-SALIDA
SET NO-FIN-PAGINA1 TO TRUE
END-IF
*
* LEEMOS EL SIGUIENTE REGISTRO DEL FICHERO
* ----------------------------------------
PERFORM 9100-LEER-ENTRADA1
THRU 9100-LEER-ENTRADA1-EXIT
UNTIL FIN-PAGINA1
*
PERFORM 3000-LISTADO
THRU 3000-LISTADO-EXIT.
*
2000-PROCESO-EXIT.
EXIT.
*
A continuación, pasamos a detallar los procesos anteriores.
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 final de la página actual (es decir, hasta que se produzca el llenado de la variable Tabla que recoge la información del 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
*
* CONTROL DE PAGINACION
* ---------------------
IF SQLCODE = 100 OR CO-TAB = 3
SET FIN-PAGINA1 TO TRUE
ADD 1 TO CO-PAG
END-IF
*
* 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 4 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º)
Control de Paginación. Una vez se ha llenado la variable Tabla, procedemos a incrementar en 1 unidad el contador de páginas y activamos el parámetro de Fin de Página actual. De esta forma, el proceso sabrá que puede pasar a ejecutar la rutina que muestra la información y, posteriormente, repetir el proceso de lectura del fichero DB2 para la siguiente página.
4º) 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 almacenados en la variable Tabla (MAX-PAG, que se correspondería con el número de registros visualizables en una página).
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-PAG.
*
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 haciendo uso de un proceso de paginación. Con él se podría obtener
un listado de datos a partir de su lectura y mostrar dicha información
por pantalla, aunque el número de registros del DB2 supere al número de ocurrencias de la variable Tabla que los recoge.
Saludos.
