finalidade do jcl

JCL

Direitos Autorais – ISP Consultoria www.escoladeprogramadores.com.br

1

Finalidade do JCL

Para que um programa seja executado no mainframe é necessário escrever um JOB

(serviço) utilizando a JCL – Job Control Language (Linguagem de Controle de Serviços). O

JOB é submetido à execução e encaminhado ao JES – Job Entry Subsystem (Subsistema de

Entrada de Serviços), que atribui um número ao JOB (Job Id) e faz uma análise sintática do

JCL. Se tudo estiver correto, o JES orienta o Sistema Operacional na execução do serviço.

Quando o serviço é encerrado, um código de retorno é informado (MAXCC – Maximum

Condition Code) e um conjunto de informações é organizado em arquivos e disponibilizado no

SPOOL (Simultaneous Peripheral Operations Online), com o resultado do processamento, para

posterior consulta. Abaixo temos os valores de MAXCC

16 terminating messages

12 severe messages

08 error messages

04 warning messages

00 informational messages / success

Elementos de JCL Abaixo temos um exemplo de JOB para executar um programa que lê e grava um

arquivo:

1 2 3 4 5 6 7 8

12345678901234567890123456789012345678901234567890123456789012345678901234567890

//ALUNOXXX JOB SEUNOME,MSGCLASS=X,CLASS=C,NOTIFY=&SYSUID,TIME=(0,20)

//*****************************************************************

//STEP1 EXEC PGM=PROGCLI

//STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR

//ESTOQUE DD DSN=GR.ALUNOXXX.ESTOQUE,DISP=SHR

//REPOSIC DD DSN=GR.ALUNOXXX.REPOSIC,DISP=(NEW,CATLG,DELETE),

// SPACE=(TRK,(1,1),RLSE),UNIT=SYSALLDA,

// DCB=(LRECL=20,RECFM=FB,DSORG=PS,BLKSIZE=0)

Uma régua foi colocada no início do JOB para melhor identificar as colunas. Uma linha na linguagem JCL começa com // nas duas primeiras colunas. Existem 3 tipos de linhas principais básicas, também chamados de cartões, pois o JCL

remonta à época em que se usavam cartões perfurados, conforme mostra a figura a seguir:

JOB especifica os parâmetros de execução do serviço

EXEC especifica o programa que será executado

DD especifica os arquivos que serão lidos ou gravados e seus parâmetros.

No exemplo acima, o JOB executa o programa PROGCLI que lê o arquivo ESTOQUE

e grava o arquivo REPOSIC.

JCL


2

operando.

Estrutura básica de um job

Um JOB tem a seguinte disposição dos cartões JOB, EXEC e DD: 1 2 3 4 5 6 7 8

12345678901234567890123456789012345678901234567890123456789012345678901234567890

//XXXXXXXX JOB XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

//XXXXXXXX EXEC XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

//XXXXXXXX DD XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX




//XXXXXXXX DD XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX






Em um JOB temos cartão JOB, de 1 a 255 cartões EXEC e de 1 a 1635 cartões DD

para cada cartão EXEC.

Posicionamento de um job

Podemos dividir uma linha da JCL em quatro partes:

Colunas Conteúdo Observação 01 e 02 // obrigatório, menos na entrada de dados 03 a 10 nome do cartão pode ser um JOBNAME, STEPNAME ou DDNAME 12 a 15 operador tipo do cartão, pode ser JOB, EXEC ou DD 16 a 72 operando parâmetros do cartão, separados por vírgula e sem

espaço. Um espaço em branco após um operando começa um comentário.

Regras para a codificação de um JOB:

a) É necessário um espaço em branco entre o nome do cartão, o operador e o

b) Toda linha JCL começa com // nas colunas 1 e 2, exceto quando vai se inserir dados via SYSIN ou INPUT STREAM.

c) Um comentário começa com //* nas colunas de 1 a 3.

d) Um JOB sempre começa por um cartão JOB. Isso significa que a primeira linha não pode ser comentário.

e) Um JOB é composto de pelo menos um programa. Este programa pode ser um utilitário do Sistema Operacional (SORT, IDCAMS, etc), um programa desenvolvido pelo programador ou um procedimento catalogado (PROC).

