Desarrollando en Cobol y Natural sobre Plataforma Mainframe

lunes, 3 de agosto de 2015

Utilidad ICETOOL para JCL. ¿Cómo usarla? (y 2)

Hace algunas semanas comenzamos a ver en qué consistía la utilidad ICETOOL de la herramienta ICEMAN. Se trata de un servicio que, en los JCL, simplifica enormemente la codificación de los pasos de ordenación, de copia o de cruce de registros de ficheros.

En la primera parte del post estuvimos viendo cuáles son las principales funciones que se pueden realizar con la utilidad ICETOOL (ver post Utilidad ICETOOL para JCL. ¿Cómo usarla? - 1). En esta segunda parte trataremos de explicar cómo se debe implementar un operador ICETOOL en un paso estándar de JCL.

¿Cómo se ejecuta la utilidad ICETOOL en un JCL?


Una vez expuestas las diferentes alternativas de las que disponemos con esta utilidad, nos quedaría pendiente ver cómo se podría desarrollar una función ICETOOL desde un JCL. En realidad, el empleo de esta herramienta en un paso JCL no tiene más dificultad añadida que la de cualquier otra utilidad clásica (tal como IEBGENER, IEBCOPY o DFSORT).

Para demostrarlo, vamos a incluir como ejemplo un fragmento de código con un paso JCL en el que se va a emplear la función COUNT de ICETOOL para contar el número de registros existentes en un fichero secuencial de entrada. Se trata del siguiente. 

//*    *********************************************     
//*    * PASO DE ICETOOL PARA CONTAR LOS REGISTROS *     
//*    *********************************************     
//JJ0101   EXEC PGM=ICETOOL                                         
//TOOLMSG  DD SYSOUT=*                                              
//DFSMSG   DD SYSOUT=*                                              
//INPUT    DD  DSN=SIST.UNLOAD.X0005X.DIA.POBL,           
//             DISP=SHR                                             
//OUT      DD  DSN=SIST.JJ0101S1.X0060X.DDD.FECHA.POBL,
//             DISP=(,CATLG,DELETE),                                
//             SPACE=(TRK,(00010,00010),RLSE),                      
//             UNIT=DISCO                                           
//TOOLIN   DD  DSN=SIST.SYSIN(CONTCT01),                      
//             DISP=SHR                                             
//CTL1CNTL DD  DSN=SIST.SYSIN(CONTCT02),                      
//             DISP=SHR                                             
//*
                                                                 

Las dos fichas asociadas a este paso JCL (denominadas CONTCT01 y CONTCT02), serían las siguientes. 

*------------------------------------------------------------*
* <<< FICHA TOOLIN CONTCT01 >>> 
* FICHA PARA REALIZAR EL COUNT DE LOS REGISTROS DE ENTRADA   *
*------------------------------------------------------------*
  COUNT FROM(INPUT) USING(CTL1) WRITE(OUT) TEXT('CONT: ')

*------------------------------------------------------------*
* <<< FICHA CONTROL CONTCT02 >>>
* FICHA PARA INDICAR LAS CONDICIONES DEL RECUENTO            *
*------------------------------------------------------------*
  INCLUDE COND=(48,1,CH,EQ,C'.')



Como vemos, para implementar una función ICETOOL en un JCL únicamente hay que incluir una serie de Fichas con un formato predefinido. A continuación, pasamos a repasarlas con un poco más de detalle.

1º) Invocación de ICETOOL: En la primera línea del paso tenemos que incluir la llamada a la utilidad ICETOOL. Esto se hace mediante una simple ejecución estándar del comando EXEC PGM. 

//JJ0101   EXEC PGM=ICETOOL

2º) Ficha INPUT: En esta declaración se debe incluir el nombre del fichero de entrada que va a ser empleado por la función ICETOOL (el  operador correspondiente a dicha función será definido más adelante). En nuestro ejemplo estamos usando el fichero SIST.UNLOAD.X0005X.DIA.POBL. 

//INPUT    DD  DSN=SIST.UNLOAD.X0005X.DIA.POBL, 
//             DISP=SHR



