Aprende Jcls Desde 0

Aprende Jcl
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://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
.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
.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.
//HMUNJOB JOB 'JNAVERO', CLASS=E, MSGCLASS=X,

// MSGLEVEL=(1,0),REGION=256K
//PASO1 EXEC PGM=IEBGENER
//SYSUT1 DD DATA,DLM=$$
/*******************************************************/
/* */
/* Hola, Mundo en JCL!! */
/* */
/*******************************************************/
$$
//SYSUT2 DD SYSOUT=A
//SYSPRINT DD SYSOUT=A
//SYSIN DD DUMMY
//
4
.com/
Explicación paso a paso
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.
Un JOB tiene un mínimo de 3 sentencias obligatorias y claramente diferenciadas

que son:
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.
Pasamos a analizar la primera línea:

Linea 1: //HMUNJOB JOB '@HMUNDO', CLASS=E, MSGCLASS=X, REGION=6M
Continuando con el JOB, existen 2 tipos de parámetros que se le pueden pasar al

JOB. Posicionales y de palabras clave.
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
La sintaxis del Job es la siguiente:
// nombrejob JOB accounting, nombre_programador, class, msgclass, region
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.
Nombre del programador:

Es el segundo parámetro y es donde se puede poner el nombre del programador
que ha realizado el JOB.
5
.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
Marca el principio del EXEC e indica que UTILITIES (librerías) vamos a

utilizar es el caso de PGM=IEBGENER, estas librerías, pueden estar definidas por una
empresa o por nosotros mismos, por este tipo de librerías nos es necesario reservar
memoria (como hicimos anteriormente con REGION)
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.
(En el Anexo A se explican brevemente algunas librerías)
Linea 4: //SYSUT1 DD DATA,DLM=$$

Linea 5: /*******************************************************/
Linea 6: /* */
Linea 7: /* Hola, Mundo en JCL!! */
Linea 8: /* */
Linea 9: /*******************************************************/
Linea 10: $$
Linea 11: //SYSUT2 DD SYSOUT=A
Linea 12: //SYSPRINT DD SYSOUT=A
Linea 13: //SYSIN DD DUMMY
Linea 14: //
Los parámetros de IEBGERNER Son los siguientes que explicare

posteriormente.
Sysut1, sysut2, sysprint y sysin
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
.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.
Por ultimo como ya indique anteriormente, la // final indica el final de JCL.
Primer ejemplo y comentarios
//@BORRADO JOB (999),'@BORRADO',CLASS=E,MSGCLASS=X,REGION=6M