f) Cada cartão EXEC é chamado STEP e sempre executa um utilitário, programa, ou PROC.

g) Cada cartão EXEC possui cartões DD que indicam os arquivos necessários para o funcionamento do programa, utilitário ou PROC.

h) Não confundir JCL ERROR com ABEND. Um JCL ERROR é um erro de sintaxe ou indisponibilidade de recursos e o programa, utilitário ou PROC não é executado. Um ABEND é uma falha no programa que, em alguns casos, pode até mesmo ser causado por indisponibilidade de recursos do sistema, tais como disco (DASD) ou memória.

Não invente nomes para o JOBNAME, STEPNAME ou DDNAME. Use o padrão da empresa em que estiver trabalhando.

JCL


3

O cartão job

Formato 1 1 2 3 4 5 6 7 8

12345678901234567890123456789012345678901234567890123456789012345678901234567890

//ALUNOXXX JOB ’ACCOUNT’,MSGCLASS=X,CLASS=C,NOTIFY=&SYSUID,TIME=(0,20)

Formato 2 1 2 3 4 5 6 7 8

12345678901234567890123456789012345678901234567890123456789012345678901234567890

//ALUNOXXX JOB ’ACCOUNT’,

// MSGCLASS=X,

// CLASS=C,

// NOTIFY=&SYSUID,

// TIME=(0,20)

ALUNOXXX é o JOBNAME, nome do JOB. Os seis primeiros caracteres deve ser

seu UserID ou um nome padronizado, estabelecido pela área de

produção do CPD. O JOBNAME pode ter de 1 a 8 caracteres de

tamanho e deve começar por um caractere alfabético na coluna 3.

JOB Nome do cartão. Obrigatório. Deve ter um espaço em branco antes e

outro depois. Deve começar na coluna 12.

‘ACCOUNT’ Informações de contabilização. Este parâmetro é utilizado para indicar

de quem será cobrado o serviço, em outras palavras, o tempo gasto

pelo mainframe. Deve ser codificado entre apóstrofes. Cada empresa

utiliza um padrão.

CLASS Define a classe que será submetida na fila de JOBS. O sinal de igual

(=) não pode ter espaço em branco antes ou depois. Pode- se usar

letras de A até Z e dígitos de 0 a 9.

MSGCLASS Define a classe de SYSOUT (saída) onde serão gerados todos os

arquivos de log durante o tempo que o JOB permanecer no sistema.

Pode-se usar letras de A até Z e dígitos de 0 a 9.

NOTIFY Emite uma notificação com o MAXCC (Maximum Condition Code) do

JOB executado para o usuário indicado. Pode-se usar &SYSUID, para

utilizar o usuário logado no TSO.

TIME Tempo de CPU para executar o JOB. Não é o tempo corrido, mas sim o tempo que a CPU se dedica ao JOB, visto que ele compartilha seu tempo com todos os JOBs em execução no Sistema Operacional. Não inclui tempo de espera nas operações de I-O (OPEN, CLOSE, READ, WRITE, etc). O primeiro valor é minutos (de 0 a 1440) e o segundo é segundos (de 1 a 59). Codificando TIME=1440 ou TIME=NOLIMIT, dará ao JOB ou STEP uma quantidade de tempo ilimitada. Para permitir que o JOB ou STEP use a quantidade máxima de tempo, codifique TIME=MAXIMUM, que permite ao JOB ou STEP executar por 357912 minutos (aproximadamente 248 dias).

JCL


4

Outros parâmetros do JOB não obrigatórios, mas que podem aparecer nas empresas que usam mainframe são:

PRTY Define a prioridade do JOB na fila de execução. PRTY=n. Quanto

menor o número, maior a prioridade. n varia entre 0 e 15.

REGION Aloca espaço em memória. Equivale para todos os STEPs do JOB. O valor default (padrão) é 512Kbytes, outros valores devem ser múltiplos de 512Kbytes. Exemplos: REGION=1024K, REGION=2M. Se REGION é codificada com 0K ou 0M, todo espaço disponível é alocado ao job.

MSGLEVEL Especifica o nível de mensagens do sistema que se deseja imprimir. Sua Sintaxe é: MSGLEVEL=(A,B), onde A pode ser 0, 1 ou 2 e B pode ser 0 ou 1. O valor default é MSGLEVEL=(1,1). O parâmetro A corresponde a informações do JCL e o B corresponde a informações de alocações. Os possíveis valores são:

