Desarrollando en Cobol y Natural sobre Plataforma Mainframe

jueves, 21 de noviembre de 2013

Paginación de Listado de registros DB2

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.

No hay comentarios:

Publicar un comentario

Related Posts Plugin for WordPress, Blogger...