COBOL/CICS vol.2: acceso a ficheros.

En este artículo veremos un programa CICS que recoge información de la pantalla y actualiza un fichero VSAM. Al igual que en el ejemplo anterior, se trata de un programa conversacional, es decir, el código se ejecutará de principio a fin sin devolver el control al CICS en ningún momento (salvo al finalizar la ejecución).

En el artículo COBOL/CICS vol.1: primer contacto vimos como crear una transacción CICS y asociarla a nuestro programa, por lo que no volveremos a explicarlo.
En esta ocasión veremos como definir un fichero VSAM en CICS para que pueda ser utilizado por nuestro programa. El sistema será el mismo que para definir un programa.

Utilizaremos la transacción CEDA para definir el fichero.
Escribiremos CEDA DEFINE FILE
La información a rellenar será:
File
Group
DSNAme
Add = yes
BRowse = yes
DELete = yes
READ = yes
UPDATE = yes

Una vez definido, tendremos que instalarlo:
CEDA INSTALL FILE(FILE1)
Se debe rellenar el campo Group

Ahora si consultamos la transacción CEMT veremos que ya aparece nuestro fichero:
CEMT I FILE(FILE1)

Ya tenemos el fichero listo para usar.

Antes de meternos a ver el programa, vamos a ver las instrucciones CICS de acceso a fichero que vamos a utilizar.

STARTBR: Apertura del fichero

      EXEC CICS STARTBR
                FILE ('FILE1')
                RIDFLD (WX-CODIGO)
                KEYLENGTH (WX-LONG-CLAVE)
                GTEQ
                RESP (WX-RESP)
      END-EXEC.

Donde:
FILE1 es el nombre que le hemos dado a nuestro fichero en CICS.
RIDFLD es el campo clave del fichero.
KEYLENGTH es la longitud de la clave.
GTEQ indica mayor o igual.
RESP indicamos la variable donde guardaremos el código de respuesta.

DELETE: borra un registro del fichero

    EXEC CICS DELETE
              RIDFLD (WX-CODIGO)
              FILE ('FILE1')
              NOHANDLE
    END-EXEC.

Nota: si usamos NOHANDLE el código de respuesta lo tendremos en EIBRESP


WRITE: graba un registro

     EXEC CICS WRITE
               FILE ('FILE1')
               RIDFLD (WX-CODIGO)
               LENGTH (WX-LONG-REG)
               FROM (REG-VSAMKSDS)
               NOHANDLE
     END-EXEC.

Donde:
LENGTH es la longitud del registro
FROM es el nivel 01 que define la estructura del fichero

READ: lectura directa

     EXEC CICS READ
               RIDFLD (WX-CODIGO)
               FILE ('FILE1')
               INTO (REG-VSAMKSDS)
               LENGTH (WX-LONG-REG)
               NOHANDLE
     END-EXEC.

Donde:
INTO es el nivel 01 que define la estructura del fichero.

READNEXT: lectura del fichero

     EXEC CICS READNEXT
               INTO (REG-VSAMKSDS)
               RIDFLD (WX-CODIGO)
               FILE ('FILE1')
               KEYLENGTH (WX-LONG-CLAVE)
               RESP (WX-RESP)
     END-EXEC.


UPDATE: indica lectura con intención de actualizar

     EXEC CICS READ
               RIDFLD (WX-CODIGO)
               FILE ('FILE1')
               INTO (REG-VSAMKSDS)
               LENGTH (WX-LONG-REG)
               UPDATE
               NOHANDLE
     END-EXEC.

Nota: con UPDATE bloqueamos el registro para que no se pueda acceder a él mientras tanto

REWRITE: actualiza un registro

     EXEC CICS REWRITE
               FILE ('FILE1')
               LENGTH (WX-LONG-REG)
               FROM (REG-VSAMKSDS)
               NOHANDLE
     END-EXEC.

ENDBR: cierre del fichero

     EXEC CICS ENDBR
               FILE ('FILE1')
               RESP (WX-RESP)
     END-EXEC.


