Aprende Jcls Desde 0

http://www.namocode.com

http://devthisblog.wordpress.com/

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

Aprende Jcl desde 0.

http://www.namocode.com/


http://devthisblog.wordpress

.com/

2

Í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



.com/

3

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



.com/

4

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

//



.com/

5

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.



.com/

6

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í:



.com/

7

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 //*.



.com/

8

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.



.com/

9

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.



.com/

10

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.



.com/

11

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.



.com/

12

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.



.com/

13

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.



.com/

14

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.



.com/

15

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.



.com/

16

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.



.com/

17

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)



.com/

18

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.



.com/

19

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:



.com/

20

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



.com/

21

G. Bibliografía.

MVC JCL User Guide de IBM. (RedBooks)

Wikipedia.

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

Aprende Jcls Desde 0

Documents

Transcript of Aprende Jcls Desde 0