Sub-parâmetro “A”:

0 = imprime apenas o cartão JOB;

1 = imprime todos os cartões de JCL alimentados e os intercalados; 2 = imprime todos os cartões de JCL alimentados.

Sub-parâmetro “B”:

0 = NÃO imprime mensagens de alocação ou liberação de arquivo;

1 = imprime todas as mensagens de alocação e liberação de arquivo.

O valor default é:

(1,1) = exibe todos comandos de JCL codificados, expandidos e as alocações

TYPRUN Tipo de Execução. Pode ser:

TYPRUN=HOLD, retém o JOB na fila de entrada, aguardando um comando do operador

TYPRUN=SCAN, verifica o JCL para detectar erros de sintaxe e inibe a execução do JOB.

JCL


5

COND= sim

(0,NE,PASSO2)

não

PASSO03

PASSO2

O cartão exec

Formato 1

1 2 3 4 5 6 7 8

12345678901234567890123456789012345678901234567890123456789012345678901234567890

//PASSO03 EXEC PGM=ALUNOXXX,COND=(0,NE,PASSO02)

Formato 2

1 2 3 4 5 6 7 8

12345678901234567890123456789012345678901234567890123456789012345678901234567890

//PASSO03 EXEC PGM=ALUNOXXX,

// COND=(0,NE,PASSO02)

PASSO03 É o STEPNAME. Deve iniciar na coluna 3 e ter no máximo 8 caracteres.

Tradicionalmente se utiliza o nome STEPnn, mas pode ser qualquer

nome, desde que comece por um caractere alfabético.

EXEC Nome do cartão. Obrigatório. Deve ter um espaço em branco antes e

outro depois. Deve começar na coluna 12.

PGM Nome do programa ou utilitário a ser executado no step. No exemplo

acima, ALUNOXXX é um programa que deverá estar na biblioteca

padrão do sistema, no nosso caso a GR.GERAL.LOADLIB. Antes de

dar OPEN no programa, o sistema irá verificar se o programa

realmente existe. Em seguida irá verificar os recursos solicitados pelos

cartões DD para só então dar OPEN no programa e carregá-lo para a

memória.

PROC Usado no lugar de PGM, identifica a execução de uma procedure

catalogada no arquivo particionado GR.GERAL.PROCLIB.

COND Condiciona a execução do step atual em função do que ocorreu nos

steps anteriores; não faz sentido usá-lo no primeiro step do JOB. Seu

formato é:

COND=((CODIGO,OPERADOR,STEPNAME),EVEN/ONLY)

onde:

CODIGO qualquer valor numérico entre 0 e 4095

OPERADOR GT = GREATER THAN

GE = GREATER OR EQUAL THAN

LT = LESS THAN LE = LESS OR EQUAL THAN EQ = EQUAL

NE = NOT EQUAL

EVEN executa o passo MESMO QUE alguns dos passos anteriores tenham terminado de forma anormal (ABEND) ou emitido um return code diferente de 0.

ONLY executa o passo SOMENTE SE um dos passos

anteriores tenham terminado de forma anormal (ABEND) ou emitido um return code diferente de 0.

JCL


6

Todos os programas ao terminarem, emitem um código de retorno (return code) para o

sistema operacional. Se for 0 (zero) significa que terminou com sucesso. A lógica da codificação do COND é para “pular” o passo (STEP), ou seja, para que o

No exemplo COND=(4,GT,COMPILA), se o step COMPILA terminou com return code maior que 4, o STEP atual não será executado. Para que o STEP seja executado o resultado do COND tem de ser FALSO.

Alguns exemplos de COND=

(0,NE) Pular o step atual somente se os steps anteriores terminaram com return code igual a 0.

(4,LT) Pular o step atual somente se todos os steps anteriores terminaram com return code menores que 4

(4,GT,STEP1) Pular o step atual somente se o step1 terminou com return code maior que 4

(0,EQ,STEP5) Pular o step atual somente se step5 terminou com return code igual a 0

Outros parâmetros do EXEC não obrigatórios, mas que podem aparecer nas empresas que usam mainframe são:

