JCL Básico IV: Sentencia DD (Parte II)

Continuamos con la segunda parte de este artículo. Vamos a hablar ahora de los diferentes parámetros que puede tener la sentencia DD. Los parámetros pueden ser de dos tipos, posicionales o de palabras clave. Vamos a ver ambos por separado:

PARÁMETROS POSICIONALES:
Asterisco *
El asterisco evita tener que definir un fichero, únicamente indicaremos los datos. La finalización de datos se indica con ( /* ) o con ( // ). Por ejemplo:

//PAS01 EXEC PGM=MIPROGRAMA
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//ENTRADA2 DD *
AQUI_ESCRIBIMOS_LOS_DATOS_DE_ENTRADA2
//SALIDA1  DD DSN=xxxx.nombre.fichero3,
//            DISP=(NEW,CATLG,DELETE),...


Otra utilidad es en los SORT:
//SYSIN DD *
SORT FIELDS=(1,4,CH,A)
/*


DATA
Similar al asterisco con la diferencia de que la finalización de datos se indica con el delimitador /*.

NOTA: Aunque poco usado, este delimitador puede ser modificado para no llevarnos a confusión.
Indicando DLM='##', sustituimos el delimitador /* por el ##. Sirve también para el parámetro asterisco *
Ejemplo de uso:

//PAS01 EXEC PGM=MIPROGRAMA
//SYSIN DD DATA,DLM=‘##’
SORT FIELDS=(1,1,CH,A)
##--> Delimitador modificado


DUMMY
Indica un fichero ficticio. El jcl tratará este fichero como si fuera real pero no
leerá o escribirá ningun dato sobre él. Muy útil cuando se quiere ejecutar un job sin generar algún fichero que no nos interese.

Aclaraciones: El programa utilizado ha de realizar el open y el close como si de un fichero real se tratara. En el siguiente ejemplo se ejecuta el programa MIPROGRAMA del mismo modo que lo haría normalmente, pero en el fichero de SALIDA1 no se obtendrán datos, sin embargo el funcionamiento del programa será exactamente el mismo.

//PAS01 EXEC PGM=MIPROGRAMA
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//SALIDA1  DD DUMMY
//SALIDA2  DD DSN=xxxx.nombre.fichero3,
//            DISP=(NEW,CATLG,DELETE),...


DYNAM
Sirve para asignar memoria dinámica a nuestro paso. Pondremos tantas DD DYNAM como
ficheros tengamos. Si no la indicamos el jcl se sirve de la memoria dinámica indicada en la sentencia EXEC con el DYNAMNBR. Pero también se pueden combinar ambas utilidades.
Veamos 3 posibles ejemplos prácticos(los 3 asignan la misma memoria, dejo a vuestra elección el que más os guste):

//PAS01 EXEC PGM=MIPROGRAMA
//DD1 DD DYNAM
//DD2 DD DYNAM
//DD3 DD DYNAM
//DD4 DD DYNAM
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//SALIDA1  DD DUMMY
//SALIDA2  DD DSN=xxxx.nombre.fichero3,
//            DISP=(NEW,CATLG,DELETE),...


//PAS01 EXEC PGM=MIPROGRAMA,DYNAMNBR=4
//DD1 DD DYNAM
//DD2 DD DYNAM
//DD3 DD DYNAM
//DD4 DD DYNAM
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//SALIDA1  DD DUMMY
//SALIDA2  DD DSN=xxxx.nombre.fichero3,
//            DISP=(NEW,CATLG,DELETE),...


//PAS01 EXEC PGM=MIPROGRAMA,DYNAMNBR=4
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//SALIDA1  DD DUMMY
//SALIDA2  DD DSN=xxxx.nombre.fichero3,
//            DISP=(NEW,CATLG,DELETE),...


PARÁMETROS PALABRAS CLAVE
Pueden codificarse en cualquier orden y son opcionales.

DDNAME
Funciona de forma similar a un procedimiento o copy. Tú defines una variable(por
ejemplo TEXTO) y almacenas en ella los datos que quieras. Después únicamente has de hacer una llamada (DDNAME=ENTR1) para utilizar ese texto. Se ve muy claro con un ejemplo:

//PAS01 EXEC PGM=MIPROGRAMA,DYNAMNBR=4
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//ENTRADA1 DD DDNAME=FICHERO2
//SALIDA1  DD DSN=xxxx.nombre.fichero2,
//            DISP=(NEW,CATLG,DELETE),...
...
...
//PAS01 EXEC FERPROC
//PASO01.FICHERO2 DD *
AQUI_ESCRIBIMOS_LOS_DATOS_DE_NUESTRO_FICHERO
/*


SYSOUT
Con ella indicas al jcl a qué cola enviar la salida.
Con SYSOUT=* la ejecución del jcl va a la cola que tengas indicada en el MSGCLASS de la cabecera.
Con SYSOUT=2 la ejecución del jcl va a la cola que el host considere que es la cola 2 (según la arquitectura donde nos encontremos variará).


COPIES
Indica el número de copias que queremos del fichero donde se indica. Hay un máximo de 255 copias.

//PAS01 EXEC PGM=MIPROGRAMA,DYNAMNBR=4
//SYSPRINT DD SYSOUT=2,COPIES=2
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//SALIDA1  DD DSN=xxxx.nombre.fichero2
//            DISP=(NEW,CATLG,DELETE),...
//SALIDA2  DD DSN=xxxx.nombre.fichero3,
//            DISP=(NEW,CATLG,DELETE),...


DEST
Sirve para indicar el destino del SYSOUT. Por ejemplo, con DEST=LOCAL la ejecución va al terminal por defecto de la instalación:

//PAS01 EXEC PGM=MIPROGRAMA,DYNAMNBR=4
//SYSPRINT DD SYSOUT=2,DEST=LOCAL
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//SALIDA1  DD DSN=xxxx.nombre.fichero2
//            DISP=(NEW,CATLG,DELETE),...
//SALIDA2  DD DSN=xxxx.nombre.fichero3,
//            DISP=(NEW,CATLG,DELETE),...


FREE
Este comando libera un fichero cuando el jcl no lo use y, de ese modo, que otro jcl lo pueda usar. Para los amantes del rendimiento, muy útil para evitar esperas innecesarias. Puede tener dos valores:
FREE=END --> el fichero se libera al terminar el paso donde se esté ejecutando
FREE=CLOSE --> el fichero se libera en cuanto el programa lo cierra


HOLD
Retiene la ejecución de la salida del jcl hasta que el operador de la consola lo
libera. Solo se usa en el SYSOUT. Si no se indica, por defecto está desactivado(HOLD=NO). Para activarlo: HOLD=YES.

//PAS01 EXEC PGM=MIPROGRAMA,DYNAMNBR=4
//SYSPRINT DD SYSOUT=2,HOLD=YES
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//SALIDA1  DD DSN=xxxx.nombre.fichero2
//            DISP=(NEW,CATLG,DELETE),...


UCS
Solo dejo reseñado lo que he leído sobre este comando, no sé muy bien como funciona pues nunca lo probé, pero si a alguien le sirve ahí va:
Sirve para indicar el juego de caracteres que utilizará la cola de impresión. Los posibles valores son:
UCS=indicar_Juego_de_Caracteres,FOLD,VERIFY

En juego de caracteres se indican los caracteres
FOLD - es opcional, permite modificar el juego de caracteres por otro(por ejemplo cambiar mayúsculas a minúsculas)
VERIFY - el operador verificará el juego de caracteres

//PAS01 EXEC PGM=MIPROGRAMA,DYNAMNBR=4
//SYSPRINT DD SYSOUT=2,UCS=(YN,,VERIFY)
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//SALIDA1  DD DSN=xxxx.nombre.fichero2
//            DISP=(NEW,CATLG,DELETE),...


OUTLIM
Sirve para indicar el número máximo de registros que saldrán en los ficheros de tipo SYSOUT. Muy útil para cuando tenemos muchos displays y se nos desborda la ejecución.

Por ejemplo con OUTLIM=1000 cuando la ejecución llegue a 1000 registros se para el job.

//PAS01 EXEC PGM=MIPROGRAMA,DYNAMNBR=4
//SYSPRINT DD SYSOUT=2,OUTLIM=1000
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//SALIDA1  DD DSN=xxxx.nombre.fichero2
//            DISP=(NEW,CATLG,DELETE),...


El valor máximo es 16777215. Si no se indica se considera ilimitado.

Hemos explicado los posibles parámetros en la ficha DD. En el próximo artículo explicaré algo mucho más interesante, los posibles parámetros para los ficheros de salida de nuestros pasos: cilindros, space, ficheros en cinta, longitudes de ficheros, etc...

JCL Básico IV: Sentencia DD (Parte I)

Sentencia que describe los ficheros con los que se va a trabajar (una sentencia DD por cada fichero). Identifica cada fichero lógico definido en la SELECT del programa con su fichero físico.
No puede existir mas de una sola DD identificada con el mismo nombre lógico.

//FICHERO1 DD DSN=xxxx.nombre.fichero
//            DISP=(NEW,CATLG,DELETE),VOL=SER=SYSWKl,
//            UNIT=3380,LABEL=3,SPACE=(TRK,(10,5),RLSE),
//            COPIES=4,DEST=RMT005,OUTLIM=1500,
//            RECFM=FB,LRECL=150,BLKSIZE=1500

La no especificación de nombre lógico en una ficha DD presupone la concatenación al fichero de la sentencia DD anterior. En ocasiones un paso puede precisar de mas de un fichero para una determinada entrada de datos y ello es posible por medio de la concatenación de DD.s. La forma en codificarse es:

//ENTRADA1 DD DSN=xxxx.nombre.fichero1,DISP=SHR
//         DD DSN=xxxx.nombre.fichero2,DISP=SHR
//SALIDA1  DD DSN=xxxx.nombre.fichero3,
//            DISP=(NEW,CATLG,DELETE),VOL=SER=SYSWKl,
//            UNIT=3380,LABEL=3,SPACE=(TRK,(10,5),RLSE),
//            COPIES=4,DEST=RMT005,OUTLIM=1500,
//            RECFM=FB,LRECL=150,BLKSIZE=1500

NOTA. En este caso ambos ficheros de entrada han de tener la misma longitud.

Anteriormente a este artículo he hablado de las líneas de la cabecera de un jcl y de las sentencias que ejecutan programas (EXEC). Podemos tener sentencias DD tanto en la cabecera como en cada uno de los pasos de nuestro jcl:

• Sentencias DD en la cabecera del jcl.
  Las únicas DD asociadas a la ficha JOB son aquellas destinadas a definir librerías de acceso a las que deberán acudir los trabajos en tiempo de ejecución. El nombre lógico que las identifica es:
  
  • JOBLIB --> La ejecución de un programa se inicia en la busca del objeto (código en lenguaje maquina) en las librerías estandars de la instalación (SYS1.LINKLIB) pero en según que casos puede sernos de utilidad el desplazar esa búsqueda a otras librerías.
    La especificación de una o varias librerías no evita en ultimo caso el acudir a las estandars de la instalación si no se encontrase en ninguna de las referidas.
    Ha de codificarse después de la ficha JOB y antes de cualquier paso EXEC.
    No puede utilizarse en procedimientos catalogados.
    La codificación de JOBLIB predispone a los pasos EXEC posteriores a que todos acudan a esas librerías para la obtención del objeto a ejecutar. Será excepción de lo dicho los pasos EXEC que dispongan de una DD STEPLIB en cuyo caso serán esas las librerías de captura.
  • JOBCAT --> La diferencia de la JOBCAT con la JOBLIB radica en que mientras la anterior buscaba el objeto a ejecutar, esta marca el camino a seguir para la búsqueda y obtención del catalogo de ficheros. sigue las mismas pautas y en ultimo extremo acude a las estancadas de la instalación.
    
    Ha de codificarse después de la ficha JOB y de la JOBLIB y antes de cualquier paso EXEC.
    La codificación de JOBCAT predispone a los pasos EXEC posteriores a que todos acudan a esas librerías para la obtención del catalogo de ficheros. Será excepción de lo dicho los pasos EXEC que dispongan de una DD STEPCAT en cuyo caso serán esas las librerías de catalogo.
  • SYSCHK --> Define el fichero de grabación de CHEKPOINTS (puntos de control) de un programa que se guardan para rearranque posterior.
    Debe ser anterior a cualquier paso EXEC de un JOB puesto que en rearranque y especificando la identificación del punto de control se deberá acudir a este fichero antes que al paso para obtener la información del programa que se pretende arrancar.

• Sentencias DD en cada paso (EXEC) del jcl.
  Destinadas a definir librerías de acceso a las que deberán acudir los pasos de un trabajos en tiempo de ejecución. El nombre lógico que las identifica es:
  
  • STEPLIB --> La ejecución de un programa se inicia en la busca del objeto (código en lenguaje maquina) en las librerías estándar de la instalación (SYS1.LINKLIB) pero en según que casos puede sernos de utilidad el desplazar esa búsqueda a otras librerías.
    La especificación de una o varias librerías no evita en ultimo caso el acudir a las stándar de la instalación si no se encontrase en ninguna de las referidas.
    Ha de codificarse después de la ficha EXEC aunque no tiene porque ser la primera DD
    A diferencia de la JOBLIB puede utilizarse en procedimientos catalogados.
    
    En el siguiente ejemplo, cuando se lance el job, éste buscará el ejecutable del programa PROGRAMA1 en la libreria1 y si no lo encuentra lo buscará en la librería2:
    
    //PASO01 EXEC PGM=PROGRAMA1
    //STEPLIB DD DSN=xxxx.nombre.libreria1,DISP=SHR
    //        DD DSN=xxxx.nombre.libreria2,DISP=SHR
    ...
    ...
    
    ¿Para que puede servir la STEPLIB? Son muchas las utilidades que tiene:
    Pongo un ejemplo:
    - Para pruebas en el entorno de explotación, imagina que quieres hacer una prueba de un programa que has creado pero que todavía no está subido al entorno de explotación, pero el cliente insiste en probarlo bien y no te queda otra que hacerlo con datos de explotación.
    SOLUCIÓN: Lo que debes hacer es dejar la compilación de tu programa en una librería a la que tengas acceso en el entorno de producción (una librería que hayas creado tú o alguna puente o de intercambio que exista, en muchas plataformas existe una librería preparada para este fin). Una vez copiado tu ejecutable en dicha librería, únicamente tienes que indicar en tu paso de jcl donde se ejecuta el programa, la STEPLIB del siguiente modo:
    
    //PASO01 EXEC PGM=MIPROGRAMA
    //STEPLIB DD DSN=xxxx.nombre.libreria1,DISP=SHR
    ...
    
    Cuando se ejecute el jcl, el programa "tirará" de la librería indicada en la STEPLIB.
    
    Pongo otro ejemplo:
    - Imagina que puntualmente se necesita modificar un programa durante un periodo en concreto. Por ejemplo, tienes un programa con información acerca de la velocidad máxima en las autovías (120 km/h). Pero resulta que de la noche a la mañana lo que creías que no iba a ocurrir ocurre, y es que la velocidad ha de ser bajada a 110 km/h durante un plazo determinado. Bien, lo normal sería modificar tu programa, implantarlo, y esperar a que dentro de X meses tengas que volver a modificar el programa para devolverlo a su estado original(120 km/h), con todo lo que eso conlleva, volver a bajar el programa, modificar, probar, implantar, etc....
    SOLUCIÓN: Modificas el programa para que admita los 110 km/h pero no lo implantas en producción sino que copias el ejecutable en una librería auxiliar(temporal, puente o como quieras llamarla). Luego, en el jcl que ejecuta tu programa, lo único que haces es añadir al paso una línea de STEPLIB donde indicas esa librería puente donde has dejado la compilación. De este modo durante los próximos meses tu jcl ejecutará la versión del programa que está preparada para los 110 km/h. Cuando la norma cambie y volvamos a poder "correr" en las carreteras a 120, únicamente has de quitar la línea del jcl, o bien borrar el programa modificado de la librería auxiliar (si el jcl no encuentra el programa en la librería indicada en la STEPLIB irá a buscarlo a la librería original).
  • STEPCAT --> La diferencia de la STEPCAT con la STEPLIB radica en que mientras la anterior buscaba el objeto a ejecutar, esta marca el camino a seguir para la búsqueda y obtención del catalogo de ficheros. sigue las mismas pautas y en ultimo extremo acude a las stándar de la instalación.
    
    Ha de codificarse después de la ficha EXEC aun que no tiene porque ser la primera DD.
    La sentencia STEPCAT solo puede referirse a catálogos de usuario del tipo VSAM.
  • SYSABEND --> Determina el fichero donde el sistema efectuara el vuelco de memoria por terminación anormal ABENDED. La información que aporta hace referencia a:
    Núcleo del sistema
    Área del programa problema
    Tabla de Trace
  • SYSUDUMP --> Determina el fichero donde el sistema efectuara el vuelco de memoria por terminación anormal ABENDED. A diferencia de la anterior tan solo facilita información del área del programa.
  • DUMMY --> representa un fichero ficticio, el programa lo abrirá, efectuará operaciones de E/S sobre el (ficticias), pero el sistema no dará error. Muy útil cuando no queremos que, por lo que sea, no queremos obtener el fichero de salida de un programa, ponemos el fichero a DUMMY y la ejecución será exactamente igual que si lo tuviéramos pero sin escribir nada en la salida.

La sentencia DD es bastante amplia, por lo tanto, continuaré con ella en el próximo artículo...(JCL Básico IV: Sentencia DD (Parte II)