JCL Tutorial - En.pt

Job Control Language
Sobre o Tutorial
Job Control Language (JCL) é a língua do Multiple Virtual Storage (MVS), que é o sistema operacional comumente
usado em computadores mainframe IBM de comando. JCL identifica o programa a ser executado, as entradas que
são necessários e o local da entrada / saída, e informa o sistema operacional através de declarações de controle de
trabalho.
Em ambiente de mainframe, os programas podem ser executados em lote e modos online. JCL é usado para a
apresentação de um programa para execução em modo de lote.
Público
Este tutorial será útil para os programadores de software que gostariam de compreender os conceitos básicos de
Job Control Language. Além disso, este tutorial será útil para profissionais de mainframe aumentar o seu nível de
especialização em JCL.
Pré-requisitos
O tutorial é destinado a leitores que têm uma compreensão básica de gerenciamento de trabalho e gerenciamento
de dados em ambiente mainframe.
Disclaimer e direitos autorais
• Copyright 2015 Tutoriais ponto (I) Pvt. Ltd.
Todo o conteúdo e gráficos publicados neste e-book são propriedade dos Tutoriais ponto (I) Pvt. Ltd. O usuário
deste e-book é proibida a reutilização, reter, copiar, distribuir ou republicar qualquer conteúdo ou uma parte do
conteúdo deste e-book de qualquer maneira sem o consentimento por escrito do editor. Nós nos esforçamos para
atualizar o conteúdo de nosso site e tutoriais como oportuna e tão precisamente quanto possível, no entanto, o
conteúdo pode conter imprecisões ou erros. Tutoriais ponto (I) Pvt. Ltd. fornece nenhuma garantia quanto à
precisão, pontualidade, ou integridade de nosso site ou o seu conteúdo, incluindo este tutorial. Se você descobrir
erros no nosso site ou neste tutorial, por favor avise-nos em contact@tutorialspoint.com.
Eu
Índice
Sobre o Tutorial ............................................... .................................................. ................................... Eu
Público ................................................. .................................................. ............................................... Eu
Pré-requisitos ................................................. .................................................. ......................................... Eu
Disclaimer e direitos autorais ............................................... .................................................. ............................ Eu
Índice ............................................... .................................................. ii ...................................
1. JCL - PANORAMA ............................................... .................................................. ...................... 1
Quando usar JCL .............................................. .................................................. ...................................... 1
Processamento de trabalho ................................................ .................................................. ....................................... 1
2. JCL - configuração do ambiente .............................................. .................................................. 3
Instalando JCL no Windows / Linux ............................................ .................................................. ............... 3
Correndo JCL em Mainframes .............................................. .................................................. .................... 3
Estrutura de um JCL .............................................. .................................................. ..................................... 4
Descrição do Programa ................................................ .................................................. ............................. 4
Tipos de trabalho Parâmetros ............................................... .................................................. ............................. 5
3. JCL - DEMONSTRAÇÃO DE TRABALHO .............................................. .................................................. ........... 6
Sintaxe ................................................. .................................................. .................................................. 6
Descrição ................................................. .................................................. ........................................... 6
Exemplo ................................................. .................................................. ............................................. 10
Parâmetros diversos ................................................ .................................................. .................. 10
4. JCL - DEMONSTRAÇÃO EXEC .............................................. .................................................. ....... 12
Sintaxe ................................................. .................................................. ................................................ 12
Descrição ................................................. .................................................. ......................................... 12
Parâmetros palavra-chave comuns de EXEC e Declaração JOB .......................................... ........................ 14
Exemplo ................................................. .................................................. ............................................. 15
ii
5. JCL - DD DECLARAÇÃO .............................................. .................................................. ........... 16
Sintaxe ................................................. .................................................. ................................................ 16
Descrição ................................................. .................................................. ......................................... 16
Exemplo ................................................. .................................................. ............................................. 22
6. JCL - biblioteca de base .............................................. .................................................. ............. 23
Declaração JOBLIB ................................................ .................................................. ................................ 23
Declaração STEPLIB ................................................ .................................................. .............................. 23
Include ................................................ .................................................. ............................ 24
Declaração JCLLIB ................................................ .................................................. ................................. 25
7. JCL - PROCEDIMENTOS ............................................... .................................................. ............... 27
Sintaxe ................................................. .................................................. ................................................ 27
Instream Procedimento ................................................ .................................................. ............................. 27
Catalogado Procedimento ................................................ .................................................. ........................... 28
Procedimentos aninhados ................................................ .................................................. .............................. 29
8. JCL - processamento condicional .............................................. ...................................... 32
parâmetro COND ................................................ .................................................. ................................. 32
COND dentro instrução JOB .............................................. .................................................. .................. 33
COND dentro declaração EXEC .............................................. .................................................. ................ 34
COND = MESMO ............................................... .................................................. ......................................... 34
COND = SÓ ............................................... .................................................. ......................................... 35
IF-THEN-ELSE Construir ............................................ .................................................. ........................... 35
Definindo Pontos de Verificação ................................................ .................................................. ............................. 38
Reiniciar Processamento ................................................ .................................................. ............................... 38
9. JCL - DEFINIÇÃO DATASETS .............................................. .................................................. . 40
Concatenação de conjuntos de dados ................................................ .................................................. ...................... 40
iii
Conjuntos de dados primordiais ................................................ .................................................. ............................ 41
Definindo GDGs em um JCL ............................................. .................................................. ............................ 42
Criar / Alter GDG em um JCL ........................................... .................................................. ........................ 42
Excluir GDG em um JCL ............................................. .................................................. ................................ 44
Usando GDG em um JCL ............................................. .................................................. .................................. 44
10. JCL - Métodos de entrada / saída ............................................ ....................................... 45
Entrada de dados em um JCL ............................................. .................................................. .................................. 45
Saída de dados em um JCL ............................................. .................................................. ............................... 46
11. JCL - RUN COBOL programas usando JCL ........................................... ............................ 48
Compilar programas COBOL ............................................... .................................................. ................. 48
A execução de programas COBOL ............................................... .................................................. .................... 48
Passando dados para programas COBOL ............................................. .................................................. ........... 49
Execução de um programa COBOL-DB2 ............................................ .................................................. .............. 49
12. JCL - programas utilitários .............................................. .................................................. .. 52
IBM Conjunto de Dados Utilities ............................................... .................................................. ............................ 52
DFSORT Overview ................................................ .................................................. ............................... 53
ICETOOL Overview ................................................ .................................................. .............................. 54
SYNCSORT Overview ................................................ .................................................. ........................... 54
13. JCL - TRUQUES SORT BÁSICOS ............................................. .................................................. .... 55
iv
1. JCL - PANORAMA
JCL é utilizado em ambiente mainframe para actuar como uma ponte entre um programa (Exemplo: COBOL,
assembler ou PL / I) e o sistema operativo. Em um ambiente de mainframe, os programas podem ser executados em
ambos modo de lote assim como modo online.
Dentro modo de lote, programas são submetidos ao sistema operacional como um trabalho através de um JCL. Por
exemplo, o processamento de transações bancárias através de um arquivo (Virtual Storage Access Method) VSAM e
aplicá-lo para as contas correspondentes é um sistema de lote. Em contraste, uma equipe do banco abrir uma conta
usando uma tela de back office é um exemplo de um sistema online.
Lote e processamento on-line diferem na maneira de receber suas entradas e pedidos de execução do programa.
No processamento em lote, estes parâmetros são alimentados para o JCL que por sua vez é recebido pelo sistema
operativo.
Processamento de trabalho
Um trabalho é uma unidade de trabalho que pode ser feita de muitas etapas de trabalho. Cada etapa de trabalho é especificado no
Job Control Language (JCL) através de um conjunto de Declarações de controle do trabalho.
Os usos do sistema operacional Sistema de Entrada de trabalho (JES) para receber trabalhos para o sistema
operacional, para programá-los para processamento, e para controlar a saída.
processamento de trabalho passa por uma série de etapas como dado abaixo:
1
• Envio de Trabalhos - Submeter o JCL para JES.
• Conversão de Tarefa - O JCL juntamente com o PROC é convertida em um texto interpretado a ser
compreendido por JES e armazenados em um conjunto de dados, o que chamamos de SPOOL.
• Queuing Job - JES decide a prioridade do trabalho com base em parâmetros de classe e prty na instrução
JOB. Os erros JCL são verificados e o trabalho está programado para a fila de trabalho se não há erros.
• Execução do trabalho - Quando o trabalho chega a sua maior prioridade, é levado para a execução da fila
de trabalho. A JCL é lida a partir do carretel, o programa é executado e a saída é redirecionada ao destino
de saída correspondente, conforme especificado no JCL.
• purga - Quando o trabalho estiver concluído, os recursos alocados e o espaço JES SPOOL é liberado. Para
armazenar o log de trabalho, é preciso copiar o registo de emprego para outro conjunto de dados antes de
ser liberado do carretel.
2
2. JCL - configuração do ambiente
Instalando JCL no Windows / Linux

Existem muitos Emuladores Mainframe livre disponível para Windows, que pode ser usado para escrever e aprender
JCL de amostra.
Um tal emulador é Hércules, que pode ser facilmente instalado no Windows, seguindo alguns passos simples como
dado abaixo:
• Baixe e instale o emulador Hercules, que está disponível no site para casa o Hércules -: www.hercules-390.eu
• Depois de instalar o pacote em uma máquina Windows, ele irá criar uma pasta como C: \ unidades
centrais.
• Prompt Run Command (CMD) e vá para o diretório C: \ Mainframes em CMD.
• O guia completo sobre vários comandos para escrever e executar um JCL podem ser encontradas em
www.jaymoseley.com/hercules/installmvs/instmvs2.htm
Hercules é uma implementação de software de código aberto do mainframe System / 370 e ESA / 390 arquiteturas,
além de o mais recente 64-bit z / Architecture. Hercules é executado em Linux, Windows, Solaris, FreeBSD, e Mac
OS X.
Correndo JCL em Mainframes