REGION Aloca memória para os steps individualmente. Se esse parâmetro for codificado no cartão JOB, será ignorado no cartão EXEC. Exemplos: REGION=1024K, REGION=2M. Se REGION é codificada com 0K ou 0M, todo espaço disponível é alocado ao step.

TIME Define um limite de tempo de CPU para os steps individualmente. Equivale ao parâmetro TIME do cartão JOB. O parâmetro TIME no cartão JOB não anula o TIME do cartão EXEC. É um acréscimo a ele.

PARM Também conhecido como PARM GO, permite passar dados diretamente para a LINKAGE SECTION do COBOL. É usado em programas parametrizados, onde um parâmetro orienta o processamento. PARM=value. Value é uma string que pode ter de 1 a 100 caracteres de tamanho, delimitado por apóstrofes.

Exemplo:

1 2 3 4 5 6 7 8

12345678901234567890123456789012345678901234567890123456789012345678901234567890

//STEP10 EXEC PGM=PROGCLI,PARM=’20081026’

No COBOL, a LINKAGE SECTION deve conter as seguintes variáveis:

----+-*A-1-B--+----2----+----3----+----4----+----5----+----6----+----7--|-+ --- 8

*----------------------------------------------------------------*

LINKAGE SECTION.

*----------------------------------------------------------------*

01 CAMPO-PARAMETRO.

05 CAMPO-TAMANHO PIC S9(4) COMP.

05 CAMPO-DADO PIC X(08).

*----------------------------------------------------------------*

PROCEDURE DIVISION USING CAMPO-PARAMETRO.

*----------------------------------------------------------------*

A primeira variável contém o comprimento do parâmetro, devendo sempre ser PIC S9(04) COMP e a segunda o dado do parâmetro em si.

STEP não seja executado.

JCL


7

Joblib e steplib

Para se executar um programa, o sistema precisa carregar os programas executáveis

(Load Modules) de algum lugar. Em nosso caso, os módulos executáveis ficam na

GR.GERAL.LOADLIB, que é um arquivo particionado e o módulo objeto é um de seus

membros.Logo abaixo do cartão JOB codificamos uma JOBLIB, indicando a biblioteca (Library

ou Load) de onde devem ser carregados os programas executáveis. Ele é válido para todos os

steps. Exemplo:

1 2 3 4 5 6 7 8

12345678901234567890123456789012345678901234567890123456789012345678901234567890


//JOBLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR

O STEPLIB vale apenas para o passo (STEP) onde foi codificado. Se for codificado

uma JOBLIB, ela invalida o STEPLIB. Exemplo:

1 2 3 4 5 6 7 8

12345678901234567890123456789012345678901234567890123456789012345678901234567890


//PASSO01 EXEC PGM=PROGCLI

//STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR

JCL


8

O cartão DD Formato 1

1 2 3 4 5 6 7 8

12345678901234567890123456789012345678901234567890123456789012345678901234567890

//CLIENTES DD DSN=GR.ALUNOXXX.CLIENTES,DISP=SHR

//SAIDA DD DSN=GR.ALUNOXXX.SAIDA,DISP=(NEW,CATLG,DELETE),


// DCB=(DSORG=PS,RECFM=FB,LRECL=57,BLKSIZE=0)

//RELOCOR DD SYSOUT=*

Formato 2

1 2 3 4 5 6 7 8

12345678901234567890123456789012345678901234567890123456789012345678901234567890

//CLIENTES DD DSN=GR.ALUNOXXX.CLIENTES,

// DISP=SHR

//SAIDA DD DSN=GR.ALUNOXXX.SAIDA,

// DISP=(NEW,CATLG,DELETE),

// SPACE=(TRK,(5,2),RLSE),

// UNIT=SYSALLDA,


//RELOCOR DD SYSOUT=*

CLIENTES DDNAME. É o nome do arquivo colocado na frente do ASSIGN TO no programa COBOL.

Deve ter de 1 a 8 caracteres de tamanho e começar com um caractere alfabético.

DD Nome do cartão. Obrigatório. Deve ter um espaço em branco antes e outro depois. Deve começar

na coluna 12. DD significa DATA DEFINITION.

DSN DATA SET NAME, denomina o nome do arquivo catalogado. Deve ter de 1 a 44 caracteres de

