JCL

JCL


JOB CONTROL LANGUAGE

EXEMPLO

// JOB1 JOB (034D),'RAMESH',CLASS='A',PRTY=6
// STEP01 EXEC PGM=COBPROG.
// INFILE DD DSN=SED.GLOB.DES.INFILE,DISP=SHR
// OUTIFLE DD DSN=SED.GLOB.DES.OUTFILE,
// DISP=(NEW,CATLG,DELETE),
// UNIT=DISK,
// SPACE=(CYL,(1,5),RLSE),
// DCB=(RECFM=FB,LERECL=70,BLKSIZE=700)

ESTE JCL FOI CRIADO PARA RODAR UM PROGRAMA DE COBOL


JCL SINTAXE


O JCL é escrito entre as colunas 1 – 71 (exceto comentários). Frequentemente as colunas 73 – 80 são usadas para números seqüenciais.

Para se continuar uma linha com mais de 71 caracteres (exceto comentários), a primeira linha é terminada com vírgula, e a próxima linha deverá começar entre as colunas 4 e 16 sem esquecer de colocar as duas barras (//) nas linhas 1 e 2.


ESTRUTURA JCL


Toda a estrutura deve começar com duas barras (//) entre as colunas 1 e 2.

“//*” significa um comentário, uma parte escrita e não é usado, é apenas informativo.

“/*” é usado para finalizar uma sessão de entrada de dados, o mesmo parâmetro para algumas outras funções como o comando XEQ que indica em qual sistema o JES executará o Job.


Os CAMPOS do JCL

// (será usado sempre nas colunas 1 e 2 )

Name Field (nome específico para o job)

Operation Field (indica a operação a ser executada)

Operand ( complementos do Operation Field)

Comments (comments começam 1 espaço depois do ultimo Operand, também podemos colocar os comentários após “//*”)

Exemplo:

// Name Operation Operand

// JOB1 JOB (034D),'RAESH',CLASS='A',PRTY=6
// STEP01 EEC PGM=COBPROG
// INFILE DD DSN=SED.GLOB.DES.INFILE,DISP=SR
// OUTIFLE DD DSN=SED.GLOB.DES.OUTFILE,
// DISP=(NEW,CATLG,DELETE),
// UNIT=DISK,
// SPACE=(CYL,(1,5),RLSE),
// DCB=(RECFM=FB,
// LERECL=70,BLKSIZE=700)

Quando o Job processa, ele lê o JCL de maneira simples de cima para baixo. Quando tem uma vírgula,isso significa que o campo operacional tem continuação na ação, quando não tem virgula, quer dizer que a próxima ação será em outro cartão do Job, mas ainda no mesmo Step.




Tipo de Cartões

São tres os cartões do Job:

Job Card - É usado principalmente para identificar o job, e diz ao MVS que tipo de job é, e qual a prioridade do mesmo.

EXEC CARD - É usado para especificar o programa a ser usado.

INFILE é nome do DD CARD - Determina o arquivo de entrada, ou seja, de onde será retirado as informações necessárias para que seja executado o programa.

OUTFILE é o mesmo que INFILE - Um exemplo de DD Card.



JOB CARD


O JOB Card é a primeira parte do job e indica tanto o inicio do mesmo quanto informações sobre o cliente, programador, nome e alguns parâmetros que também darão informações de como o job irá funcionar

Componentes do cartão Job

JOB NAME

Nome do job e seu identificador para o sistema. Deve ser colocado sempre na coluna 3 e tem tamanho máximo de 8 caracteres.

OPERATION FIELD

É o JOB, este parâmetro é fixo e serve para identificar o tipo de operação a ser realizada naquela linha.

INFORMAÇÕES DA CONTA E DO NOME DO PROGRAMADOR

Estes dois parâmetros são posicionais, não aparecem em todos os JCL’s

CLASS

É USADO PARA DIZER AO SISTEMA PERACIONAL QUAL A NATURAZA DO JOB.

SINTAXE - CLASS = classe do job.

VALORES VÁLIDOS - QUALQUER CARACTERE ALFABÉTICO ENTRE A E Z OU NUMERAL ENTRE 0 E 9.

PRTY

Este parâmetro designa uma prioridade para os JOBS de mesma classe. Quanto maior o numero da classe, maior e a prioridade deste JOB rodar sobre os outros que continuarão aguardando a execução do mesmo.

Sintaxe - PRTY= prioridade.

Valores Válidos - qualquer valor entre 0 e 15.

MSGCLASS

Este parâmetro determina o dispositivo de saída para onde serão escritas as mensagens do sistema e do JCL.

Sintaxe - MSGCLASS=nome da classe de saída.

Valores válidos - Qualquer caractere alfabético entre A e Z ou numeral entre 0 e 9. O tipo de classe e suas definições são criadas pelo sistema operacional ou pelo grupo de suporte.

MSGLEVEL

Usado para dizer ao JCL quais mensagens deverão ser “impressas” no dispositivo especificado no parâmetro MSGCLASS.

Sintaxe - MSGLEVEL=(partes a serem “impressas” (statements), mensagens).

Valores válidos - partes a serem impressas ou statements, podem ser números 0, 1 ou 2 e as mensagens podem ser 0 ou 1.

Statements:

0 – Imprimira apenas os relatórios do job.
1 – O JCL será impresso (incluindo todos os parâmetros catalogados / simbólicos).
2 – So imprimira os inputs do JCL.

Mensagens:

0 - As mensagens de Alocação e finalização serão impressas caso o job termine com erro.
1 - As mensagens de Alocação e finalização serão impressas caso o job termine em erro ou não.

REGION

Este parâmetro especifica a máxima quantidade de armazenamento virtual que o job poderá usar. Uma certa quantidade de K ou M deve ser especificado, as limitações deste espaço são definidos pela classe do job.

Sintaxe - REGION=xxxxK ou M.

Valores válidos - Qualquer caractere numérico desde que de acordo com as especificações da classe.

TIME

Este parâmetro especifica o total de CPU time a ser usado pelo job (em minutos, segundos) este número e para todos os steps do job. O valor máximo permitido geralmente é de até 1439 minutos, caso o valor especificado seja igual a 1440, isso indicará que o job não possui limite de tempo.

Sintaxe - TIME=(minutos,segundos)

Valores válidos - Qualquer caractere numérico indicando tempo ate 1440, unidades não são usadas neste parâmetro.

TYPRUN

Quando este parâmetro e usado o Job não rodara propriamente, ele possui dois tipos SCAN ou HOLD, o primeiro fará uma checagem no job e o segundo o manterá em HOLD ate segunda ordem.

Sintaxe - TYPRUN=HOLD (job em HOLD até segunda ordem), TYPRUN=SCAN (checa o JCL para possíveis erros de sintaxe)

Valores válidos - HOLD ou SCAN

NOTIFY

Este parâmetro é usado para indicar ao sistema, onde as mensagens de sucesso ou de falha devem ser enviadas após o job completar.

Sintaxe - NOTIFY=userid / &SYSUID

Valores válidos - userid é o ID de quem o submeteu, &SYSUID representa o ID de quem o submeteu.
A diferença e que no caso de um &SYSUID o job localizará quem liberou o job e manda o Report para ele e o outro caso o job manda um report sempre para uma pessoa.




Cartão JOBLIB e STEPLIB

JOBLIB

Uma espécie de cartão DD (Data Definition), e especifica onde o programa existe. É aplicável a todos os steps daquele job.

Sintaxe - // JOBLIB DD DSN=dataset

Exemplo de JCL:
// MYJOB JOB (E343),'KRISHNA'
// JOBLIB DD DSN=SE.TST.LODLIB,DISP=SHR
// STEP1 EXEC PGM=COBPROG

Logo após o JOB card esta o JOBLIB DD, que especificara a localização do programa que será executado.


STEPLIB

Muito parecido com o JOBLIB, este DD pode ser usado em qualquer ponto do step.

A DIFERENÇA ENTRE O STEPLIB E O JOBLIB É QUE O STEPLIB ESPECIFICA A LOCALIZAÇÃO DO PROGRAMA A SER USADO APENAS NAQUELE STEP.

Sintaxe - // STEPLIB DD DSN=dataset

EXEMPLO DE JCL:
// MYJOB JOB (U456),'KRISHNA'
// STEP1 EXEC PGM=COBPROG
// STEPLIB DD DSN=TEST.MYPROD.LIB,DISP=SHR
// STEP2 EXEC PGM=COBPROG2
// STEPLIB DD DSN=TEST.MYPROD.LIB1,DISP=SHR

No exemplo acima, STEP1 está executando COBPROG o qual é membro de TEST.MYPROD.LIB.

E o STEP2 está executando COBPROG2 o qual é membro de TEST.MYPROD.LIB1.

OBS: Caso existam um JOBLIB e um STEPLIB no mesmo job, as especificações do STEPLIB terão prioridade no step e serão executadas.




CARTÃO EXEC


O cartão EXEC é usado para executar um programa (PROG), ou uma procedure (PROC). O máximo de STEPS que podem existir em um JCL só será 255, caso sejam necessários mais
STEPS, estes devem figurar em outro JOB, colocando-o para rodar logo após o primeiro JOB da série.

Sintaxe - // stepname EXEC PGM=progname, PARM='parm', COND=condition, REGION=n, TIME=(m,s)

Programa (PROG)

É simplesmente um programa a ser executado, dependendo do que o programa realizará alguns dados serão necessários e estes serão fornecidos pelo DD card que veremos em seguida.

Parm field (PARM)

É um parâmetro usado para passar alguma informação para o programa.

Sintaxe - PARM=valor

Valores válidos - O valor é uma cadeia de caracteres ou “strings” de 1 a 100 caracteres de tamanho.

Procedure (PROC)

Procedures são coleções de JCL pré definidos catalogados e armazenados, são chamados pelo JOB com o uso de um código próprio. Existem duas maneiras de usarmos uma procedure em um JCL, das quais a segunda forma é a mais utilizada.

Ex1: // procstepname EXEC PROC=procname,param1=foo

Ex2: // procstepname EXEC procname,param1=foo

REGION

Especifica a quantidade de espaço que devera ser usado na hora de rodar aquele Job/Step.

Sintaxe - REGION=< valor >K ou REGION=< valor >M

Exemplo de JCL:
// MYJOB JOB (AE32),'RAMESH'
// STEP1 EXEC PGM=COBPROG,
// REGION=67K

Para deixar disponível todo armazenamento disponível é só usar 0K ou 0M no parâmetro REGION.

COND

Cada STEP envia ao sistema um “return code” ao completar, este é chamado “condition code”. O parâmetro COND é usado para controlar a execução dos steps seguintes, dependendo do “condition code“ que vem do step anterior. Os return codes variam entre 0 e 4095.

Sintaxe - COND=(comparsion code,condition), COND=(comparsion-code,condition), (If coded on step), [,stepname] [,EVEN / ONLY]) , (If coded on step)

As condições podem ser:

GT = Greater Than
GE = Greater or EqualL
T = Lower or ThanL
E = Lower or Equal
EQ = Equal
NE = No Equal

Exemplo de JCL:
// MYJOB JOB (R475),'KRISHNA REDDY‘, COND=(4,GT)
// STEP1 EXEC PGM=COBPROG
// STEP2 EXEC PGM=COBPROG2

Neste exemplo estamos dizendo ao JCL que se o STEP1 tiver um return code maior que 4 então o STEP2 será passado sem executar, ou seja, pulado (BYPASS).

// MYJOB JOB (U769),'KRISHNA REDDY'
// STEP1 EXEC PGM=PROG1
// STEP2 EXEC PGM=COBPROG, COND=(8,EQ,STEP1)

Neste exemplo veremos que o STEP2 será pulado (BYPASS) caso o STEP1 terminar um return code igual a 8.

TIME

O parâmetro TIME é usado para especificar a quantidade de CPU time que um job ou um step poderá utilizar.
A sintaxe deste parâmetro e a mesma que a do cartão JOB descrito anteriormente. Não podemos esquecer de alguns dados importantes para este parâmetro:
Minutes pode ser de 1 a 1439, Segundos pode ser de 1 a 59

// SECOND JOB,'R. KRISHNA',TIME=3
// STEP1 EXEC PGM=C,TIME=2
// STEP2 EXEC PGM=D,TIME=2

Neste exemplo temos um job com tempo total de limite de 3 minutos, e cada um de seus steps possue dois minutos para rodar, caso o STEP1 levar dois minutos, o STEP 2 só terá 1 minuto para rodar, porque o JOB terá 3 minutos para rodar e as informações do cartão JOB terão prioridade.

Para codificar tempo ilimitado para um job é necessário usar no parâmetro TIME=, o numero 1440 ou NOLIMIT.

Outros parâmetros pouco usados:

ACCT – informações da conta para aquele step.

ADDRSPC – Usado para indicar o tipo de armazenamento que o step usara, pode ser armazenamento virtual ou real.

DPRTY – usado para determiner uma prioridade para aquele step

PERFORM – especifica a taxa de recursos a ser usado pelo step.

RD – (Restart Definition) é usado para determiner o restart automatico de um Job caso ele abend.



CARTÃO DD

O cartão DD (Data Definition), é usado para identificar os recursos de entrada e os locais de armazenamento de “output”.

Sintaxe - // ddname DD < Parâmetros posicionais / de comando >

Parâmetros Posicionais :

DATA
DUMMY
DYNAM

Parâmetros de Comando :

DSN
DISP
UNIT
SPACE
DCB
VOLUME


Parametros de Comando

DSN

Esse parâmetro é usado para especificar o nome do data set.

Sintaxe - DSN=nome do data set.

Exemplo de JCL:
// MYJOB JOB (ER3),'RAMESH R'
// STEP1 EXEC PGM=COBPROG
// INFILE DD DSN=TEST.GLOB.MYLIB

TEST.GLOB.MYLIB será usado no programa COBPROG.

Data Set temporário – esse tipo de dataset durante a rodada do JOB é deletado no final da execução. Os data sets temporários são codificados usando dois e comerciais (&&) seguidos do nome.

Exemplo de JCL:
// MYJOB JOB (E456),'RAMESH'
// STEP1 EXEC PGM=COBPROG
// INFILE DD DSN=&&TEMP

DISP – o parâmetro DISP é usado para especificar a disposição do data set que será
definido no parâmetro DSN.Sintaxe - DISP=(STATUS,DISPOSICAO NORMAL, DISPOSICAO ANORMAL)

STATUS – status atual do data set (se ele existe ou terá de ser criado)

DISPOSICAO NORMAL – caso o JOB complete bem, como o data set será tratado(deletado, catalogado, etc)

DISPOSICAO ANORMAL – caso o JOB abend, como o data set será tratado(deletado,
catalogado, etc)

Parâmetros DISP

Status - Normal Disp - Abnormal Disp
NEW - DELETE - DELETE
OLD - CATLG - CATLG
MOD - UNCATLG - KEEP
SHR - KEEP - UNCATLG
- PASS

STATUS

NEW - Data set será criado. (file não deve existir)
OLD - Data set deve existir.
MOD - Data set será criado caso não exista.
SHR - Data set não poderá ser usado por outro JOB.

DISPOSICAO NORMAL

DELETE - Data set devera ser deletado.
CATLG - Data set devera ser catalogado.
UNCATLG - Data set será removido dos catálogos do sistema.
KEEP - Data set será guardado, mantido (Este parâmetro deve ser usado com data sets permanentes).
PASS - Data set devera ser passado para o próximo step no job.

DISPOSICAO ANORMAL

DELETE - Dataset será deletado
CATLG - Dataset será catalogado
UNCATLG - Dataset será removido dos catálogos do sistema
KEEP - Dataset sera mantido

Exemplo de JCL:
// MYJOB JOB (E674),'KRISHNA REDDY'
// STEP1 EXEC PGM=COBPROG
// INFILE DD DSN=TEST.GLOB.TEMP, DISP=(NEW,CATLG,DELETE)

UNIT

Em um ambiente mainframe, todos os devices têm um endereço designado no
momento que são adicionados ao sistema. Esses devices podem ser referenciados usando
estes endereços. O parâmetro UNIT é usado para especificar estes endereços.

Sintaxe - UNIT=device_address/device_type/device_group_name/TAPE

Exemplo de JCL:
// MYJOB JOB (R345),'KRISHNA REDDY'
// STEP1 EXEC PGM=COBPROG
// INFILE DD DSN=TEST.GLOB.TEST.LIB,
// UNIT=SYSDA

Neste exemplo o arquivo de entrada TEST.GLOB.TEST.LIB existe em qualquer um dos
devices que estão designados com o nome simbólico de SYSDA.

VOL

Este parâmetro é usado para identificar o numero serial do volume no qual o
Dataset reside. O parâmetro VOL é usado com data sets de disco e tape.

Sintaxe - VOL= volumelabel/data set label

**Sub-parâmetros usados com o parâmetro VOL:__

SER - especificação do número serial.
REF - faz referência a um volume localizado em um step anterior.
PRIVATE - permite o acesso a um volume por apenas um usuário.
RETAIN - não permite que o volume seja desmontado antes do termino do job.
SEQ - especificação da seqüência em que os volumes serão montados.

Exemplo de JCL:
// MYJOB JOB (E454),'KRISHNA REDDY'
// STEP1 EXEC PGM=COBPROG
// INFILE DD DSN=TEST.GLOB.TEMP,
// VOL=SER=(VOL1,VOL2,VOL3)

SPACE

Este parâmetro é usado para alocar espaço para datasets. Podemos alocar espaço em cilindros/tracks/blocos.

Sintaxe - SPACE=(CYL,(primary,secondary,directory),RLSE, CONTIG,MXIG,ROUND)

Significado dos sub parâmetros:

TRK - Espaço estará em tracks.
CYL - Espaço estará em Cilindros.
PRIMARY - Espaço primário a ser alocado quando o data set for criado.
SECONDARY - Espaço adicional a ser alocado caso a alocação primaria não for suficiente, será ampliada 15 vezes caso necessário.
DIRECTORY - Espaço para alocação do nome e localização de datasets particionados.
RLSE - Libera espaço pré-alocado não utilizado, depois que o Job completar.
CONTIG - Requisição para espaços contíguos.
MXIG - Requisição para uma grande área de espaço contíguo.
ROUND - Requisição para armazenamento em um cilindro inteiro.

Exemplo de JCL:
// MYJOB JOB (W345),'KRISHNA REDDY'
// STEP1 EXEC PGM=COBPROG
// INFILE DD DSN=TEST.GLOB.LIB,
// UNIT=4560,
// SPACE=(CYL,(30,4))

DCB

Os dados em um dataset podem ter tamanho fixo ou tamanho variado. O parâmetro DCB (Data Control Block) é usado para especificar o formato da gravação, tamanha da gravação, tamanho de blocos etc…

Sintaxe - // ddname DD DCB=< parameters >

Sub-parâmetros:

RECFM - Especificação do formato dos dados - F/FB/V/VB/U
LRECL - Especificação do tamanho dos dados
BLKSIZE - Especificação do tamanho dos blocos
BUFNO - Especificação do buffers

Exemplo de JCL:
// MYJCL JOB (E3445),'RAMESH'
// STEP1 EXEC PROG=COBPROG
// INFILE DD DSN=TEST.GLOB.LIB,
// UNIT=234,
// DSN=(LRECL=80, RECFM=FB, BLKSIZE=800, BUFNO=30)

Neste exemplo, o parâmetro DCB especifica que este file necessita de uma gravação
lógica de tamanho 80 bytes, terá um formato de bloco fixo, e a quantidade de blocos
será 800. O parâmetro BUFNO está setado para 30 indicando que até 30 buffers poderão
ser utilizados. A quantidade de buffers default é 5 caso não exista o parâmetro BUFNO.




RESTART

O Restart no JCL é usado no cartão job, depois do ultimo parâmetro ou em qualquer parte dos parâmetros não posicionais, utilizar o parâmetro RESTART=PROCSTEP.STEP, não esquecer de adicionar a virgula antes do parâmetro restart.

Sintaxe - ,RESTART=step.procstep,

Exemplo de JCL:

// jobname JOB 'message message message',ZZZ,
// MSGLEVEL=1,MSGCLASS=Q,
// NOTIFY=onono,
// RESTART=step.procstep


CHEKPOINT


O Checkpoint é um parâmetro onde o job lê as informações processadas em um determinado período de tempo e salva este processamento ponto a ponto para posterior conferencia ou até um restart de um determinado ponto do processamento para evitar perda de tempo e informação.

Checkpoint Restart

// jobname JOB (y999,onon),'blabla',REGION=5000K,CLASS=X,
// MSGCLASS=N
// JOBLIB DD DSN=data.set.name,DISP=SHR
// DD DSN=data.set.name.one,DISP=SHR
// DD DSN=data.set.name.two,DISP=SHR
/*JOBPARM F=CJBA
/*ROUTE PRINT RMDS
*LOGONID ononon
OUTD OUTPUT CLASS=*,FORMS=zzzz,DEST=RMDS
// UCC11RMD EXEC UCC11RMD,RUN=P
// zz12347 EXEC zz54321
// zz12348 EXEC zz54322
// zz12349 EXEC zz54323

Job abended message:

JOB99999 MVS0010I jobname 07.234 X step procstep R0012

Depois deve-se procurer o ultimo checkpoint:

JOB99999 +DFS0540I *EXTENDED CHECKPOINT*
PROGRAM=vaivaivai,CKPTID=ididid,REGID=0001,DAY=234,TIME=0447432 IMP9JOB99999
+DFS0542I *EXTENDED CHECKPOINT* DAY=234,TIME=044743277753-0400 IMPX

Depois disso devemos ir no cartao exec do step de abend e la no JCL procurar o nome do Checkpoint:

XX step EXEC PGM=pgmpgmpg,
XX PARM='bla,wwwwwwww,yyyyyyyy00000,&CKPT999'

O parâmetro & indica um parâmetro oculto que será carregado naprocedure, ou mesmo
uma variável que poderá ser refeita com o override.

Após acharmos o nome do checkpoint, devemos ir no step de abend e fazer o seguinte
override:

// jobname JOB (y999,onon),'blabla',REGION=5000K,CLASS=X,
// MSGCLASS=N
* blabla yy0000 LAST SYSTEM ACCESS 22.21-08/21/07 FROM STCINRDR ononon
* CA-7 JOB#=9999 DUE OUT 99.999/99.99 JCLID=000 SCHID=999 ENTRY=AUTO
* CA-7 COM9 EXIT02=Y
zz12347 EXEC zz54321,CKPT999=idididid
// zz12348 EXEC zz54322
// zz12349 EXEC zz54323

Este tipo de ação é tomada quando o job não tem o JCL acessível para editar, quando o JCL pode ser editado, é necessário ir no JCL e no local onde hover o checkpoint ID fazer a modificação e restartar do step.

XX step EXEC PGM=DFSRRC00,
XX PARM='bla,wwwwwwww,yyyyyyyy00000,CKPT999=idididid'

Caso o checkpoint seja feito do ultimo ponto onde o “CKPTID=” foi encontrado ou se o operador não tem acesso a essas informações uma solução fácil e eficaz é utilizar o parâmetro LAST da mesma maneira que fizemos com o parâmetro anterior.

// step EXEC proc,CKPT999=LAST
Ou
XX step EXEC PGM=DFSRRC00,
XX PARM='bla,wwwwwwww,yyyyyyyy00000,CKPT999=LAST'


Override para Parametros DD

Para se realizar um override algumas informações precisam ser coletadas.
- Qual o Step de abend.
- Qual o DD onde o override será executado.
- Qual o parâmetro a ser arrumado.

Exemplo:

JOB04603 MVS0010I xxxxxxxx 07.234 X zzzzzzz wwwwwww ** SB37 **

XX SORTOUT DD DSN=xx.zzzzzz,
XX DISP=(,CATLG,DELETE),
XX UNIT=SYSDA,
XX SPACE=(TRK,(700,75),RLSE)

SPACE=(TRK,(700,75),RLSE),

// jobname JOB (9999,zzz99),'zzzzzzz',REGION=5000K,CLASS=X,
// MSGCLASS=N
// * CA-7 COM2 EXIT02=Y
// zz12345 EXEC zz54320
// zz12346.SORTOUT DD SPACE=(TRK,(750,100),RLSE)
// zz12347 EXEC zz54321
// zz12348 EXEC zz54322
// zz12349 EXEC zz54323


Override Para Cartão EXEC


Este override é o mais fácil, bastando para o mesmo apenas o parâmetro necessário para o override e a modificação a ser feita, depois é só ir no JCL e onde esta a chamando a proc, e só colocar virgula e depois colocar o parâmetro a ser mudado, desde que este conste no cartão EXEC daquele step.

// jobname JOB (9999,zzz99),'zzzzzzz',REGION=5000K,CLASS=X,
// MSGCLASS=N
// * CA-7 COM2 EXIT02=Y
// zz12346 EXEC zz54320,CKPT999=LAST
// zz12347 EXEC zz54321
// zz12348 EXEC zz54322
// zz12349 EXEC zz54323


Programas Padrão IBM

São os Programas utilizados no JCL e que realizam determinados trabalhos, updates, copias, etc..

IEBCOPY – Copia, comprime e migra datasets particionados, ele também seleciona ou exclui membros específicos durante a operação de copia e os renomea, ou ate os substitui.

IEBGENER – Copia dados de um dataset seqüencial ou cria datasets particionados

IEFBR14 – é um programa “dummy”, normalmente usado para alocar ou deletar datasets.




Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License