Um usuário pode conectar a um servidor de mainframe em um número de maneiras, tais como um thin client, um
terminal fictício, um sistema cliente Virtual (VCS), ou um sistema de Desktop Virtual (VDS).
Cada utilizador válido é dado um id de login para entrar na interface Z / OS (TSO / E ou ISPF). Na interface z / OS, o
JCL pode ser codificado e armazenado como um membro de um conjunto de dados particionados (PDS). Quando o
JCL é submetido, ele é executado ea saída é recebido como explicado na seção processamento de trabalho do
capítulo anterior.
3
Estrutura de um JCL
A estrutura básica de um JCL com as declarações comuns é dada abaixo:
// FUNÇÃO SAMPJCL 1, CLASSE = 6, MSGCLASS = 0, AVISAR = & 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 = (NOVO, CATLG, CATLG), DATACLAS = DSIZE50
// SYSOUT DD SYSOUT = * (6)
// SYSUDUMP DD SYSOUT = C (6)
// SYSPRINT DD SYSOUT = * (6)
// SYSIN DD * (6)
SORT CAMPOS = CÓPIA
INCLUEM COND = (28,3, CH, EQ, C'XXX ')
/* (7)
Descrição do Programa
As instruções JCL numeradas são explicados abaixo:
(1) instrução JOB - Especifica as informações necessárias para o spool do trabalho, tais como ID de trabalho, a
prioridade de execução, user-id para ser notificado após a conclusão do trabalho.
(2) // * declaração - Esta é uma declaração comentários.
(3) declaração EXEC - Especifica o PROC / programa a ser executado. No exemplo acima, um programa SORT está
sendo executada (ou seja, a classificação dos dados de entrada numa ordem particular)
(4) instrução DD Input - Especifica o tipo de entrada a ser passado para o programa mencionado em (3). No
exemplo acima, um ficheiro sequencial Física (PS) é passada como entrada no modo comum (DISP = SHR).
(5) instrução DD Output - Especifica o tipo de saída a ser produzido pelo programa após a execução. No exemplo
acima, um arquivo PS é criado. Se um
4
declaração se estende para além da posição 70 em uma linha, então ele continua na linha seguinte, que deve
começar com "//" seguido por um ou mais espaços.
(6) Não pode haver outros tipos de instruções DD para especificar informações adicionais para o programa (No
exemplo acima: A condição SORT é especificado na declaração SYSIN DD) e para especificar o destino para o log
de erro / execução (Exemplo: SYSUDUMP / SYSPRINT). instruções DD pode ser contida em um (ficheiro
mainframe) ou como conjunto de dados em dados de transmissão (informação codificada dentro do JCL) como dado
no exemplo acima.
(7) / * marca o fim dos dados InStream.
Todas as instruções JCL, exceto dados InStream começar com //. Deve haver pelo menos um espaço antes e
depois do trabalho, EXEC, e palavras-chave DD e não deve haver nenhum espaço no resto da declaração.
Tipos de trabalho Parâmetros
Cada uma das instruções JCL é acompanhada por um conjunto de parâmetros para ajudar o sistema operacional
para completar a execução do programa. Os parâmetros podem ser de dois tipos:
Parâmetros posicionais
• Aparece na posição pré-definida e ordem no comunicado. Exemplo: Contabilidade Parameter informações

podem aparecer somente após a TRABALHO palavra-chave e antes do parâmetro de nome de programador
e os parâmetros de palavra-chave. Se um parâmetro posicional é omitido, tem que ser substituído por uma
vírgula.
• Parâmetros posicionais estão presentes em Jó e EXEC declarações. No exemplo acima, é um PGM

posicional parâmetro codificado depois
a EXEC palavra-chave.
Parâmetros de palavra-chave
• Parâmetros de palavra-chave são codificados após os parâmetros de posição, mas pode aparecer em qualquer
ordem. parâmetros de palavra-chave pode ser omitido, se não for necessário. A sintaxe genérica é palavra-chave = valor.
Exemplo: MSGCLASS = X, ou seja, o registo do trabalho é redireccionada para a bobina de saída após a conclusão
do trabalho.
• No exemplo acima, classe, MSGCLASS e notificar são parâmetros-chave de instrução JOB. Não pode
haver parâmetros-chave em declaração EXEC também.
Estes parâmetros foram detalhadas nos capítulos subsequentes, juntamente com exemplos apropriados.
5
3. JCL - DEMONSTRAÇÃO DE TRABALHO
Declaração JOB é a primeira instrução de controle em um JCL. Isto dá a identidade do trabalho para o sistema
operacional (OS), no carretel e no programador. Os parâmetros na instrução JOB ajudar o OS em alocar o
programador direita, exigido tempo de CPU, e emissão de notificações para o usuário.
Sintaxe
A seguir está a sintaxe básica de uma instrução JOB JCL:
// Job-nome do trabalho posicional-param, Keyword-param
Descrição
Vamos dar uma olhada mais de perto os termos usados na sintaxe da instrução JOB acima.
Job-name
Ele dá um id para o trabalho enquanto enviá-lo para o sistema operacional. Pode ser do comprimento de 1 a 8 com
caracteres alfanuméricos e começa logo após //.
TRABALHO
Esta é a palavra-chave para identificá-lo como uma declaração TRABALHO.
Posicional-param
Parâmetros posicionais podem ser de dois tipos:
Parâmetro Descrição
posicional
Informação da Refere-se à pessoa ou grupo ao qual o tempo de CPU é devido. Ele é definido
conta de acordo com as regras da empresa possuir os mainframes. Se for
especificado como (*), em seguida, leva o ID do usuário, que tem atualmente
conectado ao Terminal Mainframe.
6
nome do programador Ele identifica a pessoa ou grupo que está no comando de

o JCL. Não é um parâmetro obrigatório e pode ser substituído por uma vírgula.
Keyword-param
A seguir estão os vários parâmetros de palavra-chave, que podem ser usados em um comunicado TRABALHO.
Você pode usar um ou mais parâmetros (separados por vírgula) com base em suas necessidades.
Parâmetro de Descrição
palavra-chave
CLASSE
Com base no tempo de duração eo número de recursos requeridos pelo trabalho,
as empresas atribuir diferentes classes de trabalho. Estes podem ser visualizados
como programadores individuais usados pelo OS para receber os trabalhos.
Colocar os postos de trabalho no programador certo irá ajudar na fácil execução
dos trabalhos. Algumas empresas têm classes diferentes para trabalhos em teste e
ambiente de produção.
Os valores válidos para o parâmetro de classe são A a Z caracteres e 0-9 numérico
(de comprimento 1). A seguir é a sintaxe:
CLASS = 0 a 9 | A a Z
prty
Para especificar a prioridade do trabalho dentro de uma classe trabalho. Se este
parâmetro não for especificado, então o trabalho é adicionado ao final da fila na
classe especificada. A seguir é a sintaxe:
Prty = N
Onde N é um número entre 0 a 15. Quanto maior o número, maior é a prioridade.
NOTIFICAR
O sistema envia a mensagem de sucesso ou fracasso
7
(Código de condição máxima) para o usuário especificado neste parâmetro. A
seguir é a sintaxe:
NOTIFY = "ID de usuário | & SYSUID"
Aqui, o sistema envia a mensagem para o usuário "UserID", mas se usarmos
NOTIFY = & SYSUID, em seguida, a mensagem é enviada para o usuário enviar o
JCL.
MSGCLASS
Para especificar o destino de saída para as mensagens de sistema e de trabalho
quando o trabalho está completo. A seguir é a sintaxe:
MSGCLASS = CLASSE
Os valores válidos de classe pode ser a partir de "A" a "Z" e "0" a "9". MSGCLASS = Y
pode ser definido como uma classe para enviar o log de trabalho para a JMR (Gestão
JOBLOG e Recuperação: um repositório dentro de mainframes para armazenar as
estatísticas de trabalho).
MSGLEVEL
Especifica o tipo de mensagens a serem gravados para o destino de saída
especificado no MSGCLASS. A seguir é a sintaxe:
MSGLEVEL = ( ST, MSG)
ST = Tipo de declarações escritas para o registo de saída
• Quando ST = 0, declarações trabalho somente.
• Quando ST = 1, juntamente com parâmetros JCL simbólicas expandidas.
• Quando ST = 2, entrada JCL somente.
MSG = Tipo de mensagens escritas para o registo de saída.
• Quando MSG = 0, Alocação e Rescisão
8
mensagens escritas após a conclusão do trabalho anormais.
• Quando MSG = 1, alocação e terminação de mensagens escritas,
independentemente da natureza da conclusão do trabalho.
TYPRUN
Especifica um processamento especial para o trabalho. A seguir é a sintaxe:
TYPRUN = SCAN | AGUARDE
Onde SCAN e mantenha tem a seguinte descrição
• TYPRUN = SCAN verifica os erros de sintaxe do JCL sem executá-lo.
• TYPRUN = ESPERA coloca a tarefa em espera na fila de tarefas. Para
liberar um trabalho, "A" pode ser digitado contra o trabalho no spool, o que
vai trazer o trabalho para execução.
TEMPO
Especifica o período de tempo a ser utilizado pelo processador para executar o
trabalho. A seguir é a sintaxe:
TEMPO = (mm, ss) ou TEMPO = ss
Onde mm = minutos e ss = segundos
Este parâmetro pode ser útil ao testar um programa recém-codificada. A fim de
garantir que o programa não é executado por um longo tempo devido a erros de
looping, um parâmetro de tempo pode ser codificado para que o programa aborta
quando o tempo de CPU especificado for atingido.
REGIÃO
Especifica o espaço de endereço necessário para executar uma etapa de trabalho dentro do
trabalho. A seguir é a sintaxe:
9
REGIÃO = nK | nM
Aqui, região pode ser especificada como nK ou nM em que n é um número, K é
quilobyte, e M é megabyte.
Quando REGIÃO = 0K ou 0M, maior espaço de endereço é fornecido para
execução. Em aplicações críticas, codificação de 0K ou 0M é proibido para evitar o
desperdício de espaço de endereço.
Exemplo
// FUNÇÃO URMISAMP (*), "tutpoint", CLASSE = 6, prty = 10, AVISAR = & SYSUID,
// MSGCLASS = X, MSGLEVEL = (1,1), TYPRUN = SCAN,
// TIME = (3,0), REGIÃO = 10K
Aqui, a declaração de trabalho está sendo estendido para além da posição 70 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
Há outros parâmetros que podem ser usados com uma declaração de trabalho, mas eles não são usados com
freqüência:
ADDRSPC Tipo de armazenamento utilizado: Virtual ou real
BYTES Tamanho de dados a ser escrito no registo de saída e a ação a ser tomada quando
o tamanho for excedido.
LINHAS O número máximo de linhas a ser impresso para o registo de saída.
PÁGINAS O número máximo de páginas a serem impressas no log de saída.
10
DO UTILIZADOR ID de usuário usado para enviar a tarefa
SENHA Senha do usuário-id especificado no parâmetro USUÁRIO.
COND e Estes são usados em processamento condicional etapa de trabalho e são explicados
RESTART em pormenor ao discutir condicional
em processamento.
11
4. JCL - DEMONSTRAÇÃO EXEC
Cada JCL podem ser feitas de muitas etapas de trabalho. Cada etapa de trabalho pode executar um programa diretamente
ou pode chamar um procedimento, que por sua vez executa um ou mais programas (etapas de trabalho). A afirmação de
que mantém o programa de etapa de trabalho / informação procedimento é o declaração EXEC.
O objetivo da declaração EXEC é fornecer informações necessárias para o / procedimento programa executado na
etapa de trabalho. Parâmetros codificados nesta declaração pode
• passar dados para o programa em execução,
• substituir certos parâmetros de instrução JOB, e
• passar parâmetros para o procedimento se a declaração EXEC chama um procedimento em vez de executar
diretamente um programa.
Sintaxe
A seguir está a sintaxe básica de uma instrução JCL EXEC:
// Passo-name EXEC posicional-param, Keyword-param
Descrição
Vamos dar uma olhada de perto os termos utilizados na sintaxe da instrução EXEC acima.
PASSO-NAME
Ele identifica a etapa de trabalho dentro do JCL. Ele pode ser do comprimento de 1 a 8 com caracteres
alfanuméricos.
EXEC
Esta é a palavra-chave para identificá-lo como uma declaração EXEC.
12
POSIÇÃO-PARAM
Parâmetros posicionais podem ser de dois tipos:
posicional
PGM Refere-se ao nome do programa a ser executado na etapa de trabalho.
PROC Refere-se ao nome do procedimento a ser executado na etapa de trabalho. Vamos discutir
isso em um capítulo separado.
KEYWORD-PARAM
A seguir estão os vários parâmetros de palavra-chave para declaração EXEC. Você pode usar um ou mais
parâmetros (separados por vírgula) com base em suas necessidades.
palavra-chave
PARM
Usado para fornecer dados parametrizados para o programa que está sendo executado na
etapa de trabalho. É um campo dependente programa e ele não tem regras definidas, a
não ser que o valor PARM tem de ser incluído dentro citação no caso de ter caracteres
especiais.
Dê uma olhada no exemplo dado no final deste capítulo. O "CUST1000" valor é passado
como um valor alfanumérico para o programa. Se o programa está em COBOL, o valor
passado através de um parâmetro PARM em um JCL é recebido na seção de vinculação
do programa.
ADDRSPC
Isto é usado para especificar se a etapa de trabalho exige armazenamento virtual ou real para
execução. armazenamento virtual é pageable enquanto armazenamento real não é e é
colocado na memória principal para execução. etapas de trabalho que requerem uma
execução mais rápida pode ser
13
colocado no armazenamento real. A seguir é a sintaxe:
ADDRSPC = VIRT | REAL
Quando um ADDRSPC não é codificado, VIRT é o padrão.
ACCT
Ele especifica as informações contábeis da etapa de trabalho. A seguir é a sintaxe:
ACCT = (ID de utilizador)
Este é semelhante ao parâmetro posicional informação contábil na instrução JOB. Se ele
é codificado tanto no emprego e instrução EXEC, em seguida, as informações contábeis
na instrução JOB aplica-se a todas as etapas de trabalho onde um parâmetro ACCT não
está codificada. O parâmetro ACCT em uma declaração EXEC substituirá o presente na
instrução JOB apenas essa etapa de trabalho.
Comuns palavra-chave Parâmetros de EXEC e Declaração JOB
palavra-chave
ADDRSPC ADDRSPC codificado em instrução JOB substitui a ADDRSPC codificado em declaração EXEC
de qualquer etapa de trabalho.
TEMPO Se o tempo é codificado em uma declaração EXEC, então aplica-se apenas que a etapa
de trabalho. Se for especificado tanto em instrução JOB e EXEC, então ambos estarão em
vigor e pode causar erro de tempo limite deve a ele. Não é recomendado usar parâmetro
TIME tanto o trabalho e declaração EXEC juntos.
REGIÃO
Se a região é codificado em uma declaração EXEC, então aplica-se apenas que a etapa de
trabalho.
14
REGIÃO codificado em um comunicado JOB substitui a REGIÃO codificado em declaração
EXEC de qualquer etapa de trabalho.
COND
Usado para controlar a execução etapa de trabalho baseado no returncode da etapa
anterior.
Se um parâmetro COND é codificado em uma declaração EXEC de uma etapa de
trabalho, o parâmetro COND da instrução JOB (se houver) é ignorado. Os vários testes
que podem ser executados usando um parâmetro COND
é explicado em condicional
Em processamento.
Exemplo
A seguir é um exemplo simples de um script JCL, juntamente com Jó e EXEC declarações:
// FUNÇÃO TTYYSAMP 'TUTO', CLASSE = 6, MSGCLASS = X, REGIÃO = 8K,
// NOTIFY = & SYSUID
// *
// STEP010 EXEC PGM = MYCOBOL, PARAM = CUST1000,
// ACCT = (XXXX), REGIÃO = 8K, ADDRSPC = real, tempo = 1440
15
5. JCL - DD DECLARAÇÃO
Conjuntos de dados são arquivos de mainframe com registros organizados em um formato específico. Conjuntos de dados são
armazenados em áreas de armazenamento básicos, tais como o dispositivo de armazenamento de acesso directo (DASD) ou fitas
de mainframe. Se forem necessários estes dados a serem usados / criado em um programa de lote, em seguida, o arquivo (ou
seja, conjunto de dados) nome físico junto com o formato e organização de arquivos são codificados em um JCL.
A definição de cada conjunto de dados usado na JCL é determinado usando o declaração DD.
Os recursos de entrada e saída exigidos por uma etapa de trabalho precisa ser descrito em uma instrução DD com
informações como a organização do conjunto de dados, os requisitos de armazenamento e tamanho de registro.
Sintaxe
A seguir está a sintaxe básica de uma instrução JCL DD:
// Parâmetros DD-nome DD
Descrição
Vamos dar uma olhada de perto os termos utilizados na sintaxe da instrução DD acima.
DD-NOME
A DD-NOME identifica o conjunto de dados ou de entrada / saída de recursos. Se este é um arquivo de entrada /
saída usado por um programa / Assembler COBOL, em seguida, o arquivo é referenciada por este nome dentro do
programa.
DD
Esta é a palavra-chave para identificá-lo como uma declaração DD.
PARÂMETROS
A seguir estão os vários parâmetros para uma instrução DD. Você pode usar um ou mais parâmetros (separados por
vírgula) com base em suas necessidades.
16
DSN
O parâmetro DSN se refere ao nome do conjunto de dados física de um conjunto de dados
recém-criado ou existente. O valor DSN pode ser composta de sub-nomes, cada um de
comprimento de 1 a 8 caracteres, separados por períodos e do total
comprimento de 44 caracteres
(Alfanumérico). A seguir é a sintaxe:
Nome DSN = Dataset Física
conjuntos de dados temporários precisar de armazenamento apenas para a duração do trabalho e
são excluídos na conclusão do trabalho. Tais conjuntos de dados são representados como DSN = &
Nome ou simplesmente sem um DSN especificado.
Se um conjunto de dados temporária criada por uma etapa de trabalho é para ser usado na próxima
trabalho degrau, então isto é referenciada como
DSN = *. Stepname.ddname. este é chamado Para trás
Referenciando.
DISP
O parâmetro DISP é usado para descrever o estado da base de dados, a disposição no
final do passo de trabalho de acabamento normal e anormal. DISP não é necessária em um
comunicado DD somente quando o conjunto de dados é criado e eliminado na mesma
etapa de trabalho (como os conjuntos de dados temporários).
A seguir é a sintaxe:
DISP = (estado, normal disposição, anormal-disposição)
A seguir estão os valores válidos para status:
• NOVO : O conjunto de dados é recém-criado pela etapa de trabalho. OUTPUT1 no
exemplo dado no final deste capítulo.
• VELHO : O conjunto de dados já está criada e será substituído na etapa de
trabalho. Os ganhos etapa de trabalho exclusivo
17
de acesso no conjunto de dados e nenhum outro trabalho pode acessar este conjunto de dados
até a conclusão da etapa de trabalho.
• SHR: O conjunto de dados já está criada e será lido na etapa de 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á está criado. Esta disposição será usado quando há
uma necessidade de anexar novos registros para o conjunto de dados existente
(registros existentes não serão substituídos).
UMA normal disposição parâmetro pode assumir um dos seguintes valores:
• CATLG, UNCATLG, DELETE, passar e MANTENHA
UMA anormal-disposição parâmetro pode assumir um dos seguintes valores:
• CATLG, UNCATLG, DELETE e MANTENHA
Aqui está a descrição de CATLG, UNCATLG, DELETE, passar, e manter os parâmetros:
• CATLG: O conjunto de dados é mantida com uma entrada no catálogo do sistema.
• UNCATLG: O conjunto de dados é mantido, mas a entrada de catálogo do sistema é
removido.
• GUARDA : O conjunto de dados é mantido sem alterar qualquer uma das entradas de
catálogo. MANTENHA é a única disposição válida para arquivos VSAM. Isso é para ser
usado somente para conjuntos de dados permanentes.
• APAGAR: Conjunto de dados é excluído do catálogo do usuário e do sistema.
• PASS: Isso só é válida para a disposição normal. Isto é
18
utilizado quando o conjunto de dados está a ser transmitida e processada pelo próximo passo do
trabalho em um JCL
Quando qualquer um dos sub-parâmetros de DISP não são especificados, os valores padrão
são os seguintes:
• status: NOVO é o valor padrão.
• normal disposição: Se o estado é novo, normaldisposition padrão é DELETE,
então é MANTENHA.
• anormal-disposição: Mesmo que a disposição normal.
DCB
O parâmetro Bloco de Controle de Dados (DCB) detalha as características físicas de um
conjunto de dados. Este parâmetro é necessário para conjuntos de dados que são
recém-criadas na etapa de trabalho.
LRECL é o comprimento de cada registro mantido dentro do conjunto de dados.
RECFM é o formato de registro do conjunto de dados. RECFM pode manter os valores FB, V,
ou VB.
• FB é uma organização de bloco fixo onde os registros de uma ou mais lógicas são
agrupados dentro de um único bloco.
• V é organização variável onde um registo lógico de comprimento variável é
colocado dentro de um bloco físico.
• VB é a organização do bloco de variáveis em que um ou mais discos lógicos
comprimento variável são colocados dentro de um bloco físico.
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 dataset. DSORG pode segurar a valores PS (Sequential
Física), PO (Organização particionado) e DA (Organização direto).
19
Quando há necessidade dos repetir os valores DCB de um conjunto de dados para outra
dentro da mesma etapa de trabalho ou JCL, em seguida, é especificada como DCB = *.
Stepname.ddname onde stepname é o nome da etapa de trabalho e ddanme é o conjunto
de dados a partir de qual a DCB é copiado.
Verificar o exemplo dado no final deste capítulo onde RECFM = FB, LRECL = 80 forma o
DCB do OUTPUT1 conjunto de dados.
ESPAÇO
O parâmetro ESPAÇO especifica o espaço necessário para o conjunto de dados na DASD
(disco Direct Access Storage). A seguir é a sintaxe:
Espaço = (spcunits, (PRI, sec, dir), RLSE)
Aqui está a descrição de todos os parâmetros utilizados:
• spcunits: Isso pode ser qualquer um Os seguintes:
CYL (Cilindro), TRK (faixas), ou BLKSIZE (Block Size).
• pri: Este é o espaço primário necessário para o conjunto de dados.
• seg: Este é o espaço adicional necessário, quando o espaço primário não está
sendo suficiente.
• ir: Este é os blocos de diretório necessários, se o conjunto de dados é um PDS (Dataset
particionado) com os membros que a compõem.
• RLSE: Isto é usado para liberar o espaço não utilizado na conclusão do trabalho.
UNIDADE
Os parâmetros da unidade e VOL estão listadas no catálogo do sistema para conjuntos de
dados catalogados e, portanto, pode ser acessado com apenas o nome DSN física. Mas
para conjuntos de dados não catalogados, a declaração DD deveria incluir esses
parâmetros. Para novos conjuntos de dados a ser criado, os parâmetros UNIDADE / vol ou
pode ser especificado o z / OS aloca o dispositivo e o volume adequado.
20
O parâmetro UNIT especifica o tipo de dispositivo em que o conjunto de dados está
armazenado. O tipo de dispositivo pode ser identificado utilizando Endereço de hardware ou
grupo de tipos de dispositivos. A seguir é a sintaxe:
UNIT = DASD | SYSDA
Onde DASD significa dispositivo de armazenamento de acesso direto e SYSDA significa Sistema
de Acesso Direto e refere-se para o próximo dispositivo de armazenamento em disco disponível.
VOL
O parâmetro VOL especifica o número de volume no dispositivo identificado pelo parâmetro
da unidade. A seguir é a sintaxe:
VOL = Ser = (v1, v2)
Onde v1, v2 são números de volume de série. Você pode usar a seguinte sintaxe assim:
VOL = REF = *. DDNAME
Onde REF é a referência para trás, para o número de série do volume de um conjunto de
dados em qualquer uma das etapas do trabalho anterior no JCL.
SYSOUT
Os parâmetros de instrução DD discutidos até agora corresponde a dados que estão sendo
armazenados em um conjunto de dados. O parâmetro SYSOUT direciona os dados para um
dispositivo de saída com base na classe especificada. A seguir é a sintaxe:
SYSOUT = class
Se a classe for A, em seguida, dirige a saída para a impressora; e se a classe for *, em
seguida, ele direciona a saída para o mesmo destino que o do parâmetro MSGCLASS na
instrução JOB.
21
Exemplo
O exemplo que se segue faz uso de instruções DD, juntamente com vários parâmetros, como explicado acima:
// FUNÇÃO TTYYSAMP 'TUTO', CLASSE = 6, MSGCLASS = X, REGIÃO = 8K,
// NOTIFY = & SYSUID
// *
// STEP010 EXEC PGM = ICETOOL, ADDRSPC = REAIS
// *
// INPUT1 DD DSN = TUTO.SORT.INPUT1, DISP = SHR
// ENTRADA2 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, ESPAÇO = (CIL, (10,20))
// SAÍDA 2 DD SYSOUT = *
22
6. JCL - biblioteca de base
Biblioteca de base é o particionado Dataset (PDS), que detém os módulos de carregamento do programa a ser
executado no JCL ou o procedimento catalogado, que é chamado no programa. bibliotecas base pode ser
especificado para todo o JCL numa JOBLIB biblioteca ou para uma etapa de trabalho específico em uma STEPLIB declaração.
Declaração JOBLIB
UMA JOBLIB declaração é usado para identificar a localização do programa a ser executado em um JCL. A
declaração JOBLIB é especificado após a declaração de trabalho e antes da instrução EXEC. Isso pode ser usado
somente para os procedimentos e programas InStream.
Sintaxe
A seguir está a sintaxe básica de uma instrução JCL JOBLIB:
// JOBLIB DD DSN = DSNName, DISP = SHR
A declaração JOBLIB é aplicável a todas as declarações EXEC dentro do JCL. O programa especificado na
instrução EXEC será procurado na biblioteca JOBLIB seguido da biblioteca do sistema.
Por exemplo, se a instrução EXEC está executando um programa COBOL, o módulo de carregamento do programa
COBOL deve ser colocada dentro da biblioteca JOBLIB.
Declaração STEPLIB
UMA STEPLIB declaração é usado para identificar a localização do programa a ser executado dentro de uma etapa
de trabalho. A instrução STEPLIB é especificado após a instrução EXEC e antes da declaração DD da etapa de
trabalho.
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á procurado na biblioteca STEPLIB seguido da biblioteca do
sistema. STEPLIB codificado em uma etapa de trabalho substitui a declaração JOBLIB.
23
Exemplo
O exemplo seguinte mostra o uso de declarações JOBLIB e STEPLIB:
// MYJCL JOB ,, CLASSE = 6, NOTIFY = & SYSUID
// *
// JOBLIB DD DSN = MYPROC.BASE.LIB1, DISP = SHR
// *
// STEP1 EXEC PGM = MYPROG1
// INPUT1 DD DSN = MYFILE.SAMPLE.INPUT1, DISP = SHR
// RECFM = FB, LRECL = 80
// *
// STEPLIB DD DSN = MYPROC.BASE.LIB2, DISP = SHR
// ENTRADA2 DD DSN = MYFILE.SAMPLE.INPUT2, DISP = SHR
// SAÍDA 2 DD DSN = MYFILES.SAMPLE.OUTPUT2, DISP = (, CATLG, DELETE),
Aqui, o módulo de carga do MYPROG1 programa (no passo 1) é pesquisada no MYPROC.SAMPLE.LIB1. Se não
for encontrado, ele é procurado na biblioteca do sistema. Em STEP2, STEPLIB substitui JOBLIB eo módulo de carga
do MYPROG2 programa é procurado em MYPROC.SAMPLE.LIB2 e, em seguida, na biblioteca do sistema.
include
Um conjunto de instruções JCL codificados dentro de um membro de um PDS pode ser incluído em um usando um
JCL INCLUIR declaração. Quando o JES interpreta o JCL, o conjunto de instruções JCL dentro do membro INCLUIR
substitui a instrução include.
Sintaxe
A seguir está a sintaxe básica de um JCL INCLUDE:
// nome incluem MEMBRO = member-name
24
O principal objetivo de ter um include declaração é reutilização. Por exemplo, arquivos comuns para ser usado em
muitos JCL pode ser codificado como instruções DD dentro de um membro do INCLUEM e utilizados de JCL.
demonstrações manequim DD, especificações do cartão de dados, PROC, trabalho, demonstrações PROC não pode ser
codificada dentro de um membro INCLUEM. Uma declaração inlcude podem ser codificados dentro de um membro do
INCLUEM e mais de nidificação pode ser feito até 15 níveis.
Declaração JCLLIB
UMA JCLLIB declaração é usada para identificar as bibliotecas particulares utilizados no trabalho. Ele pode ser usado tanto
com ecológica e procedimentos catalogados.
Sintaxe
A seguir está a sintaxe básica de uma instrução JCL JCLLIB:
// nome do JCLLIB ORDER = (Library1, Library2 ....)
As bibliotecas especificadas na instrução JCLLIB serão pesquisados na ordem dada para localizar os programas,
procedimentos e INCLUIR membro usado no trabalho. Pode haver apenas uma instrução JCLLIB em um JCL,
especificado após uma declaração de trabalho e antes de EXEC e INCLUDE, mas não podem ser codificados dentro
de um membro INCLUDE.
Exemplo
No exemplo a seguir, o MYPROG3 programa eo MYINCL INCLUIR membro são pesquisados na ordem de
MYPROC.BASE.LIB1, MYPROC.BASE.LIB2, biblioteca de sistema.
// MYJCL JOB ,, CLASSE = 6, NOTIFY = & SYSUID
// *
// MYLIB JCLLIB ORDEM = (MYPROC.BASE.LIB1, MYPROC.BASE.LIB2)
// *
// INC INCLUEM OS = MYINCL
25
// *
26
7. JCL - PROCEDIMENTOS
Procedimentos JCL são um conjunto de comandos dentro de uma JCL agrupadas para realizar uma função
específica. Normalmente, a parte fixa do JCL é codificada por um processo. A parte variável do trabalho está
codificada dentro da JCL.
Você pode usar um procedimento para obter execução paralela de um programa usando vários arquivos de entrada. A
JCL podem ser criados 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 do procedimento JCL:
// *
// Passo-nome nome procedimento EXEC
O conteúdo do processo são realizadas dentro da JCL para um procedimento de fluxo. Os conteúdos são mantidos
dentro de um membro diferente da biblioteca de base para um procedimento catalogado. Este capítulo vai explicar
dois tipos de procedimentos disponíveis em JCL e, finalmente, vamos ver como podemos aninhar vários
procedimentos.
Instream Procedimento
Quando o procedimento é codificada dentro do mesmo membro JCL, é chamado um

Procedimento ecológica. Deve começar com uma declaração PROC e terminar com uma declaração PEND.
// FUNÇÃO SAMPINST 1, CLASSE = 6, MSGCLASS = Y, AVISAR = & SYSUID
// *
// INSTPROC PROC // * INÍCIO DO PROCEDIMENTO
// PROC1 EXEC PGM = SORT
// SORTIN DD DSN = & DSNAME, DISP = SHR
//SEPARAR DD SYSOUT = * MYINCL
// SYSOUT DD = * SYSOUT
27
// SYSIN DD DSN = & DATAC LRECL = 80
// PEND // * FIM DO PROCEDIMENTO
// *
//PASSO 1 EXEC INSTPROC, DSNME = MYDATA.URMI.INPUT1,
// DATAC = MYDATA.BASE.LIB1 (DATA1)
// *
//PASSO 2 EXEC INSTPROC, DSNME = MYDATA.URMI.INPUT2
// *
No exemplo acima, o INSTPROC procedimento é chamado em STEP1 STEP2 e usando diferentes arquivos de
entrada. O DSNAME parâmetros e DATAC podem ser codificadas com diferentes valores ao chamar o procedimento
e estes são chamados como parâmetros simbólicos. A entrada variando ao JCL tais como nomes de ficheiros,
cartões de dados, valores PARM, etc., são transmitidos como parâmetros simbólicos para os procedimentos.
Enquanto a codificação parâmetros simbólicos, não use palavras-chave, parâmetros, ou sub-parâmetros como
nomes simbólicos. Exemplo: Não use TIME = & TIME mas você pode usar TIME = & TM e assume-se como a
maneira correta de codificação simbólica.
parâmetros simbólicos definidos pelo usuário são chamados JCL símbolos. Há determinados símbolos chamados símbolos
do sistema, que são usados para execuções de trabalho logon. O único símbolo sistema usado em trabalhos em
lote por usuários normais é & SYSUID e isso é usado na AVISAR parâmetro na instrução JOB.
Procedimento Catalogado
Quando o processo é separada a partir do JCL e codificado num armazenamento de dados diferentes, é chamado um Catalogado
Procedimento. Uma declaração PROC não é obrigatório a ser codificado em um procedimento catalogado. A seguir é
um exemplo de JCL onde ele está chamando um procedimento CATLPROC:
// *
// PASSO EXEC CATLPROC, PROG = CATPRC1, DSNME = MYDATA.URMI.INPUT
28
Aqui, o procedimento CATLPROC está catalogado no 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
//EM 1 DD DSN = & DSNAME, DISP = SHR
// OUT1 DD = * SYSOUT
// SYSIN DD DSN = & DATAC
// *
No âmbito do procedimento, os parâmetros simbólicos PROG e BASELB está codificada. Note que o parâmetro
PROG dentro do procedimento é substituído pelo valor no JCL e, portanto, PGM assume o valor CATPRC1 durante
a execução.
procedimentos aninhados
Chamar um procedimento de dentro de um procedimento é chamado de procedimento aninhada.

Os procedimentos podem ser aninhados até 15 níveis. O assentamento pode ser completamente ecológica ou catalogadas.
Não podemos codificar um procedimento de fluxo dentro de um procedimento catalogado.
// *
// SETNM SET DSNM1 = ENTRADA1, DSNM2 = OUTPUT1
// INSTPRC1 PROC // * INÍCIO DO PROCEDIMENTO 1
//PASSO 1 EXEC PGM = SORT, DISP = SHR
// SORTIN DD DSN = & DSNM1, DISP = SHR
29
//SEPARAR DD DSN = & DSNM2, DISP = (, PASS)
// *
//PASSO 2 EXEC PROC = INSTPRC2, DSNM2 = MYDATA.URMI.OUTPUT2
// PEND // * FIM DO PROCEDIMENTO 1
// *
// INSTPRC2 PROC // * INÍCIO DO PROCEDIMENTO 2
//PASSO 1 EXEC PGM = SORT
// SORTIN DD DSN = *. INSTPRC1.STEP1.SORTOUT
//SEPARAR DD DSN = & DSNM2, DISP = OLD
// PEND // * FIM DO PROCEDIMENTO 2
// *
// JSTEP1 EXEC INSTPRC1, DSNM1 = MYDATA.URMI.INPUT1,
// *
No exemplo acima, o JCL chama o procedimento INSTPRC1 em JSTEP1 eo INSTPRC2 procedimento está sendo
chamado dentro do procedimento INSTPRC1. Aqui, a saída de INSTPRC1 (SORTOUT) é passada como entrada
(SORTIN) para INSTPRC2.
UMA declaração SET é usado para definir simbólica comumente usados em etapas de trabalho ou procedimentos.
Ele inicializa os valores anteriores nos nomes simbólicos. Tem que ser definido antes da primeira utilização dos
nomes simbólicos no JCL.
Vamos ter um olhar para a seguinte descrição para entender um pouco mais sobre o programa acima:
• parâmetro SET inicializa DSNM1 = INPUT1 e DSNM2 = OUTPUT1.
30
• Quando INSTPRC1 é chamado dentro JSTEP1 do JCL,

DSNM1 = MYDATA.URMI.INPUT1 e DSNM2 = OUTPUT1., Ou seja, o valor inicializado na declaração SET
é reposto com o valor definido em qualquer uma das Job Step / procedimentos.
• Quando INSTPRC2 é chamado dentro PASSO 2 do INSTPRC1,

DSNM1 = MYDATA.URMI.INPUT1 e DSNM2 = MYDATA.URMI.OUTPUT2.
31
8. JCL - processamento condicional
O Sistema de Entrada Job utiliza duas abordagens para realizar processamento condicional em um JCL. Quando um
trabalho é concluído, um código de retorno é definido com base no estado de execução. O código de retorno pode ser
um número entre 0 (execução bem sucedida) para 4095 (diferente de 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 = Terminal de erro - problemas muito sérios, não use os resultados.
A execução etapa de trabalho pode ser controlada com base no código de retorno do passo anterior (s) usando o COND
parâmetro e IF-THEN-ELSE construir, o que foi explicado neste tutorial.
parâmetro COND
UMA COND parâmetro pode ser codificado no emprego ou EXEC declaração de JCL. É um teste no código de
retorno das etapas do trabalho anterior. Se o teste é avaliado para ser verdade, a execução atual etapa de trabalho
é ignorada. Ignorando é apenas omissão da etapa de trabalho e não uma finalização anormal. Não pode ser, no
máximo, oito condições combinadas em um único teste.
Sintaxe
A seguir está a sintaxe básica de um JCL COND Parâmetro:
COND = (rc, lógico-operador)
ou
COND = (rc, lógico-operador, stepname)
ou
COND = MESMO
ou
COND = SOMENTE
32
Aqui está a descrição dos parâmetros utilizados:
• rc: Este é o código de retorno
• lógico-operador: Isso pode ser GT (Maior que), GE (maior ou igual a), EQ (igual a), LT (menor do que), LE
(menor ou igual a), ou NE (não igual a).
• stepname: Esta é a etapa de trabalho, cujo código de retorno é usado no teste.
As duas últimas condições (a) COND = MESMO e (b) COND = SOMENTE, foram explicados abaixo neste tutorial.
O COND pode ser codificado quer dentro da instrução TRABALHO ou a instrução EXEC, e em ambos os casos, que se
comporta de modo diferente, como explicado abaixo:
COND dentro instrução JOB

Quando COND é codificado na instrução JOB, a condição é testada para cada etapa de trabalho. Quando a condição é
verdadeira em qualquer etapa de trabalho especial, é ignorada, juntamente com as etapas de trabalho seguem-lo. A
seguir é um exemplo:
// FUNÇÃO DE CLASSE CNDSAMP = 6, AVISAR = & SYSUID, COND = (5, LE)
// *
// Passo 10 EXEC PGM = FIRSTP
// * Passo 10 executa sem qualquer teste a ser realizado.
// STEP20 EXEC PGM = SECONDP
// * STEP20 é ignorada, se RC de Passo 10 é 5 ou superior.
// * Say Passo 10 termina com RC4 e daí teste é falso.
// * Então STEP20 executa e permite dizer que termina com RC16.
// STEP30 EXEC PGM = SORT
// * STEP30 é ignorada desde 5 <= 16.
33
COND dentro declaração EXEC

Quando COND é codificado na instrução EXEC de uma etapa de trabalho e encontrado para ser verdade, só isso etapa de
trabalho é ignorada, ea execução é continuada a partir da próxima etapa de trabalho.
// CNDSAMP JOB CLASS = 6, NOTIFY = & SYSUID
// *
// STP01 EXEC PGM = SORT
// * Assumindo STP01 termina com RC0.
// STP02 EXEC PGM = MYCOBB, COND = (0, EQ, STP01)
// * Em STP02, condição for avaliada como TRUE e passo ignorada.
// STP03 EXEC PGM = IEBGENER, COND = ((10, LT, STP01), (10, GT, STP02))
// * Em STP03, primeira condição falhar e, portanto, STP03 executa.
// * Desde STP02 é ignorada, a condição (10, GT, STP02) em
// * STP03 não é testado.
COND = MESMO
Quando COND = MESMO é codificado, a etapa de trabalho atual é executado, mesmo se nenhuma das etapas anteriores
anormalmente terminar. Se qualquer outra condição RC é codificado juntamente com COND = MESMO, em seguida, a etapa de
trabalho é executada se nenhuma das condições RC é verdade.
// *
// * Em STP02, condição for avaliada como TRUE e passo ignorada.
34
// STP03 EXEC PGM = IEBGENER, COND = ((10, LT, STP01), MESMO)
// * Em STP03, condição (10, LT, STP01) avalia a verdadeira,
// *, portanto, a etapa é ignorada.
COND = SOMENTE
Quando COND = Apenas é codificado, a etapa de trabalho atual é executado, somente quando qualquer uma das etapas anteriores
anormalmente terminar. Se qualquer outra condição RC é codificado juntamente com COND = SOMENTE, em seguida, a etapa de
trabalho é executada se nenhuma das condições RC é verdadeiro e qualquer uma das etapas de trabalho anteriores falhar de forma
anormal.
// *
// * Em STP02, condição for avaliada como FALSE, o passo é executado
// * e assumir os abends passo.
// STP03 EXEC PGM = IEBGENER, COND = ((0, EQ, STP01), SÓ)
// * Em STP03, embora os abends STP02, a condição
// * (0, EQ, STP01) for atendida. Daí STP03 é ignorada.
IF-THEN-ELSE Construir
Outra abordagem para controlar o processamento do trabalho é usando construções IF-THEN-ELSE. Esta é uma
maneira flexível e user-friendly de processamento condicional.
35
Sintaxe
A seguir está a sintaxe básica de uma construção JCL IF-THEN-ELSE:
// nome do IF condição THEN
lista de declarações // * ação a ser tomada quando a condição é verdadeira
// nome do ELSE
lista de declarações // * ação a ser tomada quando a condição é falsa
// nome do ENDIF
Segue-se a descrição dos termos utilizados no exemplo acima Construto If-Then-Else:
• nome: Isto é opcional e um nome pode ter de 1 a 8 caracteres alfanuméricos começando com alfabeto, #, $
ou @.
• estado: Uma condição terá um formato: VALOR DO OPERADOR PALAVRA-CHAVE, Onde PALAVRAS-CHAVE
pode ser RC (código de retorno), ABENDCC (sistema ou código de conclusão do usuário), ABEND, RUN
(etapa começou execução). A OPERADOR pode ser um operador lógico (AND (&), OR (|)) ou um operador
relacional (<, <=,>,> =, <>).
Exemplo
A seguir é um exemplo simples que mostra o uso de IF-THEN-ELSE:
// *
// PRC1 PROC
// Pst1 EXEC PGM = SORT
// PST2 EXEC PGM = IEBGENER
// PEND
// IF1 SE STP01.RC = 0 THEN
// STP02 EXEC PGM = MYCOBB1, PARM = 123
36
// FIM SE
// IF2 SE ENTÃO STP01.RUN
// STP03a EXEC PGM = IEBGENER
// STP03b EXEC PGM = SORT
// FIM SE
// IF3 IF STP03b.! ABEND ENTÃO
// STP04 EXEC PGM = MYCOBB1, PARM = 456
// OUTRO
// FIM SE
// IF4 IF (STP01.RC = 0 & STP02.RC <= 4) THEN
// STP05 EXEC PROC = PRC1
// FIM SE
// IF5 SE ENTÃO STP05.PRC1.PST1.ABEND
// STP06 EXEC PGM = MYABD
// OUTRO
// FIM SE
Vamos tentar olhar para o programa acima para compreendê-lo em um pouco mais detalhadamente:
• O código de retorno de STP01 é testado em IF1. Se for 0, então STP02 é executado. Else, o
processamento vai para a próxima instrução IF (IF2).
• Em IF2, Se STP01 iniciou a execução, em seguida, STP03a e STP03b são executados.
• Em IF3, Se STP03b não ABEND, então STP04 é executado. Em MAIS, não há declarações. Ele é
chamado uma declaração ELSE NULL.
• Em IF4, se STP01.RC = 0 e STP02.RC <= 4 são verdadeiras, então STP05 é executado.
37
• Em IF5, se o Pst1 proc-passo para PROC PRC1 em JobStep STP05 ABEND, então STP06 é executado.
STP07 Else é executado.
• Se IF4 avaliada como falsa, então STP05 não é executado. Nesse caso, IF5 não são testados e os passos
STP06, STP07 não são executados.
O IF-THEN-ELSE não será executada no caso de encerramento anormal do trabalho, tais como o usuário cancelar o
trabalho, expiração do tempo de trabalho, ou um conjunto de dados está para trás referenciados a um passo que é
ignorada.
Configurando Pontos de Verificação
Você pode definir um posto de controle dataset dentro do seu programa JCL
utilização SYSCKEOV, que é uma declaração DD.
UMA chkpt é o parâmetro codificado para conjuntos de dados QSAM multi-volume em um comunicado DD. Quando um
chkpt está codificada como chkpt = EOV, um ponto de verificação é escrito para o conjunto de dados especificado na
instrução SYSCKEOV no final de cada volume da entrada / saída do conjunto de dados de vários volumes.
// CHKSAMP JOB CLASS = 6, NOTIFY = & SYSUID
// *
// STP01 EXEC PGM = MYCOBB
// SYSCKEOV DD DSNAME = SAMPLE.CHK, DISP = MOD
//EM 1 DD DSN = SAMPLE.IN, DISP = SHR
// OUT1 DD DSN = sample.out, DISP = (, CATLG, CATLG)
// Chkpt = EOV, LRECL = 80, RECFM = FB
No exemplo acima, um posto de controlo é escrito na SAMPLE.CHK conjunto de dados no final de cada volume do
sample.out conjunto de dados de saída.
Reiniciar Processamento
Você pode reiniciar o processamento automaticamente, usando o parâmetro RD ou manualmente, utilizando o parâmetro
RESTART.
parâmetro RD é codificado na instrução JOB ou EXEC e ajuda na automatizado reinicie o trabalho / STEP e pode
conter um dos quatro valores: R, RNC, NR, ou NC.
• RD = R permite reiniciar automatizados e considera o ponto de verificação codificado no parâmetro chkpt da

declaração DD.
38
• RD = RNC permite reiniciar automatizados, mas sobrepõe (ignora) o parâmetro chkpt.
• RD = NR especifica que o trabalho / passo não pode ser reiniciado automaticamente. Mas quando ele é
reiniciado manualmente usando o parâmetro RESTART, parâmetro chkpt (se houver) serão consideradas.
• RD = NC não permite o reinício automático e processamento de ponto de verificação.
Se há uma exigência para fazer o reinício automático de códigos de abend específicos apenas, então ele pode ser
especificadas no SCHEDxx membro da biblioteca parmlib sistema IBM.
parâmetro RESTART é codificado na instrução JOB ou EXEC e ajuda na reinicialização manual da JOB / STEP
depois do fracasso trabalho. RESTART pode ser acompanhado com um checkid, que é o ponto de verificação
escrito no conjunto de dados codificados na demonstração SYSCKEOV DD. Quando um checkid é codificado, a
declaração SysChk DD deve ser codificado para fazer referência ao conjunto de dados posto de controle após a
declaração JOBLIB (se houver), senão após a instrução JOB.
// FUNÇÃO DE CLASSE CHKSAMP = 6, AVISAR = & SYSUID, RESTART = (STP01, chk5)
// *
// SysChk DD DSN = SAMPLE.CHK, DISP = OLD
// * SYSCKEOV DD DSNAME = SAMPLE.CHK, DISP = MOD
//EM 1 DD DSN = SAMPLE.IN, DISP = SHR
// OUT1 DD DSN = sample.out, DISP = (, CATLG, CATLG)
// Chkpt = EOV, LRECL = 80, RECFM = FB
No exemplo acima, é o chk5 checkid, ou seja, STP01 é reiniciada no checkpoint5. Note-se que uma declaração
SysChk é adicionado e declaração SYSCKEOV é comentada no programa anterior explicado em Definindo seção
Checkpoint.
39
9. JCL - DEFINIÇÃO DATASETS
Um nome de conjunto de dados especifica o nome de um arquivo e é denotado por DSN no JCL. O parâmetro DSN
se refere ao nome do conjunto de dados física de um conjunto de dados recém-criado ou existente. O valor DSN
pode ser composta de sub-nomes de cada um 1 a 8 caracteres de comprimento, separadas por períodos e de
comprimento total de 44 caracteres alfanuméricos (). A seguir é a sintaxe:
DSN = & Nome | * .stepname.ddname
conjuntos de dados temporários precisar de armazenamento apenas para a duração do trabalho e são excluídos na conclusão do
trabalho. Tais conjuntos de dados são representados como DSN = & Nome ou simplesmente sem um DSN especificado.
Se um conjunto de dados temporária criada por uma etapa de trabalho é para ser usado na próxima etapa de trabalho, então ele
é referenciado como DSN = *. Stepname.ddname. Isso é chamado Referenciando para trás.
concatenação de conjuntos de dados
Se houver mais do que um conjunto de dados com o mesmo formato, eles podem ser concatenadas e passou como uma
entrada para o programa em um único nome DD.
// CONCATEX JOB CLASS = 6, NOTIFY = & SYSUID
// *
// Passo 10 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 concatenadas e passado como entrada para o programa de
classificação no nome SORTIN DD. Os arquivos são mesclados, classificado nos campos chave especificada e, em
seguida, escrito para um único SAMPLE.OUTPUT arquivo de saída em nome SORTOUT DD.
40
Conjuntos de dados primordiais
Em um JCL padronizada, o programa a ser executado e seus conjuntos de dados relacionados são colocados dentro de
um procedimento catalogado, o que é chamado no JCL. Normalmente, para fins de teste ou para uma correção
incidente, pode haver a necessidade de utilizar diferentes que não sejam os especificados no procedimento catalogado
conjuntos de dados. Nesse caso, o conjunto de dados no procedimento pode ser substituído no JCL.
// *
// JSTEP1 EXEC CATLPROC, PROG = CATPRC1, DSNME = MYDATA.URMI.INPUT
//STEP1.IN1 DD DSN = MYDATA.OVER.INPUT, DISP = SHR
// *
// * O procedimento catalogado como abaixo:
// *
// CATLPROC PROC PROG =, BASELB = MYCOBOL.BASE.LIB1
// *
//PASSO 1 EXEC PGM = & PROG
// STEPLIB DD DSN = & BASELB, DISP = SHR
//EM 1 DD DSN = MYDATA.URMI.INPUT, DISP = SHR
// SYSIN DD MYDATA.BASE.LIB1 (DATA1), DISP = SHR
// *
No exemplo acima, o IN1 conjunto de dados usa o MYDATA.URMI.INPUT arquivo no PROC, que é substituído no JCL.
Assim, o arquivo de entrada usado na execução é MYDATA.OVER.INPUT. Note-se que o conjunto de dados é referido
como STEP1.IN1. Se houver apenas um passo no JCL / PROC, em seguida, o conjunto de dados pode ser referido
com apenas o nome DD. Da mesma forma, se houver mais do que um passo no JCL, em seguida, o conjunto de dados
deve ser substituído como JSTEP1.STEP1.IN1.
41
// *
//DEGRAU EXEC CATLPROC, PROG = CATPRC1, DSNME = MYDATA.URMI.INPUT
//STEP1.IN1 DD DSN = MYDATA.OVER.INPUT, DISP = SHR
// DD DUMMY
// DD DUMMY
// *
No exemplo acima, a partir dos três conjuntos de dados concatenados em IN1, o primeiro é sobreposto na JCL e o
resto é mantido em que estejam presentes em Proc.
Definindo GDGs em um JCL
Geração de Grupos de Dados (GDGs) são um grupo de conjuntos de dados relacionados entre si por um nome
comum. O nome comum é conhecido como base de GDG e cada conjunto de dados associado com a base é chamado
de versão GDG.
Por exemplo, MYDATA.URMI.SAMPLE.GDG é o nome base GDG. Os conjuntos de dados são

nomeado Como MYDATA.URMI.SAMPLE.GDG.G0001V00,
MYDATA.URMI.SAMPLE.GDG.G0002V00, e assim por diante. A versão mais recente do GDG é referido como
MYDATA.URMI.SAMPLE.GDG (0), versões anteriores são referidos como (-1), (-2), e assim por diante. A próxima
versão a ser criado em um programa é referido como MYDATA.URMI.SAMPLE.GDG (+1) na JCL.
Criar / Alter GDG em um JCL
As versões GDG pode ter iguais ou diferentes parâmetros DCB. Um DCB modelo inicial pode ser definido para ser
usado por todas as versões, mas pode ser substituído durante a criação de novas versões.
// GDGSTEP1 EXEC PGM = IDCAMS
// SYSPRINT DD SYSOUT = *
// SYSIN DD *
DEFINE GDG (NAME (MYDATA.URMI.SAMPLE.GDG) -
LIMITE (7) -
42
NOEMPTY -
COÇAR, ARRANHÃO)
/*
// GDGSTEP2 EXEC PGM = IEFBR14
// GDGMODLD DD DSN = MYDATA.URMI.SAMPLE.GDG,
// DISP = (NOVO, CATLG, DELETE),
// UNIDADE = SYSDA,
// ESPAÇO = (CYL, 10,20),
// DCB = (LRECL = 50, RECFM = FB)
//
No exemplo acima, a utilidade IDCAMS define a base GDG em GDGSTEP1 com os seguintes parâmetros passados
na demonstração SYSIN DD:
• NOME especifica o nome conjunto de dados físico da base GDG.
• LIMITE especifica o número máximo de versões que a base GDG pode conter.
• VAZIO uncataloges todas as gerações, quando o limite é atingido.
• NOEMPTY uncataloges a geração menos recente.
• COÇAR, ARRANHÃO exclui fisicamente a geração quando é não catalogada.
• NOSCRATCH não exclua o conjunto de dados, ou seja, ele pode ser chamado usando os parâmetros da
unidade e VOL.
Em GDGSTEP2, IEFBR14 utilidade especifica parâmetros DD modelo a ser utilizados por todas as versões.
IDCAMS pode ser utilizada para alterar os parâmetros de definição de um GDG tais como aumentar o limite,
mudando vazio para NOEMPTY, etc, e suas versões relacionadas utilizando o comando SYSIN ALTER
MYDATA.URMI.SAMPLE.GDG LIMITE (15) VAZIO.
43
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, apagar, apagar)
No exemplo acima, a última versão do MYDATA.URMI.SAMPLE.GDG é excluído. Note que o parâmetro DISP na
conclusão do trabalho normal é codificado como DELETE. Assim, o conjunto de dados é excluído quando o trabalho
for concluído execução.
IDCAMS pode ser usado para excluir o GDG e suas versões relacionadas com o comando SYSIN APAGAR
(MYDATA.URMI.SAMPLE.GDG) GDG FORÇA / purga.
• FORÇA exclui as versões GDG e da base GDG. Se qualquer uma das versões GDG são ajustados com
uma data de validade que ainda é a expirar, em seguida, aqueles que não são eliminados e, portanto, a
base GDG é retida.
• PURGA exclui as versões GDG e da base GDG, independentemente da data de validade.
Usando GDG em um JCL
No exemplo a seguir, a última versão do MYDATA.URMI.SAMPLE.GDG é usado como entrada para o programa e
uma nova versão do MYDATA.URMI.SAMPLE.GDG é criado como a saída.
// *
//EM 1 DD DSN = MYDATA.URMI.SAMPLE.GDG (0), DISP = SHR
// OUT1 DD DSN = MYDATA.URMI.SAMPLE.GDG (1), DISP = (, CALTG, DELETE)
Aqui, E se o GDG tinha sido referido pelo nome real gostar
MYDATA.URMI.SAMPLE.GDG.G0001V00, então isso leva a mudar o JCL cada vez antes da execução. Usando (0)
e (1) faz com que seja dinamicamente substituir a versão GDG para execução.
44
10. JCL - Entrada / métodos de saída
Qualquer programa de lote executado através de um JCL requer entrada de dados, que é processado e uma saída é
criado. Existem diferentes métodos de alimentação de entrada para o programa de e escrever saída recebida a partir
de um JCL. No modo de lote, não há interacção do utilizador requerida, mas os dispositivos de entrada e de saída e
a organização requerida são definidos em JCL e submetido.
Entrada de dados em um JCL
Existem várias maneiras para alimentar os dados para um programa usando JCL e estes métodos têm sido
explicadas abaixo:
DADOS ECOLÓGICA
dados InStream para um programa podem ser especificados usando uma instrução SYSIN DD.
// CONCATEX JOB CLASS = 6, NOTIFY = & SYSUID
//* Exemplo 1:
// Passo 10 EXEC PGM = myprog
//EM 1 DD DSN = SAMPLE.INPUT1, DISP = SHR
// OUT1 DD DSN = SAMPLE.OUTPUT1, DISP = (, CATLG, DELETE),
// SYSIN DD *
// CUST1 1000
// Cust2 1001
/*
// *
// * Exemplo 2:
// STEP20 EXEC PGM = myprog
// OUT1 DD DSN = SAMPLE.OUTPUT2, DISP = (, CATLG, DELETE),
45
// SYSIN DD DSN = SAMPLE.SYSIN.DATA, DISP = SHR
// *
No Exemplo 1, a entrada para myprog é passado através SYSIN. Os dados são fornecidos dentro do JCL. Dois
registros de dados são passados para o programa. Note-se que / * marca o fim dos dados ecológica SYSIN.
"CUST1 1000" é record1 e "Cust2 1001" é RECORD2. Fim da condição de dados é satisfeito quando o símbolo / * é
encontrado durante a leitura dos dados.
No Exemplo 2, os dados SYSIN é realizada dentro de 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 em capítulos anteriores, a entrada de dados para um programa pode ser
fornecido através de PS, VSAM, ou arquivos de GDG, com parâmetros de nome DSN e DISP relevantes juntamente com
instruções DD.
No Exemplo 1, SAMPLE.INPUT1 é o ficheiro de entrada através da qual os dados são passados para myprog. É
referido como IN1 dentro do programa.
Saída de dados em um JCL
A saída de um JCL pode ser catalogada em um conjunto de dados ou transmitido para o SYSOUT. Como
mencionado no capítulo declarações DD, SYSOUT = * redireciona a saída para a mesma classe como a mencionada
no parâmetro MSGCLASS da instrução JOB.
Saving Logs Job

especificando MSGCLASS = Y salva o registro de trabalhos na JMR (Gestão Joblog e Recuperação). O registro de
trabalho inteiro pode ser redirecionado para o carretel e podem ser salvos em um conjunto de dados, dando o
comando XDC contra o nome do trabalho no carretel. Quando o comando XDC é dada no SPOOL, uma tela de
criação de conjunto de dados é aberto. O registo de trabalhos podem ser salvos, dando PS apropriado ou definição
PDS.
logs de tarefas também podem ser salvos em um conjunto de dados, ao mencionar um conjunto de dados já criado para
SYSOUT e SYSPRINT. Mas o log trabalho inteiro não pode ser capturado através desta forma (ou seja, JESMSG não
será catalogado) como feito em JMR ou XDC.
46
// *
//PASSO 1 EXEC PGM = myprog
//EM 1 DD DSN = MYDATA.URMI.INPUT, DISP = SHR
// SYSOUT DD DSN = MYDATA.URMI.SYSOUT, DISP = SHR
// SYSPRINT DD DSN = MYDATA.URMI.SYSPRINT, DISP = SHR
// SYSIN DD MYDATA.BASE.LIB1 (DATA1), DISP = SHR
// *
No exemplo acima, SYSOUT está catalogado em MYDATA.URMI.SYSOUT e SYSPRINT em

MYDATA.URMI.SYSPRINT.
47
11. JCL - RUN COBOL programas usando JCL
Compilar programas COBOL

A fim de executar um programa COBOL na modalidade de grupo usando JCL, o programa precisa ser compilado e
um módulo de carga é criado com todos os sub-programas. O JCL usa o módulo de carregamento e não o programa
atual no momento da execução. As bibliotecas de carregamento são concatenados e dada à 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 usar Change Management Ferramentas
gostar endevor, que compila e armazena todas as versões do programa. Isto é útil no rastreamento das alterações
feitas no programa.
// compile TRABALHO, DA CLASSE = 6, MSGCLASS = X, = & AVISAR SYSUID
// *
//PASSO 1 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
// *
IGYCRCTL é um utilitário compilador IBM COBOL. As opções do compilador são passados através do parâmetro
PARM. No exemplo acima, instrui o compilador RMODE para utilizar o modo de endereçamento relativo no
programa. O programa COBOL é passado através do parâmetro SYSIN eo caderno é a biblioteca usada pelo
programa em SYSLIB.
Este JCL produz o módulo de carregamento do programa de saída, que é usado como entrada para a execução
JCL.
A execução de programas COBOL
No seguinte exemplo JCL, o myprog programa é executado usando o MYDATA.URMI.INPUT arquivo de entrada e
produz dois arquivos de saída escritos para o carretel.
48
// COBBSTEP JOB CLASS = 6, NOTIFY = & SYSUID
//
// Passo 10 EXEC PGM = myprog, PARM = ACCT5000
// STEPLIB DD DSN = MYDATA.URMI.LOADLIB, DISP = SHR
// INPUT1 DD DSN = MYDATA.URMI.INPUT, DISP = SHR
// SYSIN DD *
// CUST1 1000
// Cust2 1001
/*
O módulo de carga de myprog está localizado na MYDATA.URMI.LOADLIB. Isto é importante notar que a acima JCL
pode ser usado por apenas um módulo de COBOL não-DB2.
Passando dados para programas COBOL
A entrada de dados para um programa de lote COBOL pode ser através de arquivos, parâmetro PARAM e
declaração SYSIN DD. No exemplo acima:
• registros de dados são passados para myprog através MYDATA.URMI.INPUT arquivo. Este arquivo será
designado no programa usando o nome INPUT1 DD. O arquivo pode ser aberto, ler, e fechou no programa.
• Os dados ACCT5000 parâmetro PARM é recebido na seção de vinculação do myprog programa em uma
variável definida dentro dessa seção.
• Os dados da declaração SYSIN é recebido através ACEITAR declaração na divisão de Processo do

programa. Cada ACEITAR indicação lê um álbum inteiro (ou seja, CUST1 1000) em uma variável
armazenamento de trabalho definido no programa.
Execução de um programa COBOL-DB2
Para a execução de programas DB2 COBOL, utilitário especializado IBM é usado no programa JCL; a região DB2 e
os parâmetros necessários são passados como entrada para o utilitário.
49
• Quando um programa COBOL-DB2 é compilado, um DBRM (Banco de Dados Request Module) é criado
junto com o módulo de carga. O DBRM contém as instruções SQL dos programas COBOL com sua sintaxe
verificada a ser corretas.
• O DBRM está ligada à região do DB2 (ambiente), na qual corre COBOL. Isso pode ser feito usando o
utilitário IKJEFT01 em um JCL.
• Após o passo de ligação, o programa COBOL-DB2 é executado utilizando IKJEFT01 (novamente) com a biblioteca
de carregamento e a biblioteca DBRM como a entrada para o JCL.
// STEP001 EXEC PGM = IKJEFT01
// *
// STEPLIB DD DSN = MYDATA.URMI.DBRMLIB, DISP = SHR
// *
// arquivos de entrada
// arquivos de saída
// SYSABOUT DD SYSOUT = *
// SYSDBOUT DD SYSOUT = *
// SYSUDUMP DD SYSOUT = *
// exibe DD SYSOUT = *
// SYSOUT DD SYSOUT = *
// SYSTSPRT DD SYSOUT = *
// SYSTSIN DD *
SYSTEM DSN (SSID)
Executar o programa (MYCOBB) PLANO (PLANNAME) PARM (parâmetros para programa cobol) -
LIB ( 'MYDATA.URMI.LOADLIB')
FIM
/*
50
No exemplo acima, MYCOBB é o programa COBOL-DB2 execução usando IKJEFT01. Note que o nome do
programa, DB2 Sub-System ID (SSID), o nome do Plano de DB2 são passados dentro da instrução SYSTSIN DD. A
biblioteca DBRM é especificado no STEPLIB.
51
12. JCL - programas utilitários
IBM Conjunto de Dados Utilities
programas utilitários são programas pré-escrita, amplamente utilizado em mainframes por programadores de
sistema e desenvolvedores de aplicativos para atender às exigências do dia-a-dia, organização e manutenção de
dados. Alguns deles estão listados abaixo com a sua funcionalidade:
Nome Utility funcionalidade
IEHMOVE Move-se conjuntos de dados sequenciais ou cópias.
IEHPROGM Excluindo e renomeando conjuntos de dados; catálogo ou outros que VSAM conjuntos de
dados UNCATALOG.
IEHCOMPR Compara os dados em conjuntos de dados sequenciais.
IEBCOPY Cópia, Merge, comprimir, back-up, ou restaurar PDS.
IEFBR14
Nenhum utilitário operação. Usado para retornar o controle para o usuário e terminar. É
normalmente usado para criar dataset vazio ou excluir um conjunto de dados existente.
Por exemplo, se um conjunto de dados é transmitido como entrada para um programa IEFBR14
com DISP = (OLD, apagar, apagar), o conjunto de dados é eliminada na conclusão do trabalho.
IEBEDIT Usado para copiar partes selecionadas de um JCL. Por exemplo, se um JCL tem
cinco passos e que exigem para executar o passo 1 e 3 só, em seguida, uma
IEBEDIT JCL pode ser codificada com um conjunto de dados que contém o JCL real
a ser executado. No SYSIN de IEBEDIT, podemos especificar STEP1 e STEP3 como
parâmetros. Quando isso JCL é executado, ele executa o
52
STEP1 e STEP3 do JCL real.
IDCAMS Criar, excluir, renomear, catálogo, conjuntos de dados UNCATALOG (exceto PDS). Normalmente
usado para gerenciar conjuntos de dados VSAM.
Estes programas utilitários precisa para ser usado com instruções DD apropriados em um JCL, a fim de atingir a
funcionalidade especificado.
DFSORT Overview
DFSORT é um poderoso utilitário IBM usado para copiar, classificar, ou mesclar conjuntos de dados. SORTIN e SORTINnn DD
declarações são usadas para especificar conjuntos de dados de entrada. SORTOUT e Outfil declarações são usadas para
especificar dados de saída.
declaração SYSIN DD é usado para especificar o tipo e mesclar condições. DFSORT é geralmente utilizado para
obter as seguintes funcionalidades:
• SORT o ficheiro (s) de entrada na ordem da posição do campo especificado (s) no ficheiro.
• Incluir ou omitir registos do ficheiro (s) de entrada com base na condição especificada.
• SORT MERGE ficheiro (s) de entrada na ordem da posição do campo especificado (s) no ficheiro.
• SORT unir dois ou mais arquivos de entrada com base em um determinado Cadastre-CHAVE (campo (s) em cada arquivo de entrada).
• Quando há processamento adicional a ser feito sobre os arquivos de entrada, um programa de saída do usuário
pode ser chamado a partir do programa SORT. Por exemplo, se houver um cabeçalho / trailer para ser adicionado
ao arquivo de saída, em seguida, um programa COBOL USUÁRIO escrita pode ser chamado a partir do programa
SORT para executar esta funcionalidade. Usando um cartão de controle, os dados podem ser transferidos para o
programa COBOL.
• No contrário, uma espécie 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 em vista do desempenho para arquivos grandes.
53
ICETOOL Overview
ICETOOL é um multiusos DFSORT utilizado para realizar uma variedade de operações em conjuntos de dados.
conjuntos de dados de entrada e saída pode ser definida usando nomes DD definidas pelo usuário. As operações de
arquivo são especificados na instrução toolin DD. Condições adicionais pode ser especificada em declarações 'CTL'
DD definidos pelo utilizador.
Alguns dos utilitários de ICETOOL são dadas abaixo:
• ICETOOL pode alcançar todas as funcionalidades de DFSORT em uma ou mais condições.
• SPLICE é uma poderosa operação de ICETOOL que é semelhante para classificar JOIN, mas com características
adicionais. Pode comparar dois ou mais arquivos no campo (s) especificado e criar um ou mais arquivos de saída
como arquivo com registros correspondentes, arquivo com registros não correspondentes, etc.
• Dados em um arquivo em uma posição particular podem ser cobertos em outra posição na mesma ou em
diferentes arquivos.
• Um arquivo pode ser dividido em n arquivos com base em uma condição especificada. Por exemplo, um arquivo
contendo os nomes dos funcionários pode ser dividido em 26 arquivos, cada um contendo os nomes começando com
A, B, C, e assim por diante.
• combinação diferente de manipulação de arquivos é possível usando ICETOOL com um pouco de exploração
da ferramenta.
SYNCSORT Overview
SYNCSORT é usado para copiar, mesclar ou classificar conjuntos de dados com alto desempenho. Ele dá a melhor
utilização dos recursos do sistema e operação eficiente em espaços de endereçamento de 32 bits e de 64 bits.
Ele pode ser utilizado nas mesmas linhas de DFSORT e pode atingir as mesmas características. Ele pode ser invocado por um
JCL ou a partir de dentro de um programa codificado em COBOL, PL / 1, ou linguagem Assembler. Ele também suporta
programas de saída de usuário para ser chamado a partir do programa SYNCSORT.
truques de classificação utilizados com frequência usando estes utilitários são explicados no próximo capítulo. exigências
complexas que requerem grande programação em COBOL / MONTADORA pode ser conseguido usando os utilitários
acima em passos simples.
54
13. JCL - TRUQUES SORT BÁSICOS
Os requisitos de aplicações do dia-a-dia em um mundo corporativo que pode ser conseguido usando programas de
utilidade são ilustrados abaixo:
1. Um arquivo tem 100 registros. Os primeiros 10 registros precisam ser escritos para o arquivo de saída.
// JSTEP020 EXEC PGM = ICETOOL
// TOOLMSG DD SYSOUT = *
// DFSMSG DD SYSOUT = *
//EM 1 DD DSN = MYDATA.URMI.STOPAFT, DISP = SHR
// toolin DD *
COPY FROM (IN1) a (OUT1) UTILIZAÇÃO (CTL1)
/*
// CTL1CNTL DD *
OPÇÃO STOPAFT = 10
/*
O STOPAFT opção irá parar de ler o arquivo de entrada após o registro 10 e termina o programa. Assim, 10
registros são escritos para a saída.
2. O arquivo de entrada tem um ou mais registros de mesmo número de funcionários. Escrever registros
exclusivos para a saída.
// SORTIN DD DSN = MYDATA.URMI.DUPIN, DISP = SHR
// SORTOUT DD SYSOUT = *
// SYSIN DD *
55
SORT CAMPOS = (1,15, ZD, A)
SUM CAMPOS = NONE
/*
SUM CAMPOS = NONE remove duplicados em campos especificados em campos de classificação. No exemplo acima,
o número do empregado está na posição de campo de 1,15. O arquivo de saída conterá os números de funcionários
únicos classificados em ordem crescente.
3. Substituir o conteúdo registro de entrada.
// JSTEP010 EXEC PGM = SORT
// SORTIN DD DSN = MYDATA.URMI.SAMPLE.MAIN, DISP = SHR
// SYSIN DD *
opção de cópia
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. operação de OVERLAY INREC é utilizado, a fim de reescrever os dados no arquivo de entrada antes de
copiar para a saída.
4. A adição de um número de seqüência no arquivo de saída.
// SORTIN DD *
data1
data2
data3
/*
56
// SYSIN DD *
opção de cópia
CONSTRUIR = (1: 1,5,10: SEQNUM, 4, ZD, COMEÇA = 1,000, œINCR = 2)
/*
A saída será:
data1 1000
data2 1002
data3 1004
número de sequência de 4 dígitos é adicionado na saída na posição 10, a partir de 1000, e incrementada por dois
para cada ficha.
5. Adicionando cabeçalho / Trailer de arquivo de saída.
// SORTIN DD *
data1
data2
data3
/*
// SYSIN DD *
SORT CAMPOS = CÓPIA
57
Outfil REMOVECC,
Header1 = (1: C'HDR '10: X'020110131C'),
TRAILER1 = (1: C'TRL', TOT = (10,9, PD, TO = PD, comprimento = 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 de cabeçalho /
trailer, que é definida pelo usuário e pode ser personalizado de acordo com as necessidades dos usuários.
6. Processamento Condicional
// SORTIN DD *
data1select
data2
data3select
/*
// SYSIN DD *
INREC IfThen = (QUANDO = (6,1, CH, NE, C' '), CONSTRUIR = (1: 1,15),
IfThen = (QUANDO = (6,1, CH, EQ, C' '), CONSTRUIR = (1: 1,5,7: C'EMPTY ')
58
opção de cópia
/*
A saída será:
data1select
data2 VAZIO
data3select
Com base na posição 6 do arquivo, a compilação de arquivo de saída varia. Se 6ª posição é ESPAÇOS, então o
texto "vazio" é anexado ao registro de entrada. Else, o registro de entrada é escrito na saída, tal como está.
7. Fazer o backup de um arquivo
// JSTEP001 EXEC PGM = IEBGENER
// SYSIN DD *
// SORTOUT DD DUMMY
// SYSUT1 DD DSN = MYDATA.URMI.ORIG, DISP = SHR
// SYSUT2 DD DSN = MYDATA.URMI.BACKUP, DISP = (NOVO, CATLG, DELETE),
// DCB = *. SYSUT1, ESPAÇO = (CIL, (50,1), RLSE)
IEBGENER copia o arquivo em SYSUT1 para arquivar em SYSUT2. Observe que o arquivo em SYSUT2 leva o
mesmo DCB como a do SYSUT1 no exemplo acima.
8. Comparação Arquivo
//A PRINCIPAL DD *
1000
1001
59
1003
1005
// DD PROC *
1000
1002
1003
//PARTIDA 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
// SYSIN DD *
JOINKEYS F1 = PRINCIPAL, CAMPOS = (1,4, UM)
JOINKEYS F2 = PROC, CAMPOS = (1,4, UM)
Cadastre desemparelhados, F1, F2
REFORMAT CAMPOS = (?, F1: 1,4, F2: 1,4)
opção de cópia
Outfil FNAMES = JOGO, INCLUEM = (1,1, CH, EQ, C'B '), CONSTRUIR = (1: 2,4)
Outfil FNAMES = NOMATCH1, INCLUEM = (1,1, CH, EQ, C'1' ), CONSTRUIR = (1: 2,4)
Outfil FNAMES = NOMATCH2, INCLUEM = (1,1, CH, EQ, C'2' ), CONSTRUIR = (1: 2,4)
/*
• JOINKEYS especifica o campo no qual os dois arquivos são comparados.
• REFORMAT FIELDS =? lugares 'B' (registos correspondentes), '1' (presentes em arq1, mas não em arq2),
ou '2' (presente em arq2 mas não em arq1) na primeira posição da compilação de saída.
• Cadastre-se desemparelhados uma junção externa completa sobre os dois arquivos.
60
A saída será:
Arquivo JOGO
1000
1003
Arquivo NOMATCH1
1001
1005
Arquivo NOMATCH2
1002
A mesma funcionalidade pode ser conseguida utilizando ICETOOL também.
61

JCL Tutorial - En.pt

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

JCL Tutorial - En.pt

Enviado por

Direitos autorais:

Formatos disponíveis

Job Control Language

Disclaimer e direitos autorais

• Copyright 2015 Tutoriais ponto (I) Pvt. Ltd.

Público ................................................. .................................................. ............................................... Eu

Pré-requisitos ................................................. .................................................. ......................................... Eu

Disclaimer e direitos autorais ............................................... .................................................. ............................ Eu

Índice ............................................... .................................................. ii ...................................

1. JCL - PANORAMA ............................................... .................................................. ...................... 1

Quando usar JCL .............................................. .................................................. ...................................... 1

Processamento de trabalho ................................................ .................................................. ....................................... 1

2. JCL - configuração do ambiente .............................................. .................................................. 3

Instalando JCL no Windows / Linux ............................................ .................................................. ............... 3

Correndo JCL em Mainframes .............................................. .................................................. .................... 3

Estrutura de um JCL .............................................. .................................................. ..................................... 4

Descrição do Programa ................................................ .................................................. ............................. 4

Tipos de trabalho Parâmetros ............................................... .................................................. ............................. 5

3. JCL - DEMONSTRAÇÃO DE TRABALHO .............................................. .................................................. ........... 6

Sintaxe ................................................. .................................................. .................................................. 6

Descrição ................................................. .................................................. ........................................... 6

Exemplo ................................................. .................................................. ............................................. 10

Parâmetros diversos ................................................ .................................................. .................. 10

4. JCL - DEMONSTRAÇÃO EXEC .............................................. .................................................. ....... 12

Sintaxe ................................................. .................................................. ................................................ 12

Descrição ................................................. .................................................. ......................................... 12

Parâmetros palavra-chave comuns de EXEC e Declaração JOB .......................................... ........................ 14

Exemplo ................................................. .................................................. ............................................. 15

5. JCL - DD DECLARAÇÃO .............................................. .................................................. ........... 16

Sintaxe ................................................. .................................................. ................................................ 16

Descrição ................................................. .................................................. ......................................... 16

Exemplo ................................................. .................................................. ............................................. 22

6. JCL - biblioteca de base .............................................. .................................................. ............. 23

Declaração JOBLIB ................................................ .................................................. ................................ 23

Declaração STEPLIB ................................................ .................................................. .............................. 23

Include ................................................ .................................................. ............................ 24

Declaração JCLLIB ................................................ .................................................. ................................. 25

7. JCL - PROCEDIMENTOS ............................................... .................................................. ............... 27

Sintaxe ................................................. .................................................. ................................................ 27

Instream Procedimento ................................................ .................................................. ............................. 27

Catalogado Procedimento ................................................ .................................................. ........................... 28

Procedimentos aninhados ................................................ .................................................. .............................. 29

8. JCL - processamento condicional .............................................. ...................................... 32

parâmetro COND ................................................ .................................................. ................................. 32

COND dentro instrução JOB .............................................. .................................................. .................. 33

COND dentro declaração EXEC .............................................. .................................................. ................ 34

COND = MESMO ............................................... .................................................. ......................................... 34

COND = SÓ ............................................... .................................................. ......................................... 35

IF-THEN-ELSE Construir ............................................ .................................................. ........................... 35

Definindo Pontos de Verificação ................................................ .................................................. ............................. 38

Reiniciar Processamento ................................................ .................................................. ............................... 38

9. JCL - DEFINIÇÃO DATASETS .............................................. .................................................. . 40

Concatenação de conjuntos de dados ................................................ .................................................. ...................... 40

Conjuntos de dados primordiais ................................................ .................................................. ............................ 41

Definindo GDGs em um JCL ............................................. .................................................. ............................ 42

Criar / Alter GDG em um JCL ........................................... .................................................. ........................ 42

Excluir GDG em um JCL ............................................. .................................................. ................................ 44

Usando GDG em um JCL ............................................. .................................................. .................................. 44

10. JCL - Métodos de entrada / saída ............................................ ....................................... 45

Entrada de dados em um JCL ............................................. .................................................. .................................. 45

Saída de dados em um JCL ............................................. .................................................. ............................... 46

11. JCL - RUN COBOL programas usando JCL ........................................... ............................ 48

Compilar programas COBOL ............................................... .................................................. ................. 48

A execução de programas COBOL ............................................... .................................................. .................... 48

Passando dados para programas COBOL ............................................. .................................................. ........... 49

como programadores individuais usados pelo OS para receber os trabalhos.