tamanho, separados por um ponto a cada 8 caracteres no máximo. Os arquivos podem ser temporários

ou não temporários. Todos os arquivos não temporários devem ter nomes de acordo com os padrões da

instalação. Todos os arquivos temporários devem ter nomes de 1 a 8 caracteres de tamanho e

precedidos de &&, se omitido, o sistema atribui um nome aleatório, tornando-o temporário, ou seja,

criado e removido no mesmo JOB

Informa a situação (status) do arquivo no sistema operacional. Exemplos:

DISP=(NEW,CATLG,DELETE) DISP=(OLD,KEEP,KEEP) DISP=(NEW,PASS,DELETE) DISP=SHR

O primeiro sub-parâmetro é o status do arquivo:

SHR arquivo já existe e pode ser lido por outro programa.

OLD arquivo já existe e é de uso exclusivo do programa.

NEW arquivo é novo e será criado neste step.

MOD Se arquivo não existe, ele será criado. Se já existe, é de uso exclusivo e será acrescido

de mais registros.

JCL


9

O segundo sub-parâmetro indica a ação a ser tomada em caso de término normal do step:

CATLG Catalogar o arquivo. Obviamente que esta opção deve estar sempre acompanhada de NEW no primeiro sub-parâmetro. Porque se o arquivo estiver sendo lido (OLD) é porque já está catalogado.

UNCATLG Tira o arquivo do catalogo, mas não o apaga. Evite usar.

DELETE Apaga o arquivo.

KEEP Mantém o arquivo do que jeito que estava antes.

PASS indica que o arquivo é temporário e será passado aos steps subsequentes.

O terceiro sub-parâmetro indica a ação a ser tomada em caso de término anormal do step. Quando não informado, assume o valor do segundo sub-parâmetro:

CATLG Catalogar o arquivo. Obviamente que esta opção deve estar sempre acompanhada de NEW no primeiro sub-parâmetro. Porque se o arquivo estiver sendo lido (OLD) é porque já está catalogado.

UNCATLG Tira o arquivo do catalogo, mas não o apaga. Evite usar.

DELETE Apaga o arquivo.

KEEP Mantém o arquivo do jeito que estava antes.

Se o arquivo é de entrada (OLD ou SHR) não precisa especificar demais parâmetros, pois

naturalmente já está catalogado e o sistema saberá encontrá-lo. Se for de saída você deverá

usar os demais parâmetros do exemplo SAIDA.

Exemplos válidos:

DISP=(NEW,PASS,DELETE): o arquivo é criado neste step e passado aos demais somente se o programa der return code 0. Se o programa ABENDar, o arquivo será excluído.

DISP=(NEW,PASS): o arquivo é criado neste step e passado aos demais em qualquer condição de termino.

DISP=(OLD,PASS): o arquivo é lido neste step e passado aos demais em qualquer condição de termino.

DISP=SHR: o arquivo é lido neste step, podendo ser lido por outros programas de outros Jobs, pois o arquivo é de uso compartilhado (shared).

Exemplos inválidos:

DISP=(SHR,CATLG,DELETE): Como o arquivo não é novo (SHR) ele já está catalogado. Não é possível recatalogá-lo.

DISP=(NEW,KEEP,DELETE): Como o arquivo é novo (NEW) não é possível manter (KEEP) o arquivo como estava antes.

JCL


10

Default:

Se você colocar apenas DISP=SHR o sistema assume (SHR,KEEP,KEEP).

SPACE Especifica o espaço que o sistema deve alocar para o arquivo novo que está sendo gravado em

disco. Se não houver o espaço solicitado o JOB será cancelado. O formato geral é:

SPACE=(TRK,(PRIM,SEC,DIR),RLSE,CONTIG,ROUND)

TRK espaço alocado em trilhas (47.476 bytes no disco modelo 3380 ou 56.664 bytes no modelo 3390).

Também pode ser CYL, espaço alocado em cilindros (712.140 bytes no modelo 3380 ou 849.960 no

modelo 3390) ou um número que indica o tamanho de um bloco de registros. Observe que 1 CYL = 15

TRK.

PRIM = Quantidade primária de alocação.

SEC = Quantidade secundária de alocação, também conhecida como extends.