//*
//*************************************************************
//* *
//* BORRADO PREVIO DE LOS FICHEROS *
//* *
//*************************************************************
//DELETE EXEC PGM=IDCAMS
//SYSPRINT DD SYSOUT=*
//SYSIN DD *
DELETE (-
PRUEBA.FICHERO1.SALIDA1 -
. . . . . . . . . . . - <--tantas lineas como fich. a borrar
PRUEBA.FICHERO1.SALIDA2 -
)
IF MAXCC < 9 THEN SET MAXCC = 0
/*
//** RESTO DEL JCL EN SU CASO
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.
La primera línea indica el JCL a ejecutar, @Borrado, la clase donde se ejecuta

(que es la cola de ejecución), también sabemos que las líneas que hay después son
comentarios de lo que hace el JCL, es decir, todo lo que esta entre //*.
7
.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.
Las líneas de continuación indican los parámetros necesarios para IDCAMS.
//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).
Según el JCL Reference de IBM, SYSOUT es un parámetro que especifica la clase

de salida. Cuando ponemos el sysout = * estamos especificando una clase de salida por
defecto.
8
.com/
C. Data Set con MainFrame, “DSN”
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.
Veamos un ejemplo e intentemos comprenderlo.

//TRABAJO1 JOB 'JNAVERO',URD,CLASS=E,MSGCLASS=A,
// MSGLEVEL=(1,1),REGION=256K
//PASO1 EXEC PGM=IEBGENER
//SYSUT1 DD DSN=USUARIO.FICHERO.NOM_DATASET,DISP=SHR
//SYSUT2 DD SYSOUT=A
//SYSPRINT DD SYSOUT=A
//SYSIN DD DUMMY
//
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.
Después de esto nos encontramos con DISP. Esto es la disposición en la que se

encuentra nuestro data set. Indica la disposición o bloqueo que vamos a realizar sobre
un DSN (fichero) en el momento de ejecutar el job.
DISP
Puede tener hasta tres sub-parámetros, el primero de los sub-parámetros es el

bloqueo del data set en la ejecución del job, existiendo las siguientes opciones:
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
.com/
DISP=NEW
Para un data set que crearé nuevo en ese paso.
En las ultimas 3 disposiciones, el bloqueo será exclusivo: mientras mi job este

en ejecución, ninguna otra persona podrá acceder a ese data set.
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.
Cuando se crea un data set, es necesario reservar el espacio que va a ocupar

dicho data set. Para ello, se usa el parámetro SPACE. Dicho parámetro tiene varios sub-
parámetros, viene a ser algo así:
SPACE
SPACE= ({Metric,}(primary-qty[,second-qty][,directory]) [,RLSE] [,CONTIG] )
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
.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).
A continuación pongo un ejemplo de un DNS completo así seguimos

avanzando…
//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)
De este ejemplo destacamos UNIT y DCB que veremos a continuación el resto

espero que se entienda, ya que se vio anteriormente, con esto sabremos crear un data set
UNIT
Especifica el sistema de almacenamiento. Generalmente se usa SYSDA que
indica cualquier disco físico de almacenamiento.
11
.com/
DCB
Data control block.
En el DCB especificaremos 3 cosas: Formato del registro (RECFM, RECord

ForMat), El tamaño del registro lógico (LRECL Logical RECord Length) y el tamaño
del bloque (BLKSIZE, BLocK SIZE). Usando un ejemplo, si decimos que tenemos un
data set con DCB=(RECFM=FB,LRECL=80,BLKSIZE=5600), le estamos diciendo que
nuestro data set tiene un tamaño de registro Fijo distribuido en Bloques (FB), cuya
longitud de registro lógico es de 80 bytes y que el tamaño del bloque utilizado es de
5600 bytes. El formato puede ser Fijo (F), Variable (V) y no especificado (U). Así
pues, si queremos que nuestro nuevo data set tenga ese tipo de disposición, añadimos al
JCL esa línea.
VOL
Este parámetro se usa para identificar el número de serie del volumen donde residirán
los dataset.
12
.com/
Una vez visto los campos de los JCLs, vamos a ver algunos ejemplos de JCLs.
Jcl de ejecución de un programa
//@EJECUTA JOB (999),'@EJECUTA',CLASS=E,MSGCLASS=X,REGION=6M

//*
//************************************************************
//* EJECUCION DEL PROGRAMA CUALQUIERA *
//************************************************************
//*
//PASO10 EXEC PGM=IKJEFT01,DYNAMNBR=5,REGION=6M
//STEPLIB DD DISP=SHR,DSN=LOADLIB
// DD DISP=SHR,DSN=PROGRAM.LOAD
//*
//ENTRADA DD DSN=USUARIO.ARCHIVO.ENTRADA1,
// DISP=SHR
//*
//SALIDA DD DSN=USUARIO.ARCHIVO.SALIDA,
// UNIT=SYSDA,
// SPACE=(9999,(100,10),RLSE),
//*
//SYSTSPRT DD SYSOUT=*
//SYSABEND DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSABOUT DD SYSOUT=*
//SYSUDUMP DD SYSOUT=*
//SYSTSIN DD *
DSN SYSTEM(DSN)
RUN PROGRAM(CUALQUIERA) PLAN(PLAN)
END
/*
Pasamos a comentar este JCL para que podamos entenderlo y veamos que
realmente es más sencillo de lo que parece a simple vista.
Linea 1: //@EJECUTA JOB (999),'@EJECUTA',CLASS=E,MSGCLASS=X,REGION=6M

 Inicio del JCL pasandole los parametros necesarios como vimos en las paginas 4 y 5
de este manual.
En este ejemplo, podemos ver las siguientes líneas:

//ENTRADA DD DSN=USUARIO.ARCHIVO.ENTRADA1,
// DISP=SHR
//*
//SALIDA DD DSN=USUARIO.ARCHIVO.SALIDA,
// UNIT=SYSDA,
// SPACE=(9999,(100,10),RLSE),
//*
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
.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).
En este JCL solo queda comentar esto:
//SYSTSIN DD *
DSN SYSTEM(DSN)
RUN PROGRAM(CUALQUIERA) PLAN(PLAN)
END
/*
Que no es ni más ni menos que se ejecute nuestro programa CUALQUIERA en un

plan determinado, en función del entorno donde se está ejecutando el mismo.
14
.com/
D. Características especiales de JCLS.
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
ACCEPT WS-VARIABLE1 FROM SYSIN

ACCEPT WS-VARIABLE2 FROM SYSIN
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.
2. DUMMY o DSN = NULLFILE
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.
3. Concatenación de data Sets
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
.com/
Un ejemplo de esta concatenación puede ser el siguiente:
//UNION EXEC PGM=IDCAMS

//ENTRADA DD DSN=fichero1,
// DISP=SHR
// DD DSN= fichero2,
// DISP=SHR
// DISP=SHR
// DISP=SHR
En el programa de cobol, recibiré una entrada que es la concatenación de los

cuatro ficheros con los que podremos operar sin ningún tipo de complicación
3. Parámetro SysOut
Este parámetro se utiliza para generar la salida de nuestra aplicación. Lo más

normal es que sea un fichero, pero también puede tratarse de la pantalla, la impresora o
cualquier otro dispositivo. Creo que no requiere una explicación mas detallada
4. Parámetro SYSUDUMP y SYSABEND
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
.com/
E. Diferentes tipos de JCLS.
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…
Suponemos un fichero de entrada sencillo: con tres campos
Nombre Dni Apellido

Bbbbbb 1111111 Ccccccc
CCCC 2222222 AAAAA
CCCC 1111111 BBBBB
FFFFF 333333 GGGGG
AAAAA 333222 BBBBBB
El fragmento del JCL que nos interesa, sería algo como esto:
//***************************************************************
//* ORDENACION DEL FICHERO TEMPORAL *
//***************************************************************
//SORT EXEC PGM=SORT
//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))
// SPACE=(TRK,(10,20))
// SPACE=(TRK,(10,20))
//SYSIN DD *
SORT FIELDS=(1,3,CH,A,6,3,CH,A)
OUTREC FIELDS=(1,1940)
17
.com/
El fichero resultado sería algo así:
Nombre Dni Apellido

AAAAAA 333222 BBBBBB
BBBBBB 111111 CCCCCC
CCCCCC 111111 BBBBBB
CCCCCC 222222 AAAAAA
FFFFFF 333333 GGGGGG
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)
Usamos dos campos principales:

1,3,CH,A primer campo principal, comienza en la columna 1 y tiene una
longitud de 3 caracteres.
6,3,CH,A Segundo campo que comienza en la línea 6 con una longitud de 3

caracteres.
CH: indica que son caracteres. Podemos usar BI para campos binarios.
A: es el orden, en este caso ascendente.
Además, a SORT podemos añadirle otros parámetros al igual que se muestra en

el ejemplo. Algunos de estos parámetros, pueden ser:
SUM, OUTREC, INREC…
Para eliminar los campos duplicados se utiliza: SUM FIELDS=NONE
Otra posibilidad es:

SUM FIELDS=NONE,XSUM
Esto le indicara eliminar registros duplicados y con la opcion XSUM estos
registros se copiaran a otro data set previamente definido en el paso SORTXSUM.
Con outrec o inrec añade elimina o reformatea los campos.
18
.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.
//FTP JOB (1),'FTP',CLASS=A,MSGLEVEL=(1,1),MSGCLASS=X,

// REGION=3000K
//********************************************************************
//* ENVIA FICHEROS POR FTP
//********************************************************************
//PASOFTP EXEC PGM=FTP,REGION=4096K
//OUTPUT DD SYSOUT=*
//SYSFTPD DD DISP=SHR,DSN=TCPIP.MDRVSJ.FTPSDATA.TCPIP
//SYSTCPD DD DISP=SHR,DSN=TCPIP.MDRVSJ.FTPCDATA.TCPIP
//***************************
//INPUT DD *
HOSTNAME ( EXIT=8
USUARIO CONTRASEÑA
<COMANDOS>
QUIT
/*
Este JCL es un ejemplo para realizar FTP. Paso a describir las diferentes
opciones que se pueden realizar:
19
.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:
//XXXXXXXW JOB XXXXXXX,AAAA.A.A,CLASS=G,MSGCLASS=1,NOTIFY=XXXXX

//STEP01 EXEC PGM=IEBCOMPR,ACCT=PJ00000000
// INCLUDE MEMBER=@BATCHS
//SYSIN DD DUMMY
//SYSUT1 DD DSN=XXXXXXX.OLDFILE,UNIT=DASD,DISP=SHR
//SYSUT2 DD DSN=XXXXXXX.NEWFILE,UNIT=DASD,DISP=SHR
//SYSUT# DD
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
.com/
G. Bibliografía.
MVC JCL User Guide de IBM. (RedBooks)

Wikipedia.
http://en.wikipedia.org/wiki/IBM_mainframe_utility_programs
21

Aprende Jcls Desde 0

Caricato da

Informazioni sul documento

Descrizione originale:

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Aprende Jcls Desde 0

Caricato da

Copyright:

Formati disponibili

Aprende Jcl

//HMUNJOB JOB 'JNAVERO', CLASS=E, MSGCLASS=X,

Explicación paso a paso

Un JOB tiene un mínimo de 3 sentencias obligatorias y claramente diferenciadas

Pasamos a analizar la primera línea:

Continuando con el JOB, existen 2 tipos de parámetros que se le pueden pasar al

La sintaxis del Job es la siguiente:

// nombrejob JOB accounting, nombre_programador, class, msgclass, region

Nombre del programador:

Marca el principio del EXEC e indica que UTILITIES (librerías) vamos a

(En el Anexo A se explican brevemente algunas librerías)

Linea 4: //SYSUT1 DD DATA,DLM=$$

Los parámetros de IEBGERNER Son los siguientes que explicare

Por ultimo como ya indique anteriormente, la // final indica el final de JCL.

Primer ejemplo y comentarios

//@BORRADO JOB (999),'@BORRADO',CLASS=E,MSGCLASS=X,REGION=6M

La primera línea indica el JCL a ejecutar, @Borrado, la clase donde se ejecuta

Las líneas de continuación indican los parámetros necesarios para IDCAMS.

Según el JCL Reference de IBM, SYSOUT es un parámetro que especifica la clase

C. Data Set con MainFrame, “DSN”

Veamos un ejemplo e intentemos comprenderlo.

Después de esto nos encontramos con DISP. Esto es la disposición en la que se

Puede tener hasta tres sub-parámetros, el primero de los sub-parámetros es el

En las ultimas 3 disposiciones, el bloqueo será exclusivo: mientras mi job este

Cuando se crea un data set, es necesario reservar el espacio que va a ocupar

SPACE= ({Metric,}(primary-qty[,second-qty][,directory]) [,RLSE] [,CONTIG] )

A continuación pongo un ejemplo de un DNS completo así seguimos

De este ejemplo destacamos UNIT y DCB que veremos a continuación el resto

En el DCB especificaremos 3 cosas: Formato del registro (RECFM, RECord

//@EJECUTA JOB (999),'@EJECUTA',CLASS=E,MSGCLASS=X,REGION=6M

Linea 1: //@EJECUTA JOB (999),'@EJECUTA',CLASS=E,MSGCLASS=X,REGION=6M

En este ejemplo, podemos ver las siguientes líneas:

En este JCL solo queda comentar esto:

Que no es ni más ni menos que se ejecute nuestro programa CUALQUIERA en un

D. Características especiales de JCLS.

ACCEPT WS-VARIABLE1 FROM SYSIN

2. DUMMY o DSN = NULLFILE

3. Concatenación de data Sets

//UNION EXEC PGM=IDCAMS

En el programa de cobol, recibiré una entrada que es la concatenación de los

Este parámetro se utiliza para generar la salida de nuestra aplicación. Lo más

4. Parámetro SYSUDUMP y SYSABEND

E. Diferentes tipos de JCLS.

Suponemos un fichero de entrada sencillo: con tres campos

Nombre Dni Apellido

Nombre Dni Apellido

Usamos dos campos principales:

6,3,CH,A Segundo campo que comienza en la línea 6 con una longitud de 3

Además, a SORT podemos añadirle otros parámetros al igual que se muestra en

Para eliminar los campos duplicados se utiliza: SUM FIELDS=NONE

Otra posibilidad es:

Con outrec o inrec añade elimina o reformatea los campos.

//FTP JOB (1),'FTP',CLASS=A,MSGLEVEL=(1,1),MSGCLASS=X,

//XXXXXXXW JOB XXXXXXX,AAAA.A.A,CLASS=G,MSGCLASS=1,NOTIFY=XXXXX

MVC JCL User Guide de IBM. (RedBooks)

Potrebbero piacerti anche