La semana que viene continuaremos el artículo con el código completo del programa y su ejecución. Esta no hay tiempo para más!

COBOL/CICS vol.1: primer contacto.

En este artículo veremos en uso el programa COBOL/CICS más sencillo. Usaremos las sentencias CICS para enviar y recoger texto de la pantalla, pero sin formatear. Este programa será conversacional, es decir, el código se ejecutará de principio a fin sin devolver el control al CICS en ningún momento (salvo al finalizar la ejecución).
Cualquier sentencia CICS debe escribirse entre las etiquetas EXEC CICS y END-EXEC.

Se trata de un programa ONLINE, por lo que ya no hay que usar un JOB para ejecutarlo. Ahora necesitaremos una transacción CICS.

Dependiendo de vuestro sistema, habrá una u otra manera de dar de alta una nueva transacción CICS, que tenga asociado nuestro programa de pruebas. Incluso es probable que muchos de vosotros no tengáis permisos para poder darla de alta en vuestro trabajo.
Para aquellos que tengáis Hércules instalado en vuestro PC de casa, ahí va como generarla:

Transacción CEDA

La transacción CEDA es una transacción del sistema (como la CEMT) que nos permitirá definir nuestra transacción CICS. Una transacción a efectos prácticos, es un código de 4 dígitos que lleva asociado un programa (ya sea COBOL, PL/I, ensamblador...), de tal manera que si la consultamos desde CEMT I TRANS nos mostrará lo siguiente:

Para definirla entraremos en nuestra sesión de CICS y escribiremos CEDA. Nos mostrará la siguiente lista:

Aquí elegimos Define, pues vamos a definir algo nuevo:

Y aquí elegimos Transaction, pues vamos a definir una transacción:

Los campos que debemos rellenar son:
Transaction
Group
Description
Program

Una vez definida la transacción tendremos que hacer lo mismo para el programa:

Y rellenaremos los datos:
Program
Group
Description
Language

Terminada la definición, pasamos a la instalación:
CEDA INSTALL TRANS(ACCQ)
Se debe rellenar el campo Group.

CEDA INSTALL PROG(PGMCICS1)
Se debe rellenar el campo Group.

Hecho esto, ya podemos empezar a codificar nuestro programa.
Nota: Si tenéis algún problema dando de alta la transacción, dejad un comentario y lo vemos.

PROGRAMA:
Por tratarse de un programa COBOL/CICS, tendrá la misma estructura que un programa cobol normal, simplemente incluiremos algunas sentencias CICS en el código.

 IDENTIFICATION DIVISION.
 PROGRAM-ID. PGMCICS1.
 AUTHOR. CONSULTORIO COBOL.
*
*==========================================================*
* MI PRIMER PROGRAMA EN CICS *
* ENVIA UN SALUDO PERSONALIZADO *
*==========================================================*
*
 ENVIRONMENT DIVISION.
*
 CONFIGURATION SECTION.
*
 SPECIAL-NAMES.
    DECIMAL-POINT IS COMMA.
*
 DATA DIVISION.
*
 WORKING-STORAGE SECTION.
*
 01 WX-PREGUNTA-NOMBRE.
    05 WX-PN.
       10 FILLER    PIC X(20) VALUE 'INTRODUCE TU NOMBRE:'.
       10 FILLER    PIC X(10) VALUE '__________'.

 01 WX-RESPUESTA.
    05 WX-RES1.
       10 FILLER    PIC X(3).
       10 FILLER    PIC X(20).
       10 WX-NOMBRE PIC X(10).

 01 WX-SALUDO       PIC X(30).
 01 WX-HOLA         PIC X(5)  VALUE 'HOLA '.
 01 WX-RESTO-SALUDO PIC X(17) VALUE '! YO SOY EL CICS.'.
*
***********************************************************
 PROCEDURE DIVISION.
