JCL

JCL - Visão gerãl

Quando usar JCL
JCL é usado em um ambiente de mainframe para atuar como uma comunicação entre um programa
(Exemplo: COBOL, Assembler ou PL/I) e o sistema operacional. Em um ambiente de mainframe, os
programas podem ser executados em modo batch e online. Exemplo de sistema batch pode ser o
processamento das transações bancárias através de um arquivo VSAM (Virtual Storage Access Method) e a
aplicação nas contas correspondentes. Exemplo de um sistema online pode ser uma tela de back office usada
por funcionários de um banco para abrir uma conta. No modo batch, os programas são enviados ao sistema
operacional como um job por meio de uma JCL.

O processamento em lote e online difere no aspecto de entrada, saída e solicitação de execução do programa.
No processamento em lote, esses aspectos são alimentados em um JCL que, por sua vez, é recebido pelo
sistema operacional.

Processamento de JOB
Um JOB é uma unidade de trabalho que pode ser composta de várias etapas de trabalho. Cada passo (step)
do JOB é especificado em uma JCL (Job Control Language) por meio de um conjunto de Instruções de
Controle de Trabalho.

O Sistema Operacional usa o Sistema de Entrada de Trabalhos (JES) para receber trabalhos no Sistema
Operacional, para agendá-los para processamento e para controlar a saída.

O processamento do trabalho passa por uma série de etapas, conforme indicado abaixo:

 Job Submission (Envio de trabalho): Enviando o JCL para JES.

 Job Conversion (Conversão de Trabalho): O JCL junto com o PROC é convertido em um texto
interpretado para ser entendido pelo JES e armazenado em um dataset, que chamamos de SPOOL.
 Job Queuing (Enfileiramento de Trabalhos): O JES decide a prioridade do trabalho com base nos
parâmetros CLASS e PRTY na instrução JOB (explicado no capítulo JCL – Declaração JOB). Os
erros de JCL são verificados e a tarefa é agendada na fila de tarefas se não houver erros.
 Job Execution (Execução do Trabalho): Quando o trabalho atinge sua prioridade mais alta, ele é
executado na fila de trabalhos. O JCL é lido do SPOOL, o programa é executado e a saída é
redirecionada para o destino de saída correspondente conforme especificado no JCL.
 Purging (Purga): Quando a tarefa for concluída, os recursos alocados e o espaço JES SPOOL serão
liberados. Para armazenar o log de trabalho, precisamos copiar o log de trabalho para outro conjunto
de dados antes de liberá-lo do SPOOL.
JCL – Configurãção do Ambiente
Instalando JCL no Windows/Linux
Existem muitos emuladores de mainframe gratuitos disponíveis para Windows que podem ser usados para
escrever e aprender JCLs de amostra. Um desses emuladores é o Hercules, que pode ser facilmente instalado
no Windows. Hercules é uma implementação de software de código aberto das arquiteturas de mainframe
System/370 e ESA/390, além da mais recente arquitetura z/Architecture de 64 bits. Hercules é executado em
Linux, Windows, Solaris, FreeBSD e Mac OS X.

Executando JCL em Mainframes

Um usuário pode se conectar a um servidor de mainframe de várias maneiras, como thin client, terminal
fictício, Virtual Client System (VCS) ou Virtual Desktop System (VDS).

Cada usuário válido recebe um id de login para entrar na interface Z/OS (TSO/E ou ISPF). Na interface do
Z/OS, o JCL pode ser codificado e armazenado como um membro em um Partitioned Dataset (PDS).
Quando o JCL é enviado, ele é executado e a saída recebida conforme explicado na seção de processamento
de trabalho do capítulo anterior.

Estrutura de um JCL
A estrutura básica de um JCL com as instruções comuns é dada abaixo:

//SAMPJCL JOB 1,CLASS=6,MSGCLASS=0,NOTIFY=&SYSUID (1)