DIR = Quantidade em unidades de blocos de 256 bytes (pouco usado).

RLSE = Libera o espaço não utilizado.

CONTIG = Solicita que o espaço primário seja alocado apenas em trilhas e cilindros contíguos (pouco

usado).

ROUND = Arredonda para número inteiro de cilindros, e aloca em cilindros, quando o espaço solicitado é

em blocos (pouco usado).A alocação do espaço funciona da seguinte forma ((de 1 a 15 * SEC) + PRIM)

Vale notar que todo disco modelo 3390 contém 56.664 bytes por trilha, 15 trilhas por

cilindro e 849.960 bytes por cilindro. O termo trilha (track) e cilindro (cylinder) vem da época

dos discos pré-RAID (redundant array of inexpensive disks), que eram semelhantes a 8

discos de vinil empilhados e com um conjunto de cabeçotes de leitura/gravação que se moviam

sobre a superfície dos discos. Os discos tinham superfície de gravação em ambos os lados.

Das 16 superfícies, uma era usada para informações de controle, o que deixava 15 para os

dados. Uma trilha é a quantidade de dados que podia ser lida de uma superfície em uma volta

do disco, sem precisar mover as cabeças. Um cilindro podia ser lido de todas as 15 superfícies

sem mover as cabeças. Isso é muito importante, já que um cilindro pode ser lido rapidamente,

sem qualquer movimento mecânico. O diagrama abaixo ilustra isso. Os discos modernos usam

armazenamento FBA (Fixed Block Architecture), mas devem emular o formato dos discos

3390, de forma que os termos trilha (track) e cilindros (cylinder) são ainda usados.

JCL


11

VOL=SER= Especifica o número de série do volume (DASD) onde o arquivo (DATA SET) está ou será

localizado.

UNIT Especifica o tipo de dispositivo onde o arquivo será criado. Geralmente disco é SYSDA.

SYSALLDA significa que o sistema pode procurar em todos (ALL) os dispositivos para encontrar um com

espaço suficiente para o arquivo. Para arquivos em fita, usar TAPE.

DCB DATA CONTROL BLOCK. Indica o formato do arquivo a ser gravado. Não é necessário para

arquivos a serem lidos, pois o catálogo já guarda essas informações. A ordem dos sub- parâmetros não

importa. Seus sub-parâmetros são:

ECFM Acrônimo para RECORD FORMAT, é o formato do registro. F para registros de tamanho

fixo, V para registros de tamanho variável, B para registros blocados, A para registros cuja primeira

posição contém caractere ASA para impressora e U para registros de tamanho indefinido. As possíveis

combinações são: F, FB, V, VB, U, FBA e FA.

LRECL Acrônimo para LOGIC RECORD LENGTH, é o tamanho do registro em bytes. Quando você

especifica V para o parâmetro RECFM, o valor informado deve ser o tamanho do maior registro no

arquivo mais 4 bytes. Esses 4 bytes contém o tamanho real de cada registro de comprimento variável no

arquivo.

DSORG Acrônimo para DATA SET ORGANIZATION, é aorganização dos registros no arquivo. DA é

acesso direto (disco), PO é particionado (disco), PS é físico sequencial (fita ou cartucho) e IS é indexado

sequencial (disco).

BLKSIZE Acrônimo para BLOCK SIZE, é o tamanho de um bloco de registros. Quando omitido ou

colocando 0 o sistema calcula a blocagem ideal.

BUFNO Acrônimo para BUFFERS NUMBER é a quantidade de buffers. O default é BUFNO=5.

Exemplo:

DCB=(RECFM=FB,LRECL=100,BLKSIZE=6000,DSORG=PS)

SYSOUT Direcionar as saídas para a impressora. Exemplo: //ARQRELAT DD SYSOUT=* fila default (msgclass)

//RELOCORR DD SYSOUT=Z

* INPUT STREAM, serve para passar dados ao programa, através de um