***********************************************************
*  | 0000 - PRINCIPAL
*--|------------------+----------><----------+-------------* 
* 1| EJECUTA EL INICIO DEL PROGRAMA 
* 2| EJECUTA EL PROCESO DEL PROGRAMA 
* 3| EJECUTA EL FINAL DEL PROGRAMA ************************************************************
 0000-PRINCIPAL. 
* 
     PERFORM 1000-INICIO 
     PERFORM 2000-PROCESO 
     PERFORM 3000-FINAL 
     . 
* 
************************************************************ 
*  | 10000 - INICIO 
*--|------------+----------><----------+-------------------* 
*  | SE REALIZA EL TRATAMIENTO DE INICIO: 
* 1| INICIALIZACIóN DE ÁREAS DE TRABAJO 
* 2| PRIMERA LECTURA DE SYSIN ************************************************************ 
 1000-INICIO.
*
     INITIALIZE WX-RESPUESTA 
                WX-SALUDO 
     . 
* 
************************************************************ 
*  | 20000 - PROCESO 
*--|------------------+----------><------------------------* 
*  | SE REALIZA EL TRATAMIENTO DE LOS DATOS: 
* 1| REALIZA EL TRATAMIENTO DE CADA REGISTRO RECUPERADO DE 
*  | LA ENTRADA ************************************************************ 
 2000-PROCESO. 
*
     PERFORM 2100-PEDIR-DATOS 
     PERFORM 2200-ENVIA-SALUDO 
     . 
* 
************************************************************ 
* 2100 PEDIR DATOS 
*--|------------------+----------><----------+-------------* 
* ENVIA UN MENSAJE A LA PANTALLA ************************************************************
 2100-PEDIR-DATOS. 
* POSICIONAMOS EL CURSOR EN LA POSICION 21 
     MOVE 21   TO EIBCPOSN 
*
* ENVIAMOS UN TEXTO A LA VENTANA 
     EXEC CICS SEND TEXT 

               FROM (WX-PREGUNTA-NOMBRE) 

               ERASE 
               CURSOR (EIBCPOSN) 

               LENGTH (LENGTH OF WX-PREGUNTA-NOMBRE) 

     END-EXEC 

* 
* RECOGEMOS LA RESPUESTA EN WX-RESPUESTA 
* 
     EXEC CICS RECEIVE 

               INTO (WX-RESPUESTA) 

               LENGTH (LENGTH OF WX-RESPUESTA) 

     END-EXEC 

     .
*
************************************************************ 
* 2200 ENVIAMOS SALUDO 
*--|------------------+----------><----------+-------------* 
* FORMATEA EL NOMBRE PARA QUITAR LOS GUIONES BAJOS 
* ENVIA EL SALUDO PERSONALIZADO A LA PANTALLA 
************************************************************ 
 2200-ENVIA-SALUDO. 
* 
     INSPECT WX-NOMBRE REPLACING ALL '_' BY SPACES 

     STRING WX-HOLA DELIMITED BY SIZE 
            WX-NOMBRE DELIMITED BY SPACES 
            WX-RESTO-SALUDO DELIMITED BY SIZE 
       INTO WX-SALUDO 

     EXEC CICS SEND TEXT 

               FROM (WX-SALUDO) 

               ERASE LENGTH (LENGTH OF WX-SALUDO) 

     END-EXEC 
     . 
* 
************************************************************ 
*  | 30000 - FINAL 
*--|------------------+----------><----------+-------------* 
*  | FINALIZA LA EJECUCION DEL PROGRAMA Y DEVUELVE EL 
*  | CONTROL AL CICS 
************************************************************ 
 3000-FINAL. 
* 
     EXEC CICS RETURN 

     END-EXEC

     . 
*

En el programa podemos ver las siguientes divisiones/secciones:
IDENTIFICATION DIVISION: existirá siempre.
ENVIRONMENT DIVISION: existirá siempre.
  CONFIGURATION SECTION: existirá siempre.
  INPUT-OUTPUT SECTION: en este ejemplo no exisitrá porque no vamos a usar ficheros.