//* (2)
//STEP010 EXEC PGM=SORT (3)
//SORTIN DD DSN=JCL.SAMPLE.INPUT,DISP=SHR (4)
//SORTOUT DD DSN=JCL.SAMPLE.OUTPUT, (5)
// DISP=(NEW,CATLG,CATLG),DATACLAS=DSIZE50
//SYSOUT DD SYSOUT=* (6)
//SYSUDUMP DD SYSOUT=C (6)
//SYSPRINT DD SYSOUT=* (6)
//SYSIN DD * (6)
SORT FIELDS=COPY
INCLUDE COND=(28,3,CH,EQ,C'XXX')
/* (7)

Descrição do Programa
As instruções JCL numeradas foram explicadas abaixo:

(1) JOB statement (Declaração de JOB): Especifica as informações necessárias para o SPOOLing do job,
como ID do job, prioridade de execução, ID do usuário a ser notificado após a conclusão do job.

(2) //* statement (declaração): Esta é uma declaração de comentário.

(3) Declaração EXEC: Especifica o PROC/Program a ser executado. No exemplo acima, um programa
SORT está sendo executado (ou seja, ordenando os dados de entrada em uma ordem específica)

(4) Instrução DD de Entrada: Especifica o tipo de entrada a ser passado para o programa mencionado em
(3). No exemplo acima, um arquivo Physical Sequential (PS) é passado como entrada no modo
compartilhado (DISP = SHR).
(5) Instrução DD de saída: Especifica o tipo de saída a ser produzida pelo programa na execução. No
exemplo acima, um arquivo PS é criado. Se uma instrução se estender além da 70ª posição em uma linha, ela
continuará na próxima linha, que deve começar com “//” seguido por um ou mais espaços.

(6) Pode haver outros tipos de instruções DD para especificar informações adicionais ao programa (no
exemplo acima: A condição SORT é especificada na instrução SYSIN DD) e para especificar o destino do
log de erro/execução (Exemplo: SYSUDUMP/SYSPRINT). As instruções DD podem estar contidas em um
conjunto de dados (arquivo de mainframe) ou como em dados de fluxo (informações codificadas no JCL),
conforme fornecido no exemplo acima.

(7) /* marca o fim dos dados do stream.

Todas as instruções JCL, exceto em dados de fluxo, começam com //. Deve haver pelo menos um espaço
antes e depois das palavras-chave JOB, EXEC e DD e não deve haver espaços no restante da instrução.

Tipos de Parâmetros JOB

Cada uma das instruções JCL é acompanhada por um conjunto de parâmetros para ajudar os Sistemas
Operacionais a completar a execução do programa. Os parâmetros podem ser de dois tipos:

Parâmetros posicionais (Positional Parameters)

 Aparece na posição e ordem pré-definidas na instrução. Exemplo: O parâmetro de informações de

contabilidade pode aparecer somente após a palavra-chave JOB e antes do parâmetro de nome do
programador e dos parâmetros de palavra-chave. Se um parâmetro posicional for omitido, ele deverá
ser substituído por uma vírgula.
 Parâmetros posicionais estão presentes nas instruções JOB e EXEC. No exemplo acima, PGM é um
parâmetro posicional codificado após a palavra-chave EXEC.

Parâmetros de palavra-chave (Keyword Parameters)

 Eles são codificados após os parâmetros posicionais, mas podem aparecer em qualquer ordem. Os
parâmetros de palavra-chave podem ser omitidos se não forem necessários. A sintaxe genérica é
KEYWORD= valor. Exemplo: MSGCLASS=X, ou seja, o log do job é redirecionado para o SPOOL
de saída após a conclusão do job.
 No exemplo acima, CLASS, MSGCLASS e NOTIFY são parâmetros de palavras-chave da instrução
JOB. Também pode haver parâmetros de palavras-chave na instrução EXEC.

Esses parâmetros foram detalhados nos capítulos subsequentes, juntamente com exemplos apropriados.
JCL – JOB Stãtement
A instrução JOB é a primeira instrução de controle em uma JCL. Isso dá a identidade do trabalho ao Sistema
Operacional (SO), no spool e no agendador. Os parâmetros na instrução JOB ajudam os sistemas
operacionais na alocação do agendador correto, tempo de CPU necessário e emissão de notificações ao
usuário.

Sintaxe
A seguir está a sintaxe básica de uma instrução JCL JOB:

//Job-name JOB Positional-param, Keyword-param

Descrição (Description)
Vamos ver a descrição dos termos usados na sintaxe da instrução JOB acima.

Nome do JOB (job-name)

Isso fornece um id ao trabalho ao enviá-lo ao sistema operacional. Pode ter comprimento de 1 a 8 com
caracteres alfanuméricos e começa logo após //.

JOB

Esta é a palavra-chave para identificá-la como uma instrução JOB.

Parâmetro de posição (Positional-param)

Existem parâmetros posicionais, que podem ser de dois tipos:

Positional Parameter Descrição

Isso se refere à pessoa ou grupo ao qual o tempo de CPU é devido. Ele é definido
de acordo com as regras da empresa proprietária dos mainframes. Se for
Account information
especificado como (*), então leva o id do usuário, que está atualmente conectado
ao Terminal Mainframe.
Isso identifica a pessoa ou grupo responsável pelo JCL. Este não é um parâmetro
Programmer name
obrigatório e pode ser substituído por uma vírgula.

Palavra-chave (Keyword-param)

A seguir estão os vários parâmetros de palavras-chave, que podem ser usados na instrução JOB. Você pode
usar um ou mais parâmetros com base nos requisitos e eles são separados por vírgula:
Parâmetro de
Descrição
palavra-chave
Com base na duração do tempo e no número de recursos exigidos pelo JOB, as empresas
atribuem diferentes classes de trabalho. Estes podem ser visualizados como agendadores
individuais usados pelo sistema operacional para receber os trabalhos. Colocar os
trabalhos no agendador correto ajudará na fácil execução dos trabalhos. Algumas
empresas possuem classes diferentes para trabalhos em ambiente de teste e produção.
CLASS
Os valores válidos para o parâmetro CLASS são caracteres de A a Z e numéricos de 0 a 9
(de comprimento 1). Segue a sintaxe:

CLASSE=0 a 9 | A a Z
Para especificar a prioridade do trabalho em uma classe de trabalho. Se esse parâmetro
não for especificado, o trabalho será adicionado ao final da fila na CLASS especificada.
Segue a sintaxe:
PRTY
PRTY=N

Onde N é um número entre 0 e 15 e maior o número, maior é a prioridade.

O sistema envia a mensagem de sucesso ou falha (Código de Condição Máxima) para o
usuário especificado neste parâmetro. Segue a sintaxe:

NOTIFY NOTIFY=”userid | &SYSUID”

Aqui o sistema envia a mensagem para o usuário “userid”, mas se usarmos NOTIFY =
&SYSUID, a mensagem é enviada para o usuário que envia o JCL.
Para especificar o destino de saída para as mensagens do sistema e do trabalho quando o
trabalho for concluído. Segue a sintaxe:

MSGCLASS=CLASS
MSGCLASS
Os valores válidos de CLASS podem ser de “A” a “Z” e “0” a “9”. MSGCLASS = Y
pode ser definido como uma classe para enviar o log de trabalho para o JMR (Joblog
Management and Retrieval: um repositório dentro de mainframes para armazenar as
estatísticas de trabalho).
Especifica o tipo de mensagens a serem gravadas no destino de saída especificado no
MSGCLASS. Segue a sintaxe:

MSGLEVEL=(ST, MSG)

ST= Tipo de instruções gravadas no log de saída

 Quando ST = 0, somente instruções de trabalho.

 Quando ST = 1, JCL juntamente com parâmetros simbólicos são expandidos.
MSGLEVEL
 Quando ST = 2, insira apenas JCL.

MSG= Tipo de mensagens gravadas no log de saída.

 Quando MSG = 0, mensagens de Alocação e Encerramento são gravadas após a

conclusão anormal do trabalho.
 Quando MSG = 1, mensagens de Alocação e Encerramento são gravadas
independentemente da natureza da conclusão do trabalho.
 Especifica um processamento especial para o trabalho. Segue a sintaxe:

TYPRUN = SCAN | HOLD

TYPRUN Onde SCAN e HOLD tem a seguinte descrição

 TYPRUN = SCAN verifica os erros de sintaxe da JCL sem executá-la.

 TYPRUN = HOLD coloca o trabalho em HOLD na fila de trabalhos.

Especifica o intervalo de tempo a ser usado pelo processador para executar o trabalho.
Segue a sintaxe:

TIME=(mm, ss) ou TIME=ss

TIME Onde mm = minutos e ss = segundos

Este parâmetro pode ser útil ao testar um programa recém-codificado. Para garantir que o
programa não seja executado por muito tempo devido a erros de loop, um parâmetro de
tempo pode ser codificado para que o programa termine de forma anormal quando o
tempo de CPU especificado for atingido.
Especifica o espaço de endereço necessário para executar uma etapa de trabalho dentro do
trabalho. Segue a sintaxe:

REGION=nK | nM

REGION Aqui, a região pode ser especificada como nK ou nM onde n é um número, K é kilobyte e
M é Megabyte.

Quando REGION = 0K ou 0M, o maior espaço de endereçamento é fornecido para

execução. Em aplicações críticas, a codificação de 0K ou 0M é proibida para evitar o
desperdício do espaço de endereçamento.

Exemplo
//URMISAMP JOB (*),"tutpoint",CLASS=6,PRTY=10,NOTIFY=&SYSUID,
// MSGCLASS=X,MSGLEVEL=(1,1),TYPRUN=SCAN,
// TIME=(3,0),REGION=10K

Aqui, a instrução JOB está sendo estendida além da 70ª posição em uma linha, então continuamos na
próxima linha que deve começar com “//” seguido por um ou mais espaços.

Parâmetros diversos
Existem alguns outros parâmetros que podem ser usados com a instrução JOB, mas eles não são usados com
frequência:
ADDRSPC Tipo de armazenamento usado: Virtual ou Real
Tamanho dos dados a serem gravados no log de saída e a ação a ser tomada quando o
BYTES
tamanho for excedido.
LINES Número máximo de linhas a serem impressas no log de saída.
PAGES Número máximo de páginas a serem impressas para o log de saída.
USER ID do usuário usado para enviar o trabalho
PASSWORD Senha do ID do usuário especificado no parâmetro USER.
COND AND Eles são usados no processamento condicional da etapa de trabalho e são explicados
RESTART em detalhes ao discutir o processamento condicional.
Declãrãção JCL - EXEC
Cada JCL pode ser composto de várias etapas de trabalho. Cada etapa do JOB pode executar um programa
diretamente ou pode chamar um procedimento, que por sua vez executa um ou mais programas (etapas de
trabalho). A instrução, que contém as informações do programa/procedimento da etapa da tarefa, é a
instrução EXEC.

A finalidade da instrução EXEC é fornecer as informações necessárias para o programa/procedimento

executado na etapa de trabalho. Os parâmetros codificados nesta instrução podem passar dados para o
programa em execução, podem substituir certos parâmetros da instrução JOB e podem passar parâmetros
para o procedimento se a instrução EXEC chamar um procedimento em vez de executar diretamente um
programa.

Sintaxe
A seguir está a sintaxe básica de uma instrução JCL EXEC:

//Step-name EXEC Positional-param, Keyword-param

Descrição (Description)
Vejamos a descrição dos termos usados na sintaxe da instrução EXEC acima.

STEP-NAME

Isso identifica a etapa da tarefa dentro da JCL. Pode ter comprimento de 1 a 8 com caracteres alfanuméricos.

EXEC

Esta é a palavra-chave para identificá-la como uma instrução EXEC.

POSITIONAL-PARAM

Estes são parâmetros posicionais, que podem ser de dois tipos:

Positional
Descrição
Parameter

PGM Refere-se ao nome do programa a ser executado na etapa de trabalho.

Refere-se ao nome do procedimento a ser executado na etapa de trabalho. Discutiremos

PROC
isso em um capítulo separado.
KEYWORD-PARAM

A seguir estão os vários parâmetros de palavra-chave para a instrução EXEC. Você pode usar um ou mais
parâmetros com base nos requisitos e eles são separados por vírgula:

Keyword
Descrição
Parameter

Usado para fornecer dados parametrizados ao programa que está sendo executado na etapa de
trabalho. Este é um campo dependente do programa e não possui regras definidas, exceto que
o valor PARM deve ser incluído entre aspas no caso de ter caracteres especiais.
PARM
Por exemplo dado abaixo, o valor “CUST1000” é passado como um valor alfanumérico para
o programa. Se o programa estiver em COBOL, o valor passado por meio de um parâmetro
PARM em um JCL é recebido na LINKAGE SECTION do programa.
Isso é usado para especificar se a etapa do trabalho requer armazenamento virtual ou real
para execução. O armazenamento virtual é paginável, enquanto o armazenamento real não é e
é colocado na memória principal para execução. As etapas de trabalho, que exigem execução
ADDRSPC mais rápida, podem ser colocadas em armazenamento real. Segue a sintaxe:

ADDRSPC=VIRT | REAL

Quando um ADDRSPC não é codificado, VIRT é o padrão.

Isso especifica as informações de contabilidade da etapa do trabalho. Segue a sintaxe:

ACCT=(userid)
ACCT
Isso é semelhante às informações de contabilidade de parâmetros posicionais na instrução
JOB. Se estiver codificado na instrução JOB e EXEC, as informações de contabilidade na
instrução JOB se aplicarão a todas as etapas do trabalho em que um parâmetro ACCT não
estiver codificado. O parâmetro ACCT em uma instrução EXEC substituirá aquele presente
na instrução JOB somente para essa etapa de trabalho.

Parâmetros de palavras-chave comuns da instrução EXEC e JOB

Keyword
Descrição
Parameter

ADDRSPC codificado na instrução JOB substitui o ADDRSPC codificado na instrução

ADDRSPC
EXEC de qualquer etapa do trabalho.

Se TIME estiver codificado em uma instrução EXEC, ele se aplicará somente a essa etapa de
trabalho. Se for especificado na instrução JOB e EXEC, ambos entrarão em vigor e poderão
TEMPO
causar um erro de tempo limite devido a qualquer um deles. Não é recomendado usar o
parâmetro TIME na instrução JOB e EXEC juntos.

REGIÃO Se REGION estiver codificado em uma instrução EXEC, ele se aplicará somente a essa etapa
 de trabalho.

REGION codificado na instrução JOB substitui o REGION codificado na instrução EXEC de

qualquer etapa do trabalho.
Usado para controlar a execução da etapa de trabalho com base no código de retorno da etapa
anterior.
COND
Se um parâmetro COND for codificado em uma instrução EXEC de uma etapa de trabalho, o
parâmetro COND da instrução JOB (se houver) será ignorado. Os vários testes que podem
ser realizados usando um parâmetro COND são explicados em Processamento condicional.

Exemplo
A seguir está um exemplo simples de script JCL junto com instruções JOB e EXEC:

//TTYYSAMP JOB 'TUTO',CLASS=6,MSGCLASS=X,REGION=8K,

// NOTIFY=&SYSUID
//*
//STEP010 EXEC PGM=MYCOBOL,PARAM=CUST1000,
// ACCT=(XXXX),REGION=8K,ADDRSPC=REAL,TIME=1440

JCL - Declaração DD

Conjuntos de dados são arquivos de mainframe com registros organizados em um formato específico. Os
conjuntos de dados são armazenados no dispositivo de armazenamento de acesso direto (DASD) ou nas fitas
do mainframe e são áreas básicas de armazenamento de dados. Se esses dados precisarem ser usados/criados
em um programa em lote, o nome físico do arquivo (ou seja, conjunto de dados) junto com o formato e a
organização do arquivo serão codificados em um JCL.

A definição de cada conjunto de dados usado na JCL é fornecida usando a instrução DD. Os recursos de
entrada e saída necessários para uma etapa de trabalho precisam ser descritos em uma instrução DD com
informações como a organização do conjunto de dados, requisitos de armazenamento e tamanho do registro.

Sintaxe
A seguir está a sintaxe básica de uma instrução JCL DD:

//DD-name DD Parameters

Descrição
Vamos ver a descrição dos termos usados na sintaxe da instrução DD acima.

DD-NAME

Um DD-NAME identifica o conjunto de dados ou recurso de entrada/saída. Se este for um arquivo de

entrada/saída usado por um programa COBOL/Assembler, o arquivo será referenciado por esse nome no
programa.
DD

Esta é a palavra-chave para identificá-la como uma instrução DD.

PARÂMETROS

A seguir estão os vários parâmetros para a instrução DD. Você pode usar um ou mais parâmetros com base
nos requisitos e eles são separados por vírgula:

Parâmetro Descrição
O parâmetro DSN refere-se ao nome do conjunto de dados físico de um conjunto de dados
recém-criado ou existente. O valor DSN pode ser composto por subnomes de 1 a 8 caracteres de
comprimento cada um, separados por pontos e de comprimento total de 44 caracteres
(alfanuméricos). Segue a sintaxe:

DSN=Nome do conjunto de dados físicos

DSN
Conjuntos de dados temporáriosprecisam de armazenamento apenas para a duração do
trabalho e são excluídos na conclusão do trabalho. Esses conjuntos de dados são representados
como DSN=&name ou simplesmente sem um DSN especificado.

Se um conjunto de dados temporário criado por uma etapa de trabalho for usado na próxima
etapa de trabalho, ele será referenciado como DSN=*.stepname.ddname. Isso é chamado de
referência para trás.
O parâmetro DISP é usado para descrever o status do conjunto de dados, disposição no final da
etapa do trabalho na conclusão normal e anormal. O DISP não é necessário em uma instrução
DD somente quando o conjunto de dados é criado e excluído na mesma etapa de trabalho (como
os conjuntos de dados temporários). Segue a sintaxe:

DISP=(status, disposição normal, disposição anormal)

A seguir estão os valores válidos para o status:

 NEW: o conjunto de dados é recém-criado pela etapa do trabalho. OUTPUT1 no

exemplo acima.
 OLD: O conjunto de dados já foi criado e será substituído na etapa do trabalho. A etapa
de trabalho obtém acesso exclusivo ao conjunto de dados e nenhum outro trabalho pode
acessar esse conjunto de dados até a conclusão da etapa de trabalho.
DISP  SHR: O conjunto de dados já está criado e será lido na etapa do trabalho. O conjunto de
dados pode ser lido por vários trabalhos ao mesmo tempo. Exemplo: ENTRADA1 e
ENTRADA2.
 MOD: o conjunto de dados já foi criado. Essa disposição será usada quando houver
necessidade de anexar novos registros ao conjunto de dados existente (os registros
existentes não serão substituídos).

Um parâmetro de disposição normal pode ter um dos seguintes valores

 CATLG, UNCATLG, DELETE, PASS e KEEP

Um parâmetro de disposição anormal pode ter um dos seguintes valores

 CATLG, UNCATLG, DELETE e KEEP

 Aqui está a descrição dos parâmetros CATLG, UNCATLG, DELETE, PASS e KEEP:

 CATLG: O conjunto de dados é retido com uma entrada no catálogo do sistema.

 UNCATLG: O conjunto de dados é retido, mas a entrada do catálogo do sistema é
removida.
 KEEP: O conjunto de dados é retido sem alterar nenhuma das entradas do catálogo.
KEEP é a única disposição válida para arquivos VSAM. Isso deve ser usado apenas para
conjuntos de dados permanentes.
 DELETE: O conjunto de dados é excluído do catálogo do usuário e do sistema.
 PASS: Isso é válido apenas para disposição normal. Isso é usado quando o conjunto de
dados deve ser passado e processado pela próxima etapa do trabalho em um JCL

Quando algum dos subparâmetros de DISP não é especificado, os valores padrão são os
seguintes:

 status: NEW é o valor padrão.

 normal-disposition: Se o status for NEW, a disposição normal padrão é DELETE, caso
contrário, é KEEP.
 abnormal-disposition: O mesmo que disposição normal.

O parâmetro Data Control Block (DCB) detalha as características físicas de um conjunto de

dados. Esse parâmetro é necessário para conjuntos de dados recém-criados na etapa de trabalho.

LRECL é o comprimento de cada registro contido no conjunto de dados.

RECFM é o formato de registro do conjunto de dados. RECFM pode conter valores FB, V ou
VB. FB é uma organização de bloco fixo onde um ou mais registros lógicos são agrupados em
um único bloco. V é a organização variável onde um registro lógico de comprimento variável é
colocado dentro de um bloco físico. VB é uma organização de bloco variável onde um ou mais
registros lógicos de comprimento variável são colocados dentro de um bloco físico.
DCB
BLKSIZE é o tamanho do bloco físico. Quanto maior o bloco, maior é o número de registros
para um arquivo FB ou VB.

DSORG é o tipo de organização de conjunto de dados. DSORG pode conter valores PS

(Physical Sequential), PO (Partitioned Organization) e DA (Direct Organization).

Quando há a necessidade de replicar os valores DCB de um conjunto de dados para outro dentro
do mesmo jobstep ou JCL, ele é especificado como DCB=*.stepname.ddname em que stepname
é o nome da etapa do job e ddname é o conjunto de dados do qual o DCB é copiado.

Confira o exemplo abaixo onde RECFM=FB,LRECL=80 forma o DCB do dataset OUTPUT1.

O parâmetro SPACE especifica o espaço necessário para o conjunto de dados no DASD (Direct
Access Storage Disk). Segue a sintaxe:

SPACE=(spcunits, (pri, sec, dir), RLSE)

Aqui está a descrição de todos os parâmetros usados:

SPACE
 spcunits: Este pode ser um dos CYL(Cilindro), TRK(Faixas) ou BLKSIZE(Tamanho do
bloco).
 pri: este é o espaço primário necessário para o conjunto de dados.
 sec: Este é o espaço adicional necessário, quando o espaço primário não está sendo
suficiente.
  ir: estes são os blocos de diretório necessários, se o conjunto de dados for um PDS
(conjunto de dados particionado) com membros dentro dele.
 RLSE: Isso é usado para liberar o espaço não utilizado na conclusão do trabalho.

Os parâmetros UNIT e VOL são listados no catálogo do sistema para conjuntos de dados
catalogados e, portanto, podem ser acessados apenas com o nome DSN físico. Mas para
conjuntos de dados não catalogados, a instrução DD deve incluir esses parâmetros. Para que
novos conjuntos de dados sejam criados, os parâmetros UNIT/VOL podem ser especificados ou
o Z/OS aloca o dispositivo e o volume adequados.

O parâmetro UNIT especifica o tipo de dispositivo no qual o conjunto de dados está

UNIT
armazenado. O tipo de dispositivo pode ser identificado usando o endereço de hardware ou o
grupo de tipo de dispositivo. Segue a sintaxe:

UNIDADE=DASD | SYSDA

Onde DASD significa Direct Access Storage Device e SYSDA significa System Direct Access
e refere-se ao próximo dispositivo de armazenamento em disco disponível.
O parâmetro VOL especifica o número do volume no dispositivo identificado pelo parâmetro
UNIT. Segue a sintaxe:

VOL=SER=(v1,v2)

VOL Onde v1, v2 são números de série do volume. Você também pode usar a seguinte sintaxe:

VOL=REF=*.DDNAME

Em que REF é a referência inversa ao número de série do volume de um conjunto de dados em

qualquer uma das etapas de trabalho anteriores na JCL.
Os parâmetros da instrução DD discutidos até agora correspondem aos dados armazenados em
um conjunto de dados. O parâmetro SYSOUT direciona os dados para o dispositivo de saída
com base na classe especificada. Segue a sintaxe
SYSOUT
SYSOUT=class

Onde se a classe for A, ela direcionará a saída para a impressora e, se a classe for *, ela
direcionará a saída para o mesmo destino do parâmetro MSGCLASS na instrução JOB.

Exemplo
A seguir está um exemplo, que faz uso de instruções DD junto com vários parâmetros explicados acima:

//TTYYSAMP JOB 'TUTO',CLASS=6,MSGCLASS=X,REGION=8K,

// NOTIFY=&SYSUID
//*
//STEP010 EXEC PGM=ICETOOL,ADDRSPC=REAL
//*
//INPUT1 DD DSN=TUTO.SORT.INPUT1,DISP=SHR
//INPUT2 DD DSN=TUTO.SORT.INPUT2,DISP=SHR,UNIT=SYSDA,
// VOL=SER=(1243,1244)
//OUTPUT1 DD DSN=MYFILES.SAMPLE.OUTPUT1,DISP=(,CATLG,DELETE),
// RECFM=FB,LRECL=80,SPACE=(CYL,(10,20))
//OUTPUT2 DD SYSOUT=*
JCL – Bibliotecã Bãse (bãse librãry)
Biblioteca básica: é o Partitioned Dataset (PDS), que contém os módulos de carga do programa a ser
executado na JCL ou o procedimento catalogado, que é chamado no programa. As bibliotecas base podem
ser especificadas para toda a JCL em uma biblioteca JOBLIB ou para uma etapa de trabalho específica em
uma instrução STEPLIB.

Declaração de JOBLIB (Statement)

Uma instrução JOBLIB é usada para identificar a localização do programa a ser executado em uma JCL. A
instrução JOBLIB é especificada após a instrução JOB e antes da instrução EXEC. Isso pode ser usado
apenas para os procedimentos e programas em fluxo.

Sintaxe
A seguir está a sintaxe básica de uma instrução JCL JOBLIB:

//JOBLIB DD DSN=dsnname,DISP=SHR

A instrução JOBLIB é aplicável a todas as instruções EXEC dentro da JCL. O programa especificado na
instrução EXEC será pesquisado na biblioteca JOBLIB seguido pela biblioteca do sistema.

Por exemplo, se a instrução EXEC estiver executando um programa COBOL, o módulo de carregamento do
programa COBOL deve ser colocado na biblioteca JOBLIB.

Declaração STEPLIB
Uma instrução STEPLIB é usada para identificar a localização do programa a ser executado dentro de um
Job Step. A instrução STEPLIB é especificada após a instrução EXEC e antes da instrução DD da etapa da
tarefa.

Sintaxe
A seguir está a sintaxe básica de uma instrução JCL STEPLIB:

//STEPLIB DD DSN=dsnname,DISP=SHR

O programa especificado na instrução EXEC será pesquisado na biblioteca STEPLIB seguido pela
biblioteca do sistema. STEPLIB codificado em uma etapa de trabalho substitui a instrução JOBLIB.

Exemplo
O exemplo a seguir mostra o uso de instruções JOBLIB e STEPLIB:

//MYJCL JOB ,,CLASS=6,NOTIFY=&SYSUID

//*
//JOBLIB DD DSN=MYPROC.BASE.LIB1,DISP=SHR
//*
//STEP1 EXEC PGM=MYPROG1
//INPUT1 DD DSN=MYFILE.SAMPLE.INPUT1,DISP=SHR
//OUTPUT1 DD DSN=MYFILES.SAMPLE.OUTPUT1,DISP=(,CATLG,DELETE),
// RECFM=FB,LRECL=80
//*
//STEP2 EXEC PGM=MYPROG2
//STEPLIB DD DSN=MYPROC.BASE.LIB2,DISP=SHR
//INPUT2 DD DSN=MYFILE.SAMPLE.INPUT2,DISP=SHR
//OUTPUT2 DD DSN=MYFILES.SAMPLE.OUTPUT2,DISP=(,CATLG,DELETE),
// RECFM=FB,LRECL=80

Aqui, o módulo de carregamento do programa MYPROG1 (em STEP1) é pesquisado em

MYPROC.SAMPLE.LIB1. Se não for encontrado, é procurado na biblioteca do sistema. No STEP2, o
STEPLIB substitui o JOBLIB e o módulo de carregamento do programa MYPROG2 é pesquisado em
MYPROC.SAMPLE.LIB2 e depois na biblioteca do sistema.

INCLUDE Statement
Um conjunto de instruções JCL codificadas em um membro de um PDS pode ser incluído em um JCL
usando uma instrução INCLUDE. Quando o JES interpreta o JCL, o conjunto de instruções JCL no membro
INCLUDE substitui a instrução INCLUDE.

Sintaxe
A seguir está a sintaxe básica de uma instrução JCL INCLUDE:

//name INCLUDE MEMBER=member-name

O objetivo principal da instrução INCLUDE é a reutilização. Por exemplo, arquivos comuns a serem usados
em muitas JCLs podem ser codificados como instruções DD no membro INCLUDE e usados em uma JCL.

Instruções DD fictícias, especificações de cartão de dados, instruções PROCs, JOB, PROC não podem ser
codificadas em um membro INCLUDE. Uma instrução INLCUDE pode ser codificada em um membro
INCLUDE e aninhamento adicional pode ser feito em até 15 níveis.

Declaração JCLLIB
Uma instrução JCLLIB é usada para identificar as bibliotecas privadas usadas na tarefa. Pode ser usado
tanto com procedimentos instream quanto catalogados.

Sintaxe
A seguir está a sintaxe básica de uma instrução JCL JCLLIB:

//name JCLLIB ORDER=(library1, library2....)

As bibliotecas especificadas na instrução JCLLIB serão pesquisadas na ordem indicada para localizar os
programas, procedimentos e membros INCLUDE usados no trabalho. Pode haver apenas uma instrução
JCLLIB em uma JCL; especificado após uma instrução JOB e antes da instrução EXEC e INCLUDE, mas
não pode ser codificado em um membro INCLUDE.

Exemplo
No exemplo a seguir, o programa MYPROG3 e o membro INCLUDE MYINCL são pesquisados na ordem
de MYPROC.BASE.LIB1, MYPROC.BASE.LIB2, biblioteca do sistema.

//MYJCL JOB ,,CLASS=6,NOTIFY=&SYSUID

//*
//MYLIB JCLLIB ORDER=(MYPROC.BASE.LIB1,MYPROC.BASE.LIB2)
//*
//STEP1 EXEC PGM=MYPROG3
//INC INCLUDE MEMBER=MYINCL
//OUTPUT1 DD DSN=MYFILES.SAMPLE.OUTPUT1,DISP=(,CATLG,DELETE),
// RECFM=FB,LRECL=80
//*
JCL – Procedimentos
Os procedimentos JCL são conjuntos de instruções dentro de um JCL agrupados para executar uma função
específica. Normalmente, a parte fixa do JCL é codificada em um procedimento. A parte variável do
trabalho é codificada dentro da JCL.

Você pode usar um procedimento para obter a execução paralela de um programa usando vários arquivos de
entrada. Um JCL pode ser criado para cada arquivo de entrada e um único procedimento pode ser chamado
simultaneamente passando o nome do arquivo de entrada como um parâmetro simbólico.

Sintaxe
A seguir está a sintaxe básica de uma definição de procedimento JCL:

//*
//Step-name EXEC procedure name

O conteúdo do procedimento é mantido no JCL para um procedimento instream. O conteúdo é mantido em

um membro diferente da biblioteca base para um procedimento catalogado. Este capítulo explicará dois
tipos de procedimentos disponíveis em JCL e, finalmente, veremos como podemos aninhar vários
procedimentos.

Procedimento Instream (Instream Procedure)

Quando o procedimento é codificado no mesmo membro JCL, ele é chamado de Procedimento Instream. Ele
deve começar com uma instrução PROC e terminar com uma instrução PEND.

//SAMPINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID

//*
//INSTPROC PROC //*START OF PROCEDURE
//PROC1 EXEC PGM=SORT
//SORTIN DD DSN=&DSNAME,DISP=SHR
//SORTOUT DD SYSOUT=*MYINCL
//SYSOUT DD SYSOUT=*
//SYSIN DD DSN=&DATAC LRECL=80
// PEND //*END OF PROCEDURE
//*
//STEP1 EXEC INSTPROC,DSNME=MYDATA.URMI.INPUT1,
// DATAC=MYDATA.BASE.LIB1(DATA1)
//*
//STEP2 EXEC INSTPROC,DSNME=MYDATA.URMI.INPUT2
// DATAC=MYDATA.BASE.LIB1(DATA1)
//*

No exemplo acima, o procedimento INSTPROC é chamado em STEP1 e STEP2 usando arquivos de entrada
diferentes. Os parâmetros DSNAME e DATAC podem ser codificados com diferentes valores ao chamar o
procedimento e estes são chamados como parâmetros simbólicos. A entrada variável para o JCL, como
nomes de arquivos, cartões de dados, valores PARM, etc., são passados como parâmetros simbólicos para
procedimentos.

Ao codificar parâmetros simbólicos, não use PALAVRAS-CHAVE, PARÂMETROS ou

SUBPARÂMETROS como nomes simbólicos. Exemplo: Não use TIME=&TIME, mas sim, você pode usar
TIME=&TM e é assumido como uma maneira correta de codificar simbólicos.

Os parâmetros simbólicos definidos pelo usuário são chamados de Símbolos JCL. Existem certos símbolos
chamados símbolos do sistema, que são usados para execuções de tarefas de logon. O único símbolo do
sistema usado em trabalhos em lote por usuários normais é &SYSUID e é usado no parâmetro NOTIFY na
instrução JOB.

Procedimento catalogado (Cataloged Procedure)

Quando o procedimento é separado do JCL e codificado em um armazenamento de dados diferente, ele é
chamado de Procedimento Catalogado. Uma declaração PROC não é obrigatória para ser codificada em um
procedimento catalogado. A seguir está um exemplo de JCL onde está chamando o procedimento
CATLPROC:

//SAMPINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID

//*
//STEP EXEC CATLPROC,PROG=CATPRC1,DSNME=MYDATA.URMI.INPUT
// DATAC=MYDATA.BASE.LIB1(DATA1)

Aqui, o procedimento CATLPROC é catalogado em MYCOBOL.BASE.LIB1. PROG,DATAC e DSNAME

são passados como parâmetros simbólicos para o procedimento CATLPROC.

//CATLPROC PROC PROG=,BASELB=MYCOBOL.BASE.LIB1

//*
//PROC1 EXEC PGM=&PROG
//STEPLIB DD DSN=&BASELB,DISP=SHR
//IN1 DD DSN=&DSNAME,DISP=SHR
//OUT1 DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN DD DSN=&DATAC
//*

Dentro do procedimento, os parâmetros simbólicos PROG e BASELB são codificados. Observe que o
parâmetro PROG dentro do procedimento é substituído pelo valor no JCL e, portanto, o PGM assume o
valor CATPRC1 durante a execução.

Procedimentos aninhados (Nested Procedures)

Chamar um procedimento de dentro de um procedimento é chamado de procedimento aninhado. Os
procedimentos podem ser aninhados em até 15 níveis. O aninhamento pode ser completamente in-stream ou
catalogado. Não podemos codificar um procedimento instream dentro de um procedimento catalogado.

//SAMPINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID

//*
//SETNM SET DSNM1=INPUT1,DSNM2=OUTPUT1
//INSTPRC1 PROC //* START OF PROCEDURE 1
//STEP1 EXEC PGM=SORT,DISP=SHR
//SORTIN DD DSN=&DSNM1,DISP=SHR
//SORTOUT DD DSN=&DSNM2,DISP=(,PASS)
//SYSOUT DD SYSOUT=*
//SYSIN DD DSN=&DATAC
//*
//STEP2 EXEC PROC=INSTPRC2,DSNM2=MYDATA.URMI.OUTPUT2
// PEND //* END OF PROCEDURE 1
//*
//INSTPRC2 PROC //* START OF PROCEDURE 2
//STEP1 EXEC PGM=SORT
//SORTIN DD DSN=*.INSTPRC1.STEP1.SORTOUT
//SORTOUT DD DSN=&DSNM2,DISP=OLD
//SYSOUT DD SYSOUT=*
//SYSIN DD DSN=&DATAC
// PEND //* END OF PROCEDURE 2
//*
//JSTEP1 EXEC INSTPRC1,DSNM1=MYDATA.URMI.INPUT1,
// DATAC=MYDATA.BASE.LIB1(DATA1)
//*

No exemplo acima, a JCL chama o procedimento INSTPRC1 em JSTEP1 e o procedimento INSTPRC2 está
sendo chamado dentro do procedimento INSTPRC1. Aqui, a saída de INSTPRC1 (SORTOUT) é passada
como entrada (SORTIN) para INSTPRC2.

Uma instrução SET é usada para definir símbolos comumente usados em etapas ou procedimentos de
trabalho. Inicializa os valores anteriores nos nomes simbólicos. Ele deve ser definido antes do primeiro uso
dos nomes simbólicos na JCL.

Vamos dar uma olhada na descrição abaixo para entender um pouco mais sobre o programa acima:

 O parâmetro SET inicializa DSNM1=INPUT1 e DSNM2=OUTPUT1.

 Quando INSTPRC1 é chamado em JSTEP1 de JCL, DSNM1=MYDATA.URMI.INPUT1 e
DSNM2=OUTPUT1., ou seja, o valor inicializado na instrução SET é redefinido com o valor
configurado em qualquer uma das etapas/procedimentos da tarefa.
 Quando INSTPRC2 é chamado em STEP2 de INSTPRC1, DSNM1=MYDATA.URMI.INPUT1 e
DSNM2=MYDATA.URMI.OUTPUT2.
JCL – Processãmento Condicionãl (Conditionãl
Processing)
O Job Entry System usa duas abordagens para realizar o processamento condicional em um JCL. Quando
um trabalho é concluído, um código de retorno é definido com base no status de execução. O código de
retorno pode ser um número entre 0 (execução bem-sucedida) a 4095 (não-zero mostra condição de erro).
Os valores convencionais mais comuns são:

 0 = Normal – tudo OK
 4 = Aviso – pequenos erros ou problemas.
 8 = Erro – erros ou problemas significativos.
 12 = Erro grave – grandes erros ou problemas, os resultados não devem ser confiáveis.
 16 = Erro de terminal – problemas muito sérios, não use os resultados.

A execução de uma etapa de trabalho pode ser controlada com base no código de retorno da(s) etapa(s)
anterior(es) usando o parâmetro COND e a construção IF-THEN-ELSE, que foi explicada neste tutorial.

Parâmetro COND
Um parâmetro COND pode ser codificado na instrução JOB ou EXEC de JCL. É um teste no código de
retorno das etapas de trabalho anteriores. Se o teste for avaliado como verdadeiro, a execução da etapa de
trabalho atual será ignorada. Ignorar é apenas omissão da etapa de trabalho e não um término anormal. Pode
haver no máximo oito condições combinadas em um único teste.

Sintaxe
A seguir está a sintaxe básica de um parâmetro JCL COND:

COND=(rc,logical-operator)
or
COND=(rc,logical-operator,stepname)
or
COND=EVEN
or
COND=ONLY

Aqui está a descrição dos parâmetros usados:

 rc: Este é o código de retorno

 logical-operator : Pode ser GT (maior que), GE (maior que ou igual a), EQ (igual a), LT (menor
que), LE (menor que ou igual a) ou NE (diferente de).
 stepname: Esta é a etapa do trabalho cujo código de retorno é usado no teste.

As duas últimas condições (a) COND=EVEN e (b) COND=ONLY foram explicadas abaixo neste tutorial.

O COND pode ser codificado dentro da instrução JOB ou da instrução EXEC e, em ambos os casos, ele se
comporta de maneira diferente, conforme explicado abaixo:
COND dentro da instrução JOB
Quando COND é codificado na instrução JOB, a condição é testada para cada etapa da tarefa. Quando a
condição é verdadeira em qualquer etapa de trabalho específica, ela é ignorada junto com as etapas de
trabalho que a seguem. Segue um exemplo:

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID,COND=(5,LE)

//*
//STEP10 EXEC PGM=FIRSTP
//* STEP10 executes without any test being performed.

//STEP20 EXEC PGM=SECONDP

//* STEP20 is bypassed, if RC of STEP10 is 5 or above.
//* Say STEP10 ends with RC4 and hence test is false.
//* So STEP20 executes and lets say it ends with RC16.

//STEP30 EXEC PGM=SORT

//* STEP30 is bypassed since 5 <= 16.

COND dentro da instrução EXEC

Quando COND é codificado na instrução EXEC de uma etapa de trabalho e considerado verdadeiro,
somente essa etapa de trabalho é ignorada e a execução continua a partir da próxima etapa de trabalho.

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID

//*
//STP01 EXEC PGM=SORT
//* Assuming STP01 ends with RC0.

//STP02 EXEC PGM=MYCOBB,COND=(0,EQ,STP01)

//* In STP02, condition evaluates to TRUE and step bypassed.

//STP03 EXEC PGM=IEBGENER,COND=((10,LT,STP01),(10,GT,STP02))

//* In STP03, first condition fails and hence STP03 executes.
//* Since STP02 is bypassed, the condition (10,GT,STP02) in
//* STP03 is not tested.

COND=EVEN

Quando COND=EVEN é codificado, a etapa de trabalho atual é executada, mesmo se qualquer uma das
etapas anteriores terminar de forma anormal. Se qualquer outra condição RC for codificada junto com
COND=EVEN, a etapa de trabalho será executada se nenhuma das condições RC for verdadeira.

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID

//*
//STP01 EXEC PGM=SORT
//* Assuming STP01 ends with RC0.

//STP02 EXEC PGM=MYCOBB,COND=(0,EQ,STP01)

//* In STP02, condition evaluates to TRUE and step bypassed.

//STP03 EXEC PGM=IEBGENER,COND=((10,LT,STP01),EVEN)

//* In STP03, condition (10,LT,STP01) evaluates to true,
//* hence the step is bypassed.
COND=ONLY

Quando COND=ONLY é codificado, a etapa de trabalho atual é executada, somente quando qualquer uma
das etapas anteriores termina de forma anormal. Se qualquer outra condição RC for codificada juntamente
com COND=ONLY, a etapa de trabalho será executada se nenhuma das condições RC for verdadeira e
qualquer uma das etapas de trabalho anteriores falhar de forma anormal.

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID

//*
//STP01 EXEC PGM=SORT
//* Assuming STP01 ends with RC0.

//STP02 EXEC PGM=MYCOBB,COND=(4,EQ,STP01)

//* In STP02, condition evaluates to FALSE, step is executed
//* and assume the step abends.

//STP03 EXEC PGM=IEBGENER,COND=((0,EQ,STP01),ONLY)

//* In STP03, though the STP02 abends, the condition
//* (0,EQ,STP01) is met. Hence STP03 is bypassed.

IF-THEN-ELSE Construct
Outra abordagem para controlar o processamento do trabalho é usando construções IF-THEN-ELSE. Isso dá
mais flexibilidade e uma maneira amigável de processamento condicional.

Sintaxe
A seguir está a sintaxe básica de uma construção JCL IF-THEN-ELSE:

//name IF condition THEN

list of statements //* action to be taken when condition is true
//name ELSE
list of statements //* action to be taken when condition is false
//name ENDIF

A seguir está a descrição dos termos usados na construção IF-THEN-ELSE acima:

 name: Isso é opcional e um nome pode ter de 1 a 8 caracteres alfanuméricos começando com
alfabeto, #,$ ou @.
 Condition: Uma condição terá um formato: KEYWORD OPERATOR VALUE, onde as
KEYWORDS podem ser RC (Código de Retorno), ABENDCC (Código de conclusão do sistema ou
usuário), ABEND, RUN (execução da etapa iniciada). Um OPERADOR pode ser operador lógico
(AND (&), OR (|)) ou operador relacional (<, <=, >, >=, <>).

Exemplo
A seguir está um exemplo simples mostrando o uso de IF-THEN-ELSE:

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID

//*
//PRC1 PROC
//PST1 EXEC PGM=SORT
//PST2 EXEC PGM=IEBGENER
// PEND
//STP01 EXEC PGM=SORT
//IF1 IF STP01.RC = 0 THEN
//STP02 EXEC PGM=MYCOBB1,PARM=123
// ENDIF
//IF2 IF STP01.RUN THEN
//STP03a EXEC PGM=IEBGENER
//STP03b EXEC PGM=SORT
// ENDIF
//IF3 IF STP03b.!ABEND THEN
//STP04 EXEC PGM=MYCOBB1,PARM=456
// ELSE
// ENDIF
//IF4 IF (STP01.RC = 0 & STP02.RC <= 4) THEN
//STP05 EXEC PROC=PRC1
// ENDIF
//IF5 IF STP05.PRC1.PST1.ABEND THEN
//STP06 EXEC PGM=MYABD
// ELSE
//STP07 EXEC PGM=SORT
// ENDIF

Vamos tentar analisar o programa acima para entendê-lo com um pouco mais de detalhes:

 O código de retorno de STP01 é testado em IF1. Se for 0, então STP02 é executado. Caso contrário,
o processamento vai para a próxima instrução IF (IF2).
 Em IF2, se STP01 iniciou a execução, então STP03a e STP03b são executados.
 Em IF3, se STP03b não ABEND, então STP04 é executado. Em ELSE, não há declarações. Ela é
chamada de instrução NULL ELSE.
 Em IF4, se STP01.RC = 0 e STP02.RC <=4 forem TRUE, então STP05 será executado.
 Em IF5, se o proc-step PST1 no PROC PRC1 no jobstep STP05 ABEND, então STP06 é executado.
Caso contrário, STP07 é executado.
 Se IF4 for avaliado como falso, o STP05 não será executado. Nesse caso, IF5 não são testados e as
etapas STP06, STP07 não são executadas.

O IF-THEN-ELSE não será executado no caso de encerramento anormal do trabalho, como o usuário
cancelando o trabalho, expiração do tempo de trabalho ou um conjunto de dados é referenciado para trás a
uma etapa que é ignorada.

Definindo pontos de verificação (Checkpoints)

Você pode definir o conjunto de dados de ponto de verificação dentro de seu programa JCL usando
SYSCKEOV, que é uma instrução DD.

Um CHKPT é o parâmetro codificado para conjuntos de dados QSAM de vários volumes em uma instrução
DD. Quando um CHKPT é codificado como CHKPT=EOV, um ponto de verificação é gravado no conjunto
de dados especificado na instrução SYSCKEOV no final de cada volume do conjunto de dados de vários
volumes de entrada/saída.

//CHKSAMP JOB CLASS=6,NOTIFY=&SYSUID

//*
//STP01 EXEC PGM=MYCOBB
//SYSCKEOV DD DSNAME=SAMPLE.CHK,DISP=MOD
//IN1 DD DSN=SAMPLE.IN,DISP=SHR
//OUT1 DD DSN=SAMPLE.OUT,DISP=(,CATLG,CATLG)
// CHKPT=EOV,LRECL=80,RECFM=FB

No exemplo acima, um ponto de verificação é escrito no conjunto de dados SAMPLE.CHK no final de cada
volume do conjunto de dados de saída SAMPLE.OUT.
Reiniciar processamento
Você pode reiniciar o processamento de éter de forma automatizada usando o parâmetro RD ou manual
usando o parâmetro RESTART.

Parâmetro RD é codificado na instrução JOB ou EXEC e ajuda na reinicialização automatizada de

JOB/STEP e pode conter um dos quatro valores: R, RNC, NR ou NC.

 RD=R: permite reinicializações automatizadas e considera o ponto de verificação codificado no

parâmetro CHKPT da instrução DD.
 RD=RNC: permite reinicializações automatizadas, mas substitui (ignora) o parâmetro CHKPT.
 RD=NR: especifica que o trabalho/etapa não pode ser reiniciado automaticamente. Mas quando for
reiniciado manualmente usando o parâmetro RESTART, o parâmetro CHKPT (se houver) será
considerado.
 RD=NC: não permite a reinicialização automatizada e o processamento de ponto de verificação.

Se houver um requisito para fazer a reinicialização automatizada apenas para códigos de encerramento
anormal específicos, ele poderá ser especificado no membro SCHEDxx da biblioteca parmlib do sistema
IBM.

Parâmetro REINICIAR: é codificado na instrução JOB ou EXEC e ajuda na reinicialização manual do

JOB/STEP após a falha do trabalho. RESTART pode ser acompanhado por um checkid, que é o ponto de
verificação escrito no conjunto de dados codificado na instrução SYSCKEOV DD. Quando um checkid é
codificado, a instrução SYSCHK DD deve ser codificada para referenciar o conjunto de dados do ponto de
verificação após a instrução JOBLIB (se houver), senão após a instrução JOB.

//CHKSAMP JOB CLASS=6,NOTIFY=&SYSUID,RESTART=(STP01,chk5)

//*
//SYSCHK DD DSN=SAMPLE.CHK,DISP=OLD
//STP01 EXEC PGM=MYCOBB
//*SYSCKEOV DD DSNAME=SAMPLE.CHK,DISP=MOD
//IN1 DD DSN=SAMPLE.IN,DISP=SHR
//OUT1 DD DSN=SAMPLE.OUT,DISP=(,CATLG,CATLG)
// CHKPT=EOV,LRECL=80,RECFM=FB

No exemplo acima, chk5 é o checkid, ou seja, STP01 é reiniciado no checkpoint5. Observe que uma
instrução SYSCHK é adicionada e a instrução SYSCKEOV é comentada no programa anterior explicado na
seção Definindo o ponto de verificação.
JCL – Definindo conjuntos de dãdos (Dãtãsets)
Um nome de conjunto de dados especifica o nome de um arquivo e é indicado por DSN em JCL. O
parâmetro DSN refere-se ao nome do conjunto de dados físico de um conjunto de dados recém-criado ou
existente. O valor DSN pode ser composto por subnomes de 1 a 8 caracteres de comprimento cada um,
separados por pontos e de comprimento total de 44 caracteres (alfanuméricos). Segue a sintaxe:

DSN=&name | *.stepname.ddname

Conjuntos de dados temporários precisam de armazenamento apenas para a duração do trabalho e são
excluídos na conclusão do trabalho. Esses conjuntos de dados são representados como DSN=&name ou
simplesmente sem um DSN especificado.

Se um conjunto de dados temporário criado por uma etapa de trabalho for usado na próxima etapa de
trabalho, ele será referenciado como DSN=*.stepname.ddname. Isso é chamado de referência para trás.

Concatenar conjuntos de dados

Se houver mais de um conjunto de dados do mesmo formato, eles podem ser concatenados e passados como
entrada para o programa em um único nome DD.

//CONCATEX JOB CLASS=6,NOTIFY=&SYSUID

//*
//STEP10 EXEC PGM=SORT
//SORTIN DD DSN=SAMPLE.INPUT1,DISP=SHR
// DD DSN=SAMPLE.INPUT2,DISP=SHR
// DD DSN=SAMPLE.INPUT3,DISP=SHR
//SORTOUT DD DSN=SAMPLE.OUTPUT,DISP=(,CATLG,DELETE),
// LRECL=50,RECFM=FB

No exemplo acima, três conjuntos de dados são concatenados e passados como entrada para o programa
SORT no nome SORTIN DD. Os arquivos são mesclados, classificados nos campos-chave especificados e,
em seguida, gravados em um único arquivo de saída SAMPLE.OUTPUT no nome SORTOUT DD.

Substituindo conjuntos de dados (Overriding Datasets)

Em um JCL padronizado, o programa a ser executado e seus conjuntos de dados relacionados são colocados
em um procedimento catalogado, que é chamado no JCL. Normalmente, para fins de teste ou correção de
incidentes, pode haver a necessidade de usar conjuntos de dados diferentes dos especificados no
procedimento catalogado. Nesse caso, o conjunto de dados no procedimento pode ser substituído no JCL.

//SAMPINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID

//*
//JSTEP1 EXEC CATLPROC,PROG=CATPRC1,DSNME=MYDATA.URMI.INPUT
// DATAC=MYDATA.BASE.LIB1(DATA1)
//STEP1.IN1 DD DSN=MYDATA.OVER.INPUT,DISP=SHR
//*
//* The cataloged procedure is as below:
//*
//CATLPROC PROC PROG=,BASELB=MYCOBOL.BASE.LIB1
//*
//STEP1 EXEC PGM=&PROG
//STEPLIB DD DSN=&BASELB,DISP=SHR
//IN1 DD DSN=MYDATA.URMI.INPUT,DISP=SHR
//OUT1 DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN DD MYDATA.BASE.LIB1(DATA1),DISP=SHR
//*
//STEP2 EXEC PGM=SORT

No exemplo acima, o conjunto de dados IN1 usa o arquivo MYDATA.URMI.INPUT no PROC, que é
substituído no JCL. Portanto, o arquivo de entrada usado na execução é MYDATA.OVER.INPUT. Observe
que o conjunto de dados é referido como STEP1.IN1. Se houver apenas uma etapa no JCL/PROC, o
conjunto de dados poderá ser referido apenas com o nome DD. Da mesma forma, se houver mais de uma
etapa no JCL, o conjunto de dados deverá ser substituído como JSTEP1.STEP1.IN1.

//SAMPINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID

//*
//STEP EXEC CATLPROC,PROG=CATPRC1,DSNME=MYDATA.URMI.INPUT
// DATAC=MYDATA.BASE.LIB1(DATA1)
//STEP1.IN1 DD DSN=MYDATA.OVER.INPUT,DISP=SHR
// DD DUMMY
// DD DUMMY
//*

No exemplo acima, dos três conjuntos de dados concatenados em IN1, o primeiro é sobrescrito no JCL e o
restante é mantido como o presente no PROC.

Definindo GDGs em um JCL

Grupos de dados de geração (Generation Data Groups GDGs) são grupos de conjuntos de dados
relacionados entre si por um nome comum. O nome comum é referido como base GDG e cada conjunto de
dados associado à base é chamado de versão GDG.

Por exemplo, MYDATA.URMI.SAMPLE.GDG é o nome base do GDG. Os conjuntos de dados são

nomeados como MYDATA.URMI.SAMPLE.GDG.G0001V00,
MYDATA.URMI.SAMPLE.GDG.G0002V00 e assim por diante. A versão mais recente do GDG é referida
como MYDATA.URMI.SAMPLE.GDG(0), as versões anteriores são referidas como (-1), (-2) e assim por
diante. A próxima versão a ser criada em um programa é referenciada como
MYDATA.URMI.SAMPLE.GDG(+1) na JCL.

Criar/Alterar GDG em um JCL

As versões GDG podem ter parâmetros DCB iguais ou diferentes. Um DCB de modelo inicial pode ser
definido para ser usado por todas as versões, mas pode ser substituído ao criar novas versões.

//GDGSTEP1 EXEC PGM=IDCAMS

//SYSPRINT DD SYSOUT=*
//SYSIN DD *
DEFINE GDG(NAME(MYDATA.URMI.SAMPLE.GDG) -
LIMIT(7) -
NOEMPTY -
SCRATCH)
/*
//GDGSTEP2 EXEC PGM=IEFBR14
//GDGMODLD DD DSN=MYDATA.URMI.SAMPLE.GDG,
// DISP=(NEW,CATLG,DELETE),
// UNIT=SYSDA,
// SPACE=(CYL,10,20),
// DCB=(LRECL=50,RECFM=FB)
//

No exemplo acima, o utilitário IDCAMS define a base GDG em GDGSTEP1 com os parâmetros abaixo
passados na instrução SYSIN DD:

 NAME especifica o nome do conjunto de dados físico da base GDG.

 LIMIT especifica o número máximo de versões que a base GDG pode conter.
 EMPTY descataloga todas as gerações quando o LIMIT é atingido.
 NOEMPTY não cataloga a geração menos recente.
 SCRATCH exclui fisicamente a geração quando não está catalogada.
 NOSCRATCH não exclua o conjunto de dados, ou seja, ele pode ser referenciado usando os
parâmetros UNIT e VOL.

No GDGSTEP2, o utilitário IEFBR14 especifica os parâmetros do modelo DD a serem usados por todas as
versões.

IDCAMS pode ser usado para alterar os parâmetros de definição de um GDG como aumentar LIMIT, mudar
EMPTY para NOEMPTY, etc., e suas versões relacionadas usando o comando SYSIN é ALTER
MYDATA.URMI.SAMPLE.GDG LIMIT(15) EMPTY.

Excluir GDG em um JCL

Usando o utilitário IEFBR14, podemos excluir uma única versão de um GDG.

//GDGSTEP3 EXEC PGM=IEFBR14

//GDGDEL DD DSN=MYDATA.URMI.SAMPLE.GDG(0),
// DISP=(OLD,DELETE,DELETE)

No exemplo acima, a versão mais recente de MYDATA.URMI.SAMPLE.GDG foi excluída. Observe que o
parâmetro DISP na conclusão normal do trabalho é codificado como DELETE. Portanto, o conjunto de
dados é excluído quando o trabalho conclui a execução.

IDCAMS pode ser usado para excluir o GDG e suas versões relacionadas usando o comando SYSIN
DELETE(MYDATA.URMI.SAMPLE.GDG) GDG FORCE/PURGE.

 FORCE exclui as versões GDG e a base GDG. Se qualquer uma das versões do GDG estiver
definida com uma data de expiração que ainda não expirou, elas não serão excluídas e, portanto, a
base do GDG será mantida.
 PURGE exclui as versões GDG e a base GDG, independentemente da data de expiração.

Usando GDG em um JCL

No exemplo a seguir, a versão mais recente de MYDATA.URMI.SAMPLE.GDG é usada como entrada para
o programa e uma nova versão de MYDATA.URMI.SAMPLE.GDG é criada como saída.

//CNDSAMP JOB CLASS=6,NOTIFY=&SYSUID

//*
//STP01 EXEC PGM=MYCOBB
//IN1 DD DSN=MYDATA.URMI.SAMPLE.GDG(0),DISP=SHR
//OUT1 DD DSN=MYDATA.URMI.SAMPLE.GDG(+1),DISP=(,CALTG,DELETE)
// LRECL=100,RECFM=FB

Aqui, se o GDG tiver sido referido pelo nome real como MYDATA.URMI.SAMPLE.GDG.G0001V00, isso
levará à alteração do JCL todas as vezes antes da execução. Usar (0) e (+1) faz com que substitua
dinamicamente a versão GDG para execução.
Metodos de entrãdã-sãídã
Qualquer programa em lote executado por meio de um JCL requer entrada de dados, que é processada e uma
saída é criada. Existem diferentes métodos para alimentar a entrada do programa e escrever a saída recebida
de uma JCL. No modo em lote, não há necessidade de interação do usuário, mas os dispositivos de entrada e
saída e a organização necessária são definidos em JCL e enviados.

Entrada de dados em um JCL

Existem várias maneiras de alimentar os dados em um programa usando JCL e esses métodos foram
explicados abaixo:

INSTREAM DATA

Os dados instream para um programa podem ser especificados usando uma instrução SYSIN DD.

//CONCATEX JOB CLASS=6,NOTIFY=&SYSUID

//* Example 1:
//STEP10 EXEC PGM=MYPROG
//IN1 DD DSN=SAMPLE.INPUT1,DISP=SHR
//OUT1 DD DSN=SAMPLE.OUTPUT1,DISP=(,CATLG,DELETE),
// LRECL=50,RECFM=FB
//SYSIN DD *
//CUST1 1000
//CUST2 1001
/*
//*
//* Example 2:
//STEP20 EXEC PGM=MYPROG
//OUT1 DD DSN=SAMPLE.OUTPUT2,DISP=(,CATLG,DELETE),
// LRECL=50,RECFM=FB
//SYSIN DD DSN=SAMPLE.SYSIN.DATA,DISP=SHR
//*

No Exemplo 1, a entrada para MYPROG é passada por meio de SYSIN. Os dados são fornecidos dentro do
JCL. Dois registros de dados são passados para o programa. Observe que /* marca o fim dos dados SYSIN
instream.

“CUST1 1000” é record1 e “CUST2 1001” é record2. A condição de fim de dados é atendida quando o
símbolo /* é encontrado durante a leitura dos dados.

No Exemplo 2, os dados SYSIN são mantidos em um conjunto de dados, onde SAMPLE.SYSIN.DATA é

um arquivo PS, que pode conter um ou mais registros de dados.

Entrada de dados através de arquivos

Conforme mencionado na maioria dos exemplos nos capítulos anteriores, a entrada de dados para um
programa pode ser fornecida por meio de arquivos PS, VSAM ou GDG, com o nome DSN relevante e os
parâmetros DISP junto com as instruções DD.

No Exemplo 1, SAMPLE.INPUT1 é o arquivo de entrada pelo qual os dados são passados para MYPROG.
É referido como IN1 dentro do programa.
Saída de dados em um JCL
A saída em uma JCL pode ser catalogada em um conjunto de dados ou passada para o SYSOUT. Conforme
mencionado no capítulo de instruções DD, SYSOUT=* redireciona a saída para a mesma classe mencionada
no parâmetro MSGCLASS da instrução JOB.

Salvando registros de tarefas (logs)

Especificar MSGCLASS=Y salva o log de tarefas no JMR (Joblog Management and Retrieval). Todo o log
de JOB pode ser redirecionado para o SPOOL e pode ser salvo em um conjunto de dados fornecendo o
comando XDC em relação ao nome do trabalho no SPOOL. Quando o comando XDC é dado no SPOOL,
uma tela de criação de dataset é aberta. O registro de trabalho pode então ser salvo com a definição
apropriada de PS ou PDS.

Os logs de trabalho também podem ser salvos em um conjunto de dados mencionando um conjunto de dados
já criado para SYSOUT e SYSPRINT. Mas todo o log de tarefas não pode ser capturado dessa maneira (ou
seja, JESMSG não será catalogado) como feito em JMR ou XDC.

//SAMPINST JOB 1,CLASS=6,MSGCLASS=Y,NOTIFY=&SYSUID

//*
//STEP1 EXEC PGM=MYPROG
//IN1 DD DSN=MYDATA.URMI.INPUT,DISP=SHR
//OUT1 DD SYSOUT=*
//SYSOUT DD DSN=MYDATA.URMI.SYSOUT,DISP=SHR
//SYSPRINT DD DSN=MYDATA.URMI.SYSPRINT,DISP=SHR
//SYSIN DD MYDATA.BASE.LIB1(DATA1),DISP=SHR
//*
//STEP2 EXEC PGM=SORT

No exemplo acima, SYSOUT está catalogado em MYDATA.URMI.SYSOUT e SYSPRINT em

MYDATA.URMI.SYSPRINT.
Executãndo progrãmãs COBOL usãndo JCL
Compilando programas COBOL
Para executar um programa COBOL em modo batch usando JCL, o programa precisa ser compilado e um
módulo de carregamento é criado com todos os subprogramas. A JCL usa o módulo de carregamento e não o
programa real no momento da execução. As bibliotecas de carregamento são concatenadas e fornecidas ao
JCL no momento da execução usando JCLLIB ou STEPLIB.

Existem muitos utilitários de compilador de mainframe disponíveis para compilar um programa COBOL.
Algumas empresas corporativas usam ferramentas de Gerenciamento de Mudanças como o Endevor, que
compila e armazena todas as versões do programa. Isso é útil para rastrear as alterações feitas no programa.

//COMPILE JOB ,CLASS=6,MSGCLASS=X,NOTIFY=&SYSUID

//*
//STEP1 EXEC IGYCRCTL,PARM=RMODE,DYNAM,SSRANGE
//SYSIN DD DSN=MYDATA.URMI.SOURCES(MYCOBB),DISP=SHR
//SYSLIB DD DSN=MYDATA.URMI.COPYBOOK(MYCOPY),DISP=SHR
//SYSLMOD DD DSN=MYDATA.URMI.LOAD(MYCOBB),DISP=SHR
//SYSPRINT DD SYSOUT=*
//*

IGYCRCTL é um utilitário de compilador IBM COBOL. As opções do compilador são passadas usando o
parâmetro PARM. No exemplo acima, RMODE instrui o compilador a usar o modo de endereçamento
relativo no programa. O programa COBOL é passado utilizando o parâmetro SYSIN e o copybook é a
biblioteca utilizada pelo programa em SYSLIB.

Essa JCL produz o módulo de carregamento do programa como saída que é usada como entrada para a JCL
de execução.

Executando programas COBOL

Abaixo um exemplo de JCL onde o programa MYPROG é executado utilizando o arquivo de entrada
MYDATA.URMI.INPUT e produz dois arquivos de saída gravados no spool.

//COBBSTEP JOB CLASS=6,NOTIFY=&SYSUID

//
//STEP10 EXEC PGM=MYPROG,PARM=ACCT5000
//STEPLIB DD DSN=MYDATA.URMI.LOADLIB,DISP=SHR
//INPUT1 DD DSN=MYDATA.URMI.INPUT,DISP=SHR
//OUT1 DD SYSOUT=*
//OUT2 DD SYSOUT=*
//SYSIN DD *
//CUST1 1000
//CUST2 1001
/*

O módulo de carregamento de MYPROG está localizado em MYDATA.URMI.LOADLIB. Isso é

importante observar que o JCL acima pode ser usado apenas para um módulo COBOL não-DB2.
Passando dados para programas COBOL
A entrada de dados para o programa batch COBOL pode ser através de arquivos, parâmetro PARAM e
instrução SYSIN DD. No exemplo acima:

 Os registros de dados são passados para MYPROG através do arquivo MYDATA.URMI.INPUT.

Este arquivo será referenciado no programa usando o nome DD INPUT1. O arquivo pode ser aberto,
lido e fechado no programa.
 Os dados do parâmetro PARM ACCT5000 são recebidos na seção LINKAGE do programa
MYPROG em uma variável definida dentro dessa seção.
 Os dados na instrução SYSIN são recebidos por meio da instrução ACCEPT na divisão
PROCEDURE do programa. Cada instrução ACCEPT lê um registro inteiro (ou seja, CUST1 1000)
em uma variável de armazenamento de trabalho definida no programa.

Executando um programa COBOL-DB2

Para executar o programa COBOL DB2, o utilitário IBM especializado é usado no JCL e no programa; A
região do DB2 e os parâmetros necessários são passados como entrada para o utilitário.

As etapas abaixo são seguidas na execução de um programa COBOL-DB2:

 Quando um programa COBOL-DB2 é compilado, um DBRM (Database Request Module) é criado

junto com o módulo de carregamento. O DBRM contém as instruções SQL dos programas COBOL
com sua sintaxe verificada para estar correta.
 O DBRM está vinculado à região do DB2 (ambiente) na qual o COBOL será executado. Isso pode
ser feito usando o utilitário IKJEFT01 em um JCL.
 Após a etapa de ligação, o programa COBOL-DB2 é executado usando IKJEFT01 (novamente) com
a biblioteca de carregamento e a biblioteca DBRM como entrada para a JCL.

//STEP001 EXEC PGM=IKJEFT01

//*
//STEPLIB DD DSN=MYDATA.URMI.DBRMLIB,DISP=SHR
//*
//input files
//output files
//SYSPRINT DD SYSOUT=*
//SYSABOUT DD SYSOUT=*
//SYSDBOUT DD SYSOUT=*
//SYSUDUMP DD SYSOUT=*
//DISPLAY DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSTSPRT DD SYSOUT=*
//SYSTSIN DD *
DSN SYSTEM(SSID)
RUN PROGRAM(MYCOBB) PLAN(PLANNAME) PARM(parameters to cobol program) -
LIB('MYDATA.URMI.LOADLIB')
END
/*

No exemplo acima, MYCOBB é o programa COBOL-DB2 executado usando IKJEFT01. Observe que o
nome do programa, DB2 Sub-System Id (SSID), nome do plano DB2 são passados na instrução SYSTSIN
DD. A biblioteca DBRM é especificada no STEPLIB.
JCL – Progrãmãs Utilitãrios
Utilitários de conjunto de dados IBM
Os programas utilitários são programas pré-escritos, amplamente utilizados em mainframes por
programadores de sistemas e desenvolvedores de aplicativos para atender aos requisitos do dia-a-dia,
organizar e manter dados. Alguns deles estão listados abaixo com suas funcionalidades:

Nome do
Funcionalidade
utilitário
IEHMOVE Move ou copia conjuntos de dados sequenciais.
Excluir e renomear conjuntos de dados; catalogar ou não catalogar conjuntos de dados que
IEHPROGM
não sejam VSAM.
IEHCOMPR Compara dados em conjuntos de dados sequenciais.
IEBCOPY Copiar, mesclar, compactar, fazer backup ou restaurar PDS.
Nenhum utilitário de operação. Usado para devolver o controle ao usuário e encerrar.
Geralmente é usado para criar um conjunto de dados vazio ou excluir um conjunto de dados
existente.
IEFBR14
Por exemplo, se um conjunto de dados for passado como entrada para um programa
IEFBR14 com DISP=(OLD,DELETE,DELETE), o conjunto de dados será excluído na
conclusão do trabalho.
Usado para copiar partes selecionadas de um JCL. Por exemplo, se uma JCL tiver 5 etapas e
precisarmos executar apenas as etapas 1 e 3, uma JCL IEBEDIT pode ser codificada com
IEBEDIT um conjunto de dados que contém a JCL real a ser executada. No SYSIN do IEBEDIT,
podemos especificar STEP1 e STEP3 como parâmetros. Quando este JCL é executado, ele
executa o STEP1 e STEP3 do JCL real.
Criar, excluir, renomear, catalogar, descatalogar conjuntos de dados (exceto PDS).
IDCAMS
Geralmente usado para gerenciar conjuntos de dados VSAM.

Esses programas utilitários precisam ser usados com instruções DD apropriadas em uma JCL para atingir a
funcionalidade especificada.

Visão geral do DFSORT

DFSORT é um poderoso utilitário IBM usado para copiar, classificar ou mesclar conjuntos de dados. As
instruções SORTIN e SORTINnn DD são usadas para especificar conjuntos de dados de entrada. As
instruções SORTOUT e OUTFIL são usadas para especificar dados de saída.

A instrução SYSIN DD é usada para especificar as condições de classificação e mesclagem. DFSORT é

geralmente usado para alcançar as funcionalidades abaixo:

 SORT: ordenar o(s) arquivo(s) de entrada na ordem da posição do(s) campo(s) especificado(s) no
arquivo.
 INCLUDE ou OMIT: incluir ou omitir registros do(s) arquivo(s) de entrada com base na condição
especificada.
 SORT MERGE: ordenar/mesclar arquivo(s) de entrada na ordem da posição do(s) campo(s)
especificado(s) no arquivo.
  SORT JOIN: ordenar/unir dois ou mais arquivos de entrada com base em uma JOIN KEY
especificada (campos em cada arquivo de entrada).
 Quando houver processamento adicional a ser feito nos arquivos de entrada, um programa USER
EXIT pode ser chamado a partir do programa SORT. Por exemplo, se houver um cabeçalho/trailer a
ser incluído no arquivo de saída, um programa COBOL escrito pelo USUÁRIO poderá ser chamado
a partir do programa SORT para executar essa funcionalidade. Usando um cartão de controle, os
dados podem ser passados para o programa COBOL.
 Por outro lado, um SORT pode ser chamado internamente de um programa COBOL para organizar o
arquivo de entrada em uma ordem específica antes de ser processado. Normalmente, isso não é
recomendado devido ao desempenho de arquivos grandes.

Visão geral do ICETOOL

ICETOOL é um utilitário DFSORT multifuncional usado para executar uma variedade de operações em
conjuntos de dados. Os conjuntos de dados de entrada e saída podem ser definidos usando nomes DD
definidos pelo usuário. As operações de arquivo são especificadas na instrução TOOLIN DD. Condições
adicionais podem ser especificadas em instruções DD 'CTL' definidas pelo usuário.

Algumas das utilidades do ICETOOL são dadas abaixo:

 ICETOOL pode alcançar todas as funcionalidades do DFSORT em uma ou mais condições.

 SPLICE é uma operação poderosa do ICETOOL que é semelhante ao SORT JOIN, mas com
recursos adicionais. Ele pode comparar dois ou mais arquivos em campos especificados e criar um
ou mais arquivos de saída, como arquivo com registros correspondentes, arquivo com registros não
correspondentes, etc.
 Os dados em um arquivo em uma posição específica podem ser sobrepostos em outra posição no
mesmo arquivo ou em um arquivo diferente.
 Um arquivo pode ser dividido em n arquivos com base em uma condição especificada. Por exemplo,
um arquivo contendo nomes de funcionários pode ser dividido em 26 arquivos, cada um contendo os
nomes começando com A, B, C e assim por diante.
 Diferentes combinações de manipulação de arquivos são possíveis usando ICETOOL com um pouco
de exploração da ferramenta.

Visão geral do SYNCSORT

O SYNCSORT é usado para copiar, mesclar ou classificar conjuntos de dados com alto desempenho. Ele
oferece a melhor utilização dos recursos do sistema e operação eficiente em espaços de endereço de 31 e 64
bits.

Ele pode ser usado nas mesmas linhas do DFSORT e pode alcançar os mesmos recursos. Ele pode ser
invocado por uma JCL ou de dentro de um programa codificado em linguagem COBOL, PL/1 ou
Assembler. Ele também suporta programas User Exit a serem chamados a partir do programa SYNCSORT.

Os truques de classificação usados com frequência usando esses utilitários são explicados no próximo
capítulo. Requisitos complexos, que exigem uma grande programação em COBOL/ASSEMBLER, podem
ser alcançados usando os utilitários acima em etapas simples.
JCL – Truques bãsicos de clãssificãção
Os requisitos de aplicação do dia-a-dia em um mundo corporativo que podem ser alcançados usando
Programas Utilitários são ilustrados abaixo:

1. Um arquivo tem 100 registros. Os primeiros 10 registros precisam ser gravados no arquivo de
saída.

//JSTEP020 EXEC PGM=ICETOOL

//TOOLMSG DD SYSOUT=*
//DFSMSG DD SYSOUT=*
//IN1 DD DSN=MYDATA.URMI.STOPAFT,DISP=SHR
//OUT1 DD SYSOUT=*
//TOOLIN DD *
COPY FROM(IN1) TO(OUT1) USING(CTL1)
/*
//CTL1CNTL DD *
OPTION STOPAFT=10
/*

A opção STOPAFT interromperá a leitura do arquivo de entrada após o 10º registro e encerrará o programa.
Portanto, 10 registros são gravados na saída.

2. O arquivo de entrada possui um ou mais registros para o mesmo número de funcionário. Gravar
registros exclusivos para saída.

//STEP010 EXEC PGM=SORT

//SYSOUT DD SYSOUT=*
//SORTIN DD DSN=MYDATA.URMI.DUPIN,DISP=SHR
//SORTOUT DD SYSOUT=*
//SYSIN DD *
SORT FIELDS=(1,15,ZD,A)
SUM FIELDS=NONE
/*

SUM FIELDS=NONE remove duplicatas em campos especificados em SORT FIELDS. No exemplo acima,
o número do funcionário está na posição de campo 1,15. O arquivo de saída conterá os números exclusivos
de funcionários classificados em ordem crescente.

3. Substitua o conteúdo do registro de entrada.

//JSTEP010 EXEC PGM=SORT

//SORTIN DD DSN= MYDATA.URMI.SAMPLE.MAIN,DISP=SHR
//SORTOUT DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN DD *
OPTION COPY
INREC OVERLAY=(47:1,6)
/*
No arquivo de entrada, o conteúdo na posição 1,6 é substituído na posição 47,6 e depois copiado para o
arquivo de saída. A operação INREC OVERLAY é usada para reescrever dados no arquivo de entrada antes
de copiar para a saída.

4. Adicionando um número de sequência ao arquivo de saída.

//JSTEP010 EXEC PGM=SORT

//SORTIN DD *
data1
data2
data3
/*
//SORTOUT DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN DD *
OPTION COPY
BUILD=(1:1,5,10:SEQNUM,4,ZD,START=1000,INCR=2)
/*

A saída será:

data1 1000
data2 1002
data3 1004

O número de sequência de 4 dígitos é adicionado na saída na posição 10, começando em 1000 e

incrementado em 2 para cada registro.

5. Adicionando Cabeçalho/Trailer ao arquivo de saída.

//JSTEP010 EXEC PGM=SORT

//SORTIN DD *
data1
data2
data3
/*
//SORTOUT DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN DD *
SORT FIELDS=COPY
OUTFIL REMOVECC,
HEADER1=(1:C'HDR',10:X'020110131C'),
TRAILER1=(1:C'TRL',TOT=(10,9,PD,TO=PD,LENGTH=9))
/*

A saída será:

HDR 20110131
data1
data2
data3
TRL 000000003

TOT calcula o número de registros no arquivo de entrada. HDR e TRL são adicionados como
identificadores ao cabeçalho/trailer, que é definido pelo usuário e pode ser personalizado de acordo com as
necessidades dos usuários.
6. Processamento Condicional

//JSTEP010 EXEC PGM=SORT

//SORTIN DD *
data1select
data2
data3select
/*
//SORTOUT DD SYSOUT=*
//SYSPRINT DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSIN DD *
INREC IFTHEN=(WHEN=(6,1,CH,NE,C' '),BUILD=(1:1,15),
IFTHEN=(WHEN=(6,1,CH,EQ,C' '),BUILD=(1:1,5,7:C'EMPTY ')
OPTION COPY
/*

A saída será:

data1select
data2 EMPTY
data3select

Com base na 6ª posição do arquivo, a BUILD (CONSTRUÇÃO) do arquivo de saída varia. Se a 6ª posição
for SPACES, o texto “EMPTY” será anexado ao registro de entrada. Caso contrário, o registro de entrada é
gravado na saída, como está.

7. Fazendo backup de um arquivo

//JSTEP001 EXEC PGM=IEBGENER

//SYSPRINT DD SYSOUT=*
//SYSIN DD *
//SYSOUT DD SYSOUT=*
//SORTOUT DD DUMMY
//SYSUT1 DD DSN=MYDATA.URMI.ORIG,DISP=SHR
//SYSUT2 DD DSN=MYDATA.URMI.BACKUP,DISP=(NEW,CATLG,DELETE),
// DCB=*.SYSUT1,SPACE=(CYL,(50,1),RLSE)

IEBGENER copia o arquivo em SYSUT1 para arquivo em SYSUT2. Observe que o arquivo no SYSUT2
usa o mesmo DCB do SYSUT1 no exemplo acima.

8. Comparação de arquivos

//STEP010 EXEC PGM=SORT

//MAIN DD *
1000
1001
1003
1005
//LOOKUP DD *
1000
1002
1003
//MATCH DD DSN=MYDATA.URMI.SAMPLE.MATCH,DISP=OLD
//NOMATCH1 DD DSN=MYDATA.URMI.SAMPLE.NOMATCH1,DISP=OLD
//NOMATCH2 DD DSN=MYDATA.URMI.SAMPLE.NOMATCH2,DISP=OLD
//SYSOUT DD SYSOUT=*
//SYSIN DD *
 JOINKEYS F1=MAIN,FIELDS=(1,4,A)
JOINKEYS F2=LOOKUP,FIELDS=(1,4,A)
JOIN UNPAIRED,F1,F2
REFORMAT FIELDS=(?,F1:1,4,F2:1,4)
OPTION COPY
OUTFIL FNAMES=MATCH,INCLUDE=(1,1,CH,EQ,C'B'),BUILD=(1:2,4)
OUTFIL FNAMES=NOMATCH1,INCLUDE=(1,1,CH,EQ,C'1'),BUILD=(1:2,4)
OUTFIL FNAMES=NOMATCH2,INCLUDE=(1,1,CH,EQ,C'2'),BUILD=(1:2,4)
/*

 JOINKEYS especifica o campo no qual os dois arquivos são comparados.

 REFORMAT FIELDS=? coloca 'B' (registros correspondentes), '1' (presente no arquivo1, mas não
no arquivo2) ou '2' (presente no arquivo2, mas não no arquivo1) na 1ª posição do BUILD de saída.
 JOIN UNPAIRED faz uma junção externa completa nos dois arquivos.

A saída será:

MATCH File
1000
1003

NOMATCH1 File
1001
1005

NOMATCH2 File
1002

A mesma funcionalidade também pode ser alcançada usando o ICEDOOL.