Declaración de CURSOR sobre una tabla DB2

Cuando queramos recuperar registros secuencialmente de una tabla DB2 no nos bastará con ejecutar simplemente una sentencia Fetch sobre la misma. Previamente, tendremos que haber declarado un CURSOR que nos permita realizar el acceso a la misma.



En un programa Cobol, el acceso a una tabla DB2 con la sentencia Fetch se realiza mediante un Cursor. Por tanto, en primer lugar tendremos que haber definido dicho Cursor, mediante la sentencia DECLARE CURSOR, indicando cuáles son los campos que queremos que sean recuperados de la tabla DB2 en el momento de su acceso.



Como siempre, lo veremos mejor con el siguiente ejemplo, donde se está declarando el Cursor denominado CUR_JJCLIEM0, que posteriormente nos servirá para acceder a la tabla JJCLIEM0.

*                                       
* DECLARAMOS CURSOR DE JJCLIEM0         
* -----------------------------         
     EXEC SQL                           
       DECLARE CUR_JJCLIEM0 CURSOR FOR  
         SELECT CLIENTE,                
                NOMBRE,                 
                APELLIDO1,              
                APELLIDO2,              
                ALTURA,                 
                PESO,                   
                IMC,                    
                OBSERVACIONES,          
                FECHA                   
         FROM   JJCLIEM0                
         WHERE  CLIENTE > :CLAVE-CLIENTE
           AND  IMC > :CLAVE-IMC        
         ORDER BY CLIENTE, IMC          
     END-EXEC.                            
*

Para declarar el Cursor, tenemos que incluir los siguientes puntos:

1º) Sentencia DECLARE CURSOR FOR: en ella deberá indicarse el nombre que le queremos dar al cursor. Con ese nombre es con el que se hará referencia a él en el programa Cobol.

2º) A continuación, se incluye una cláusula SELECT donde se especificarán todos los campos de la tabla DB2 que van a formar parte del Cursor.

3º) Cláusula FROM: aquí es donde especificaremos el nombre de la tabla DB2 a la que accederá nuestro Cursor (en este caso, JJCLIEM0).

4º) Cláusula WHERE: para especificar las condiciones que deben cumplir los registros de la tabla DB2 para ser extraidos por el Cursor.

5º) Finalmente, con el comando ORDER BY indicaremos el orden en que deben ser leídos los datos de la tabla DB2.

Apertura y Cierre del Cursor

Una vez definido el Cursor, antes de que pueda ser empleado para acceder a una tabla DB2, deberemos proceder a la apertura del mismo. Esto se realizará mediante una sencilla sentencia de OPEN CURSOR. Si seguimos con el ejemplo anterior, la apertura sería así.

*
*    ABRIMOS EL CURSOR DEL FICHERO 
*    ----------------------------- 
     EXEC SQL                      
       OPEN CUR_JJCLIEM0           
     END-EXEC   
*                   

A continuación, como siempre, habrá que validar el estado de la variable SQLCODE para saber si la apertura del Cursor ha sido correcta o no.

*
*    VALIDAMOS SQLCODE DEL OPEN CURSOR                        
*    ---------------------------------                        
     EVALUATE TRUE                                            
       WHEN SQLCODE = ZEROES                                  
         DISPLAY 'ACCESO DB2 OK'                              
         INITIALIZE WS-FILE-ERROR                             
       WHEN OTHER                                             
         MOVE SQLCODE TO SQLCODE-DIS                          
         MOVE SQLCODE-DIS    TO WS-FILE-ERROR                 
         MOVE 'ERROR OPEN CURSOR DB2' TO WS-DESCRIPCION       
         PERFORM 9980-GENERAR-ERROR                           
            THRU 9980-GENERAR-ERROR-EXIT
     END-EVALUATE.                    
*

Del mismo modo, tras la finalización del acceso a la tabla DB2, deberemos proceder a realizar el cierre del Cursor. Esto lo realizaremos mediante la sentencia CLOSE CURSOR. El código quedaría así.

*                          
*    CERRAMOS EL CURSOR    
*    ------------------    
     EXEC SQL              
       CLOSE CUR_JJCLIEM0  
     END-EXEC
* 

Aquí también tendremos que validar el estado del SQLCODE, para asegurarnos de que el cierre del Cursor se ha ejecutado correctamente.

*                                                         
*    VALIDAMOS SQLCODE DEL CLOSE CURSOR                   
*    ----------------------------------                   
     EVALUATE TRUE                                        
       WHEN SQLCODE = ZEROES                              
         DISPLAY 'ACCESO DB2 OK'                          
         INITIALIZE WS-FILE-ERROR                         
       WHEN OTHER                                         
         MOVE SQLCODE TO SQLCODE-DIS                      
         MOVE SQLCODE-DIS    TO WS-FILE-ERROR             
         MOVE 'ERROR CLOSE CURSOR DB2' TO WS-DESCRIPCION  
         PERFORM 9980-GENERAR-ERROR                       
            THRU 9980-GENERAR-ERROR-EXIT                  
     END-EVALUATE.
*                         

El acceso a la tabla DB2 mediante el Cursor ya lo vimos en el post dedicado a la sentencia FETCH. Refrescaremos la memoria aquí, poniendo cómo quedaría el código para el ejemplo que hemos ido siguiendo a lo largo de todo el post.

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

Por último, mencionar que, antes de comenzar a operar, tendremos que inicializar también las claves por las que va a ir leyendo el Cursor. Por ejemplo, podríamos hacer lo siguiente:

*
INITIALIZE CLAVE-CLIENTE CLAVE-IMC
MOVE 000000000 TO CLAVE-CLIENTE   
MOVE 10,1      TO CLAVE-IMC
*        

Esperamos que, con todo lo indicado, haya quedado claro cómo hay que operar con Cursores en un programa Cobol. Parece que son muchas cosas a tener en cuenta pero, una vez que hayamos aprendido a hacerlo, veremos que todo se hace de forma bastante mecánica.

Saludos.