DATA DIVISION: existirá siempre.
  FILE SECTION: en este ejemplo no exisitrá porque no vamos a usar ficheros.
  WORKING-STORAGE SECTION: exisitirá siempre.
  En este caso NO exisistirá la LINKAGE SECTION pues se trata de un programa conversacional en el que el CICS inmobiliza áreas de memoria para guardar los datos intercambiados.
PROCEDURE DIVISION: exisitirá siempre.


En el programa podemos ver las siguientes sentencias:
PERFORM: llamada a párrafo
INITIALIZE: para inicializar variable
MOVE/TO: movemos la información de un campo a otro.
EXEC CICS/END-EXEC: Etiquetas entre las que se codifica una sentencia CICS
SEND TEXT: envía un mensaje de texto al CICS.
RECEIVE: recibe un mensaje de texto desde el CICS.
INSPECT/REPLACING: recorre todos los caracteres de una cadena sustituyendo el carácter indicado en "ALL" por el carácter indicado en "BY".
STRING/INTO: concatena los campos indicados en STRING y los guarda en la variable indicada en INTO. La explicación completa en PROCEDURE DIVISION: proceso del programa.
RETURN: Sentencia de finalización de ejecución. Devuelve el control al CICS.

Descripción del programa:
En el inicio del programa, inicializamos las variables de trabajo WX-RESPUESTA y WX-SALUDO.

En el proceso tenemos los siguientes párrafos:
2100-PEDIR-DATOS.
En este párrafo colocamos el cursor en la posición 21, posición donde empieza la línea para escribir el nombre, informando la variable EIBCPOSN con un 21.
Enviamos el mensaje WX-PREGUNTA-NOMBRE a la ventana con la instrucción SEND TEXT.
En "FROM" indicamos la variable que contiene el texto, en este caso WX-PREGUNTA-NOMBRE.
ERASE limpia la pantalla.
CURSOR posiciona el cursor en la posición indicada en EIBCPOSN.
En LENGTH indicamos la longitud del texto a enviar con "LENGTH OF".

Recogemos la información de la pantalla con la sentencia RECEIVE.
En "INTO" indicamos la variable donde guardaremos la información.
En LENGTH indicamos la longitud de la variable con "LENGTH OF".

2200-ENVIA-SALUDO.
En este párrafo formateamos el mensaje recibido:
INTRODUCE TU NOMBRE:TALLI______
En WX-NOMBRE tendremos el texto "TALLI______". La sentencia INSPECT WX-NOMBRE recorrerá todos los caracteres almacenados en WX-NOMBRE. La sentencia REPLACING ALL '_' BY SPACES sustiruitá todos los guiones bajos por espacios, quedándonos en WX-NOMBRE el texto "TALLI      ".

Con la sentencia STRING concatenaremos el texto "HOLA ", WX-NOMBRE, y "! YO SOY EL CICS." dentro de la variable WX-SALUDO. Con DELIMITED BY SPACES eliminamos los espacios sobrantes en WX-NOMBRE.

Ahora con un nuevo SEND TEXT enviamos WX-SALUDO a la pantalla.

En el párrafo de final codificamos la sentencia CICS RETURN que finaliza la ejecución y devuelve el control al CICS.

Nota para usuarios de Hércules: para que CICS coja la última compilación de nuestro programa (si hemos compilado más de una vez) debemos "refrescarla" desde CEMT:
CEMT SET PROG(PGMCICS1) NEW

RESULTADO:
Ejecutamos el programa escribiendo el código de la transacción y pulsando Intro:

Se muestra el mensaje:

Introducimos nuestro nombre y pulsamos Intro:

Se muestra el saludo:

Como veis esto es una chorrada de programa^^ pero hay que empezar por lo fácil.
En próximos artículos veremos como actualizar ficheros indexados desde un programa COBOL/CICS conversacional. Más adelante veremos el uso de mapas para dar formato a la ventana. Paciencia!

Como siempre, cualquier duda que tengáis... dejad un comentario : )