arquivo, via JCL. Os caracteres /* funcionam como delimitadores.

Exemplos:

//ARQDATA DD *

20080901ANTONIO DA SILVA

20080912MARIA MOURA

20080925JOAO PEREIRA

/*

//SYSIN DD *

20080901ANTONIO DA SILVA

20080912MARIA MOURA

20080925JOAO PEREIRA

/*

JCL


12

DUMMY Ou DSN=NULLFILE, O arquivo recebe o estado de “nulo”. O arquivo não existe. O primeiro

read no arquivo gera file status 10 (EOF). Exemplo:

//ARQENT DD DUMMY

//ARQSAI DD DUMMY,SYSOUT=*,DCB=(LRECL=133)

SYSUDUMP É usado para despejar o conteúdo de vários registradores, variáveis e arquivos acessados

no exato momento de um termino anormal (ABEND), dentro de um arquivo ou do SPOOL. O despejo é

em hexadecimal. Exemplo:

1 2 3 4 5 6 7 8

12345678901234567890123456789012345678901234567890123456789012345678901234567890

//SYSUDUMP DD DSN=TEST.PROD.LIB

ou

//SYSUDUMP DD SYSOUT=*

SYSABEND É usado para despejar o conteúdo de vários registradores, variáveis e

arquivos acessados e o núcleo, no exato momento de um termino

anormal (ABEND), dentro de um arquivo ou do SPOOL. O despejo é

em hexadecimal. Exemplo:

1 2 3 4 5 6 7 8

12345678901234567890123456789012345678901234567890123456789012345678901234567890

//SYSABEND DD DSN=TEST.PROD.LIB

ou

//SYSABEND DD SYSOUT=*

JCL


13

Concatenando arquivos (DATA SETs)

No JCL, nós podemos concatenar diferentes arquivos, informando seus nomes

um após o outro. Todos os arquivos concatenados devem ser do mesmo tipo. Por

exemplo, arquivos particionados PDS (partitioned data set) podem ser concatenados

apenas com outros arquivos particionados. Exemplo:

1 2 3 4 5 6 7 8

12345678901234567890123456789012345678901234567890123456789012345678901234567890


//JOBLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR

//PASSO01 EXEC PGM=&SYSUID02

//CLIENTES DD DSN=GR.ALUNOXXX.CLIENTES1

// DSN=GR.ALUNOXXX.CLIENTES2

// DSN=GR.ALUNOXXX.CLIENTES3

No programa, nós vamos lê-los como um único arquivo. Os limites para concatenação

de arquivos pelo sistema operacional são:

Máximo de 255 arquivos sequenciais.

Máximo de 16 arquivos particionados.

Fluxo de ações de um job

PROGRAMADOR TSO JOB ENTRY

SUBSYSTEM

SISTEMA

OPERACIONAL

P.2 SUBB JOBID

SD ST ? S

MAXCC

JES agrupa as

saídas e

informações

sobre o JOB

Submete o

JCL

Digita o

JCL

Determina a

Tarefa

Usuário

consulta

a saída

S.O. executa o

serviço

JES

interpreta o

JCL e passa

p/ S.O.

JCL


14

Classificação externa de um arquivo

O SORT é o utilitário para classificar (ordenar) arquivos. Abaixo temos um exemplo de classificação de um cadastro de clientes, onde as 4 primeiras posições é o código do cliente, que será usado como critério de classificação em ordem crescente.

1 2 3 4 5 6 7 8

12345678901234567890123456789012345678901234567890123456789012345678901234567890

//STEPNN EXEC PGM=SORT

//SYSPRINT DD SYSOUT=*

//SORTIN DD DSN=GR.ALUNOXX.CADCLI,DISP=SHR

//SORTOUT DD DSN=GR. ALUNOXX.CADCLIS,DISP=(NEW,CATLG,DELETE),



//SYSIN DD *

SORT FIELDS=(01,04,CH,A)

//SYSOUT DD SYSOUT=*

SORTIN indica o arquivo que será classificado (entrada)

SORTOUT indica o arquivo que será o resultado da classificação (saída)

SORT FIELDS campos no registro de entrada que serão referencias para a classificação, os parâmetros auxiliares que compõem este parâmetro são (PI,PF,TD,TO), onde:

PI posição inicial do campo

PF posição final do campo

TD tipo do dado, podendo ser

BI binário

PK decimal compactado

ZD decimal zonado

CH caractere

TO tipo de ordenação, podendo ser

A ascendente (crescente)

D descendente (decrescente)

finalidade do jcl

Documents