Professional Documents
Culture Documents
desde 0.
José Navero
Este documento trata de explicar que es un Jcl y
como construir uno a un nivel muy básico.
Posteriormente habrá más entregas con diferentes
utilities que profundizará más el tema
http://www.namocode.com
http://devthisblog.wordpress.com/
http://www.namocode.com
http://devthisblog.wordpress
.com/
Índice
A. Introdución ........................................................................................................ 3
B. Primer programa, HOLA MUNDO… ................................................................ 4
Explicación paso a paso ............................................................................................. 5
Primer ejemplo y comentarios .................................................................................... 7
C. Data Set con MainFrame, “DSN” ...................................................................... 9
Introducción: .......................................................................................................... 9
DISP .......................................................................................................................... 9
SPACE .................................................................................................................... 10
UNIT ....................................................................................................................... 11
DCB ........................................................................................................................ 12
VOL ........................................................................................................................ 12
D. Características especiales de JCLS................................................................... 15
1. SYSIN .............................................................................................................. 15
2. DUMMY o DSN = NULLFILE ........................................................................ 15
3. Concatenación de data Sets ............................................................................... 15
3. Parámetro SysOut ............................................................................................. 16
4. Parámetro SYSUDUMP y SYSABEND ........................................................... 16
E. Diferentes tipos de JCLS. ................................................................................ 17
1. JCL de Ordenación: ..................................................................................... 17
2. JCL de Transferencias: ................................................................................ 19
F. ANEXO I: Data set Utilities (librerías) de JCLs. .............................................. 20
G. Bibliografía. .................................................................................................... 21
2
http://www.namocode.com
http://devthisblog.wordpress
.com/
A. Introdución
Job Control Languaje (JCL), Es un lenguaje de programación que realiza tareas del
sistema operativo generalmente usado en Mainframe. Podríamos decir que es un tipo de
lenguaje Script.
Según Wikipedia: “Mediante declaraciones y sentencias de JCL se informa al
sistema operativo de las tareas (por lotes o Bach) que debe realizar, la secuenciación de
las mismas y los contenedores de datos de entrada y salida (ficheros) para cada uno de
los trabajos a ejecutar. Proporciona un alto grado de flexibilidad e independencia
respecto de la localización física de los ficheros y de los programas.”
NOTA:
Este manual no pretende sustituir ningún otro, simplemente, es un intento de aclarar
otros manuales que me costó seguir, por otro lado, este manual es una versión beta, por
lo que se irá actualizando con el paso del tiempo
3
http://www.namocode.com
http://devthisblog.wordpress
.com/
B. Primer programa, HOLA MUNDO…
Buscando por Internet, he encontrado un hola mundo en JCL, por lo que voy a
plasmar dicho código y pasare a documentarlo de la mejor forma posible, esto nos
servirá para poder ver una breve introducción.
4
http://www.namocode.com
http://devthisblog.wordpress
.com/
No os asustéis, como se puede ver, es un poco diferente a todo lo que has podido ver
con anterioridad. Paso a explicar cada una de las líneas.
Estas sentencias están especificadas en uno (MVC JCL User’s Guide de IBM).
Las // indican un comando o la finalización del JCL, todos los JCL finalizan con
una //
Por otro lado //* indica un comentario mientras que /* son delimitadores.
JOB:
Marca el principio del trabajo, asignándole un nombre de trabajo además de dar
información como criterios de contabilidad “accounting” (Parámetros posicionales).
EXEC:
Marca el principio de un paso dándole el nombre de este paso que identifica
dicho paso. Cada JOB puede tener uno o más EXECs.
DD:
Identifican y describen los ficheros de entrada y salida que serán usados en los
pasos. Cada EXEC tiene uno o más DDs.
Los posicionales, respetan un orden mientras que los de palabras clave, no.
Linea 1: //HMUNJOB JOB 'JNAVERO', CLASS=E, MSGCLASS=X,
Linea 2: MSGLEVEL=(1,0),REGION=256K
Accounting:
Es el primer parámetro posicional (y opcional). Este código es con lo que se
identifica al JOB y podemos obtener información sobre los recursos que consume.
5
http://www.namocode.com
http://devthisblog.wordpress
.com/
CLASS:
Asigna un JOB a una clase determinada para su ejecución. Depende de las
características del JOB.
MSGCLASS:
Se usa para asignar el JOB a una clase de salida
MSGLEVEL:
Mediante dos sub-parámetros posicionales (van entre paréntesis) que como veis
se separan asimismo por comas, indican que queremos todos los mensajes JCL que se
generen en el sistema (el primer 1) y luego, que también queremos los mensajes
relacionados si reservamos o “allocamos” ficheros que vaya a usar el job (el segundo 1).
Si sólo quisiéramos los mensajes JCL, el MSGLEVEL quedaría así: MSGLEVEL(1,0).
REGION:
Asigna la capacidad de almacenamiento (espacio) Central o virtual que requiere
el JOB.
Linea 3: //PASO1 EXEC PGM=IEBGENER
En este caso, IEBGENER tiene una serie de parámetros que se satisfacen en las
líneas siguientes y paso a explicar a continuación.
DD:
Especifica un data set y especifica los recursos necesarios de entrada y salida
que nuestro data set necesite. Posteriormente se pueden especificar multitud de
parámetros. Paso a describir los que tenemos aquí:
6
http://www.namocode.com
http://devthisblog.wordpress
.com/
DUMMY:
Se utiliza este parámetro para no reservar espacio en la memoria es como decir
en Linux que algo se copie a /dev/null, Se verá con mas detalle.
SYSOUT = A:
Define este data ser como un data set de salida y asigna la clase de salida,
procesos externos de escritura, impresiones identificadas etc.
SYSUT1:
Indica desde donde se van a copiar los datos. Posteriormente vemos DD que es
la definición de los datos, es decir, como si fuésemos a declarar una variable.
SYSUT2:
Indica hacia donde se copiaran los datos.
SYSIN:
Son parámetros opcionales que indican hacia donde se copiarán dichos datos
SYSPRINT:
Indica la salida del resultado de esos parámetros adicionales.
Como podemos ver y como hemos visto en el ejemplo del hola mundo este no es
muy diferente del anterior. Comienzo destripando este JCL comentándolo línea a línea
ya que creo que es la mejor forma de aprender poco a poco, o como me dirían y me
dicen últimamente ladrillito a ladrillito.
7
http://www.namocode.com
http://devthisblog.wordpress
.com/
En la siguiente línea:
//DELETE EXEC PGM=IDCAMS
Vemos el nombre del paso (Delete) que ejecuta una librería (PGM = ) la librería
afectada en este caso es IDCAMS.
//SYSPRINT DD SYSOUT=*
//SYSIN DD *
SYSIN: Indica que lo que va a continuacion serán los parámetros de entrada que
se usaran la utiliti IDCAMS. En este caso el DELETE
Mientras que SYSPRINT muestra la salida del JCL (generalmente por pantalla).
8
http://www.namocode.com
http://devthisblog.wordpress
.com/
Introducción:
Un data set es una colección de registros (como una base de datos). Los utiliza
y/o los puede generar cualquier programa. Hay dos tipos de data set, Secuenciales y
particionados. Los secuenciales, no requieren explicación (el típico ejemplo es una cinta
de casset) y los particionados, que es como un contenedor que contiene varios data set
secuenciales.
Como vemos SYSUT1 tiene una definición que apunta a un DSN (data set
name). Si en vez de un data set normal (como este caso) fuese un data set particionado,
solo cambiaria en esto: FICHERO.NOM_DATASET(ARCHIVO).
De esa forma tendríamos el contenedor y dentro el data set que hace referencia.
DISP
DISP=SHR
Para un data set que existe y que solo lo voy a leer (SHR de Shared es porque
como solo lo leo, muchos otros pueden leerlo también).
DISP=OLD
Para un data set que existe y que voy a re-escribir/cambiar/borrar.
DISP=MOD
Para un data set al que le quiero añadir nueva información al final, no cambiando
la existente.
9
http://www.namocode.com
http://devthisblog.wordpress
.com/
DISP=NEW
Para un data set que crearé nuevo en ese paso.
El segundo sub-parámetro sirve para saber que hacer con ese data set cuando el
paso termine. Puede tener los siguientes valores:
KEEP
Deja el data set como está.
CATLG:
Deja el data set como esta y lo cataloga en el catalogo correspondiente.
UNCATLG:
Si el data set termina anormalmente le sistema lo borra.
PASS:
Deja el fichero como esta, pero la decisión de que hacer con él lo decidirá el
siguiente paso.
DELETE:
Borra el data set del disco y del catalogo
El tercer parámetro se utiliza para indicar que hacer si el job deja de funcionar,
tiene los mismos valores que el segundo por ejemplo: DISP=(NEW,CATLG,CATLG)
En este ejemplo le indicamos que nos cree un fichero, lo catalogue funcione o no el jcl.
SPACE
Todo lo que viene entre paréntesis puede ser omitido. Paso a explicar esto que
aunque parece complejo, no lo es (casi)
Metric:
Se refiere a la forma en la que se almacena el espacio, pueden ser:
TRK: Indica el espacio a reservar en pistas (tracks)
CYL: Indica el espacio a reservar en cilindros (cylinders)
Blklgth: Indica el espacio a reservar en longitud de bloques.
Reclgth: Indica el espacio a reservar en longitud de registros.
10
http://www.namocode.com
http://devthisblog.wordpress
.com/
Primary-qty:
Especifica una de las siguientes:
Para TRK, el numero de pistas a reservar
Para CYL, el numero de cilindros a reservar
Para la longitud de un bloque, el numero de datos del bloque en el data set
Para la longitud de un registro, el numero de registros nuevos en el data set
Second-qty:
Especifica un espacio adicional de pistas, cilindros, bloques o registros.
Directory:
Especifica el numero de de registros de 256 bytes necesarios en el directorio de
un data set particionado.
Nota: Cuando se crea un data set particionado, se debe reservar el espacio para el
directorio
RSLE:
Solicita el espacio reservado para la salida del data set, pero no se usa, este es
liberado cuando el data set se cierra. Este parámetro de liberación parcial causa el cierre
de la función que libera el espacio no usado solo si el data set es abierto en modo de
escritura y la ultima operación no hizo lecturas.
CONTIG:
Indica que el espacio reservado para el data set debe ser contiguo, solo afecta al
primero parámetro de reserva de espacio.
Veamos un ejemplo de este sub-parámetro.
SPACE=(CYL,(10,,10),,CONTIG)
En este caso, el sistema, reserva 10 cilindros para el data set con 10 registros de
256byte para Un directorio. El último parámetro (Contig) indica que reserve los 10
cilindros de forma contigua (seguidos).
//CCH10081 DD DSN=USUARIO.fichero.file,
// UNIT=SYSDA,
// DCB=(LRECL=9999,RECFM=FB,BLKSIZE=0,DSORG=PS),
// SPACE=(9999,(100,10),RLSE),
// DISP=(NEW,CATLG,CATLG)
UNIT
Especifica el sistema de almacenamiento. Generalmente se usa SYSDA que
indica cualquier disco físico de almacenamiento.
11
http://www.namocode.com
http://devthisblog.wordpress
.com/
DCB
Data control block.
VOL
Este parámetro se usa para identificar el número de serie del volumen donde residirán
los dataset.
12
http://www.namocode.com
http://devthisblog.wordpress
.com/
Una vez visto los campos de los JCLs, vamos a ver algunos ejemplos de JCLs.
Jcl de ejecución de un programa
Pasamos a comentar este JCL para que podamos entenderlo y veamos que
realmente es más sencillo de lo que parece a simple vista.
Estas, nos indica que leerá un archivo ya catalogado (fichero de entrada) que se
le pasará a nuestra aplicación de Cobol, además vemos que la disposición a este fichero
es SHR es decir compartida, por lo que otros usuarios podrán acceder al mismo tiempo
que nosotros.
13
http://www.namocode.com
http://devthisblog.wordpress
.com/
Por otro lado el siguiente DSN. USUARIO.ARCHIVO.SALIDA, se puede ver que
vamos a crear un nuevo fichero con new además nos lo catalogará funcione nuestro
programa o no, de error o no, siempre estará en el catalogo.
Para finalizar, comentar que se almacenará en SYSDA que como se dijo
anteriormente es el primer dispositivo libre que haya ademas de usar un control del
bloque para el fichero (DCB).
//SYSTSIN DD *
DSN SYSTEM(DSN)
RUN PROGRAM(CUALQUIERA) PLAN(PLAN)
END
/*
14
http://www.namocode.com
http://devthisblog.wordpress
.com/
A continuación pongo algunas de las características que tienen los JCLs que me
he encontrado por ahí, es posible que haya más, pero, yo hago esta diferenciación,
siempre basándome en mi desconocimiento pero con la ayuda del libro gordo de IBM…
1. SYSIN
Esto no aparece en ningún JCL de los que hemos visto anteriormente, pero me
he encontrado esto en una función que he hecho recientemente. No es ni más ni menos
que parámetros de entrada a una aplicación Cobol. Le podemos pasar tantos como
queramos y en nuestra aplicación debemos leer tantos como queramos. Lo mejor es ver
un ejemplo para comprenderlo rápidamente.
Debemos tener nuestras variables definidas en Cobol. Para asignar recoger estas
variable debemos hacer un ACCEPT por cada variable de Sysin que tengamos
Esto asignaría nuestras variables del JCL a nuestra aplicación. En nuestro JCL
debemos añadir la siguiente línea:
//SYSIN DD *
Parametro1
Parametro2
Los dos parámetros los pasaremos a nuestro programa de cobol que podremos
almacenar en variables, tablas internas y las podremos tratas como más nos guste.
Algunas veces necesitamos testear programas sin data set. Podemos usar
DUMMY o DSN = NULLFILE si lo que deseamos es pasarle un valor nulo sin archivos
de entrada o salida, o bien para generar algún tipo de error o por cualquier otro motivo.
Cuando usamos estos valores, el sistema simula la presencia de un fichero. Cuando se
lea el fichero, el sistema enviara un final de fichero. Ya hemos visto parte del
funcionamiento en el hola mundo de JCL en las primeras páginas.
Como dice el titulo, podemos concatenar diferentes ficheros en otro. Todos los
data set concatenados deben ser del mismo tipo. Por ejemplo los data set particionados
solo se pueden concatenar con otros data set particionados.
15
http://www.namocode.com
http://devthisblog.wordpress
.com/
Un ejemplo de esta concatenación puede ser el siguiente:
3. Parámetro SysOut
Por lo que he visto en el manual de ibm, se usan para contener varios registros,
variables, data set y son usados en caso de terminar de forma anormal el sistema
produce un Gump (vuelco) de cierta información.
16
http://www.namocode.com
http://devthisblog.wordpress
.com/
En este capítulo voy a tratar los diferentes tipos de JCls que me he encontrado,
no son muchos de momento, pero, poco a poco confío en ir ampliando este capítulo.
1. JCL de Ordenación:
Lo mejor es poner un JCL de ordenación y comentarlo para que se vea cómo
funciona…
El fragmento del JCL que nos interesa, sería algo como esto:
//***************************************************************
//* ORDENACION DEL FICHERO TEMPORAL *
//***************************************************************
//SORT EXEC PGM=SORT
//SYSPRINT DD SYSOUT=*
//SYSUDUMP DD SYSOUT=*
//SYSDBOUT DD SYSOUT=*
//SYSABOUT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//*
//SORTIN DD DSN=Fichero_Entrada,
// DISP=SHR
//SORTOUT DD DSN=Fichero_Salida,
// DISP=(NEW,CATLG,CATLG),
// UNIT=SYSDA,
// SPACE=(1940,(7000,10000),RLSE),
// DCB=(LRECL=1940,RECFM=FB,BLKSIZE=0,DSORG=PS)
//*
//SORTWK01 DD UNIT=SYSDA,
// SPACE=(TRK,(10,20))
//SORTWK02 DD UNIT=SYSDA,
// SPACE=(TRK,(10,20))
//SORTWK03 DD UNIT=SYSDA,
// SPACE=(TRK,(10,20))
//SYSIN DD *
SORT FIELDS=(1,3,CH,A,6,3,CH,A)
OUTREC FIELDS=(1,1940)
17
http://www.namocode.com
http://devthisblog.wordpress
.com/
El fichero resultado sería algo así:
Explicación:
La sintaxis de SORT para ordenar registros depende de las palabras que nosotros
le pasamos como parámetros (Podemos usar dos campos principales para realizar la
ordenación)
En nuestro ejemplo:
SORT FIELDS=(1,3,CH,A,6,3,CH,A)
CH: indica que son caracteres. Podemos usar BI para campos binarios.
A: es el orden, en este caso ascendente.
18
http://www.namocode.com
http://devthisblog.wordpress
.com/
2. JCL de Transferencias:
El JCL que a continuación se explica, sirve para realizar la transferencia de
ficheros entre diferentes entornos o diferentes usuarios dentro del mismo entorno.
Este JCL es un ejemplo para realizar FTP. Paso a describir las diferentes
opciones que se pueden realizar:
19
http://www.namocode.com
http://devthisblog.wordpress
.com/
F. ANEXO I: Data set Utilities (librerías) de JCLs.
IDCAMS:
Métodos de acceso a servicios ("Access Method Services”). Genera y modifica
data set VSAM y No VSAM. La referencia del método de acceso deriva inicialmente
del VSAM reemplazando todos los demás métodos como los del OS/VS.
IEBCOMPR:
Esta utilidad se usa para comparar dos registros secuenciales o en data set
particionados, durante el proceso IEBCOMPR compara cada registro de cada data set
uno a uno.
Ejemplo:
IEBCOPY:
Copia y fusiona data sets particionados. Puede seleccionar o excluir miembros
especificados durante la operación de copiado además de reemplazar o renombrar
miembros del data set.
Ejemplo:
//stepname EXEC PGM=IEBCOPY
//SYSPRINT DD SYSOUT=class
//MYDD1 DD DSN=xxxx.ppp.psps,DISP=shr
//MYDD2 DD DSN=xxxx.ppp.pssp,DISP=shr
//SYSIN DD *
COPY INDD=MYDD1,
OUTDD=MYDD2
SELECT MEMBER=(mem1,mem2,mem3)/ EXCLUDE member=(sf,df,sa)
/*
//
IEBGENER:
Utilizado para copiar, crear o imprimir ficheros secuenciales y / o
particionados. También para manipular su contenido.
IEBDG:
Crea data sets con un patrón de datos. Usado para realizar pruebas
20
http://www.namocode.com
http://devthisblog.wordpress
.com/
G. Bibliografía.
21