3º) Ficha OUT: De manera análoga a la ficha anterior, aquí tendremos que indicar el nombre que deseamos que tenga el fichero de salida que se va a crear al ejecutar la función ICETOOL correspondiente. En el ejemplo es el fichero SIST.JJ0101S1.X0060X.DDD.FECHA.POBL. 

//OUT      DD  DSN=SIST.JJ0101S1.X0060X.DDD.FECHA.POBL,
//             DISP=(,CATLG,DELETE),
//             SPACE=(TRK,(00010,00010),RLSE),
//             UNIT=DISCO

4º) Ficha TOOLIN: En esta ficha es en la que vamos a indicar cuál es la función ICETOOL que debe ejecutarse en nuestro paso. En el ejemplo se ha usado la función COUNT, pero también podría haberse empleado cualquiera de los 17 operadores que actualmente hay disponibles para la herramienta (COPY, MERGE, SORT, SPLICE, DISPLAY, etc…). 

  COUNT FROM(INPUT) USING(CTL1) WRITE(OUT) TEXT('CONT: ')

5º) Ficha de Control CTL1CNTL: Aquí se incluye la sentencia (o sentencias) de control asociada a la función ejecutada en la ficha anterior. En nuestro caso, el control INCLUDE COND=(48,1,CH,EQ,C’.’) está indicando que sólo se deben contar aquellos registros del fichero de entrada que en la posición 48 tengan un punto (‘.’). 

  INCLUDE COND=(48,1,CH,EQ,C'.')



Si implementamos todas las fichas anteriores tal y como se ha expuesto, no deberíamos tener ningún problema con la ejecución del paso TOOLIN. Obviamente, las primeras veces que trabajemos con esta herramienta nos resultará algo más complicado de lo que en realidad es, pero lo mismo ocurre con cualquier otra utilidad de cualquier otro lenguaje de programación.

Conclusiones de la utilidad ICETOOL de ICEMAN


En el ejemplo hemos podido ver cómo debería codificarse un paso JCL de recuento de registros mediante el comando COUNT de la utilidad ICETOOL de ICEMAN. Pero no exigiría mucho esfuerzo adicional implementar un paso de copia (COPY), de ordenación (SORT), de unión (MERGE) o de cruce de registros (SPLICE).



Tal y como puede apreciarse, la ventaja de esta herramienta es que nos permite realizar, en un mismo paso, varias acciones con ficheros, con el consiguiente ahorro de código y de tiempo. En el ejemplo comentado anteriormente se realizaron en un solo paso las siguientes acciones: 

- Filtrar los registros del fichero de entrada que tenían un determinado carácter en una posición definida.
- Contar el número de registros que cumplían con la anterior condición de filtrado.
- Y generar un fichero de salida con una línea de texto en la que se informa del resultado del recuento de registros.

En un JCL normal tendríamos que haber empleado tres pasos para ir realizando cada una de las acciones anteriores. Por tanto, incluso en un job tan sencillo, ya hemos conseguido algo de ahorro. En realidad, cuanto más compleja sea la funcionalidad a desarrollar en el JCL, mayor será el número de acciones que podremos incluir en un único paso ICETOOL y, por consiguiente, mayor será la optimización alcanzada.



Mi recomendación es que, si disponéis de ella en vuestra instalación, aprendáis a utilizar esta herramienta. En cuanto alcancéis un poco de agilidad con su manejo, agradeceréis la simplificación de pasos que se producirá en vuestros JCL. Si, a pesar de todo lo indicado, os sigue pareciendo más clara la forma clásica de implementar los pasos, obviamente podréis seguir codificando tal y como lo hacíais hasta ahora. Llegados a ese punto, se tratará de una decisión personal de cada programador.

Pues nada, espero que con todo lo comentado os haya quedado bastante claro cómo es el funcionamiento global de la herramienta ICETOOL y cuáles son las funciones que se pueden ejecutar con ella. Como ya sabéis, todas vuestras dudas serán bienvenidas en el apartado de comentarios de este post…

Saludos.

No hay comentarios:

Publicar un comentario

Related Posts Plugin for WordPress, Blogger...