Formação Programador Mainframe

Formação Programador Mainframe
Pré-requisitos
 É um pré-requisito do curso:
o Conhecimentos básicos de operação em ambiente Windows;
Informações Importantes
 Por favor, desligue o cellular ou deixe na opção vibracall. Em caso de urgência, atenda o
aparelho fora da sala de aula;
 Nao é permitido o uso de aparelhos de gravação de voz ou video;
 Durante as explanações teóricas e práticas, evite a navegação na internet para melhor
concentração do aluno e instrutor;
 Comunique o instrutor imediatamente se qualquer passo do conteúdo explanado for perdido ou
se demonstrou confuso no decorrer da aula;
 Não é permitido o consumo de alimentos ou bebidas no interior das salas de aula.
Escola de Programadores ZOS
Sistema Operacional e Mainframe

Mainframe – linha de computadores de grande porte destinado a processamento contínuo e
ininterrupto de grande volume de informações com alto grau de confiabilidade e segurança. Um mainframe
moderno pode processar uma quantidade superior a quatro bilhões de transações por segundo, suportar
milhares de terminais remotos e suas controladoras, controlar o acesso a centenas de discos, fitas, volume
de milhões de impressões etc.
Mainframe não é sistema operacional. O sistema operacional OS/390 foi desenvolvido pela IBM
para impulsionar o mainframe.
O sistema operacional OS/390 (ou z/OS) é totalmente modo caracter. O sistema operacional em
‘estado bruto’ da forma como é entregue pela IBM, ocupa cerca de 18 CD’s de instalação.
A instalação do sistema operacional até chegar ao ‘modus operandi’ pode levar longos dias de instalação
por um bom especialista em suporte operacional. Existe uma série longa de parâmetros que devem ser
selecionados, customizados de acordo com a padronização da empresa, perfil de funcionários, definição de
grupos de acesso, instalação de aplicativos, customização das redes internas e externas, escalation de
segurança, etc etc. Isso tudo permite dizer que o OS/390 é realmente um sistema operacional radicalmente
corporativo.
IBM 370 – DÉCADA DE 70, a segunda

IBM 360 – LANÇADO EM 1964 geração.
O primeiro mainframe
IBM 3090 – ANOS 80 IBM MULTIPRISE – 1990

Refrigerado a água. Modelo compacto usado muito em backup site
LINHA Z/SERIES – ANO 2000 a nova geração da IBM

LINHA 9000 – ANOS 90, o modelo mais utilizado
hoje no mercado.
Direitos Autorais – Escola de Programadores 2

Atualmente a IBM produz quatro versões de mainframes, denominados System Z series, que
modernizados, suportam diversos sistemas operacionais: z/OS, z/OS.e, z/VM, z/VSE, VSE/ESA, TPF, z/TPF e
Linux on System z.
Hoje, segundo especialistas, há uma forte e constante tendência de crescimento para este setor,
inclusive com as novas versões do Cobol (principal linguagem usada nos Mainframes) usando ambiente
gráfico.
QUADRO COMPARATIVO
COMPILADORES Cobol Natural Easytrev Pl/I

ARQUIVOS Vsam Sequencial Particionado
B. DE DADOS Adabas DB2
EDITORES Roscoe Tso
UTILITÁRIOS Idcams Icegener Iebcopy Sort
SEGURANÇA Racf Top-Secret
END-USER Cics IMS/DBDC

Sistema Operacional - z/OS
Cada sistema operacional é construído de acordo com os códigos, micro-códigos, canais, protocolos e
sistemas de arquivos de uma plataforma operacional. Portanto, o sistema z/OS foi desenvolvido para o
mainframe assim como o Windows foi desenvolvido para o PC.
Todos os servidores, são distribuídos em escala de acordo com suas capacidades, a qual chamamos de
porte. Desta forma, em relação ao porte do servidor e a plataforma, os sistemas operacionais também são
escalares.
Veja o quadro abaixo:
SISTEMA
PORTE PLATAFORMA FABRICANTE
OPERACIONAL
WINDOWS MICROSOFT
BAIXA PC´S LINUX (OPEN SOURCE)
MAC APPLE
HP-UX HP
MÉDIO UNIX RISC-AIX IBM
SOLARIS SUN
(MVS)
GRANDE MAINFRAME OS/390 IBM
(Z/OS)

Um sistema operacional possui as seguintes funções:
1. Gerenciamento de processos;
2. Gerenciamento de memória;
3. Sistema de arquivos;
4. Entrada e saída de dados.
COMPONENTES DO SISTEMA OPERACIONAL
VISÃO LÓGICA DO z/OS

ARQUITETURA

DEFINIÇÕES SOBRE SISTEMA
CONSIDERAÇÕES
Sistema é um conjunto de programas, softwares, aplicativos e utilitários que se relacionam dentro

de um mesmo assunto.
o
Ex.: Programas de folha de ponto, imposto de renda, seguros, férias, 13 . salário refere-se ao sistema
de ‘Folha de pagamento.
Programas de balanço, balancete, saldos, débitos e créditos, referem-se ao sistema de
‘Contabilidade’.
O Analista de Sistemas é o profissional responsável pela implantação de um sistema. Ele faz o
levantamento na área a ser informatizada, com base nos controles manuais existentes e das necessidades
do negócio. Ele deve estar atento ás legislações e deve procurar conhecer ao máximo o setor, e ter a
sensibilidade para que o sistema a ser implantado atenda ás necessidades do negócio. Não deverá ser
crítico nem se deixar levar pelo gosto pessoal.
Depois de ter todo o mapeamento necessário, faz uma prévia do virá a ser o ‘sistema’ a ser
implantado. Depois de exaustivas apresentações, reuniões e brain-stormings, o sistema começa então a ser
implantado. É aí que entra a figura do Programador. Ele deverá atender as necessidades levantadas pelo
Analista e então os programas desenvolvidos começarão a ser testados um a um.
Chega então à fase crucial que é a da montagem do sistema, como se fosse um quebra-cabeças. Os
programadores envolvidos quase nunca sabem ou conhecem todo o processo. Geralmente cumprem as
especificações determinadas pelo Analista de Sistemas.
COMO MONTAR UM SISTEMA
Imaginemos um sistema em fase de implantação. O Analista obviamente saberá a ordem em que os

programas deverão ser executados. Com base nestas sequências ele então montará o ‘fluxo do sistema’,
que será um dos documentos a serem enviados para a produção.
Fluxo exemplo:
Agora vamos colocar os utilitários que foram solicitados pelo analista de sistemas para que os
programas possam ter condições de processamento. Para cada sequência de programas e/ou utilitários,

vamos estabelecer um Job. Portanto um job é uma sucessão de programas ou utilitários que irão processar
numa sequência lógica.
Agora vamos monta a cadeia de jobs com base nos programas que estão dentro destes jobs. Portanto agora
temos uma sequência de Jobs e dentro destes jobs uma sequência de programas.
O
Com base no 1 . fluxo podemos fazer algumas constatações:
1) Se o PROG001 não processar ok, nenhum outro programa poderá processar.

2) Quando o PRG009 terminar ok, dois outros programas poderão processar.

3) O PROG022 depende do fim ok de dois outros programas.
Repare nas sequências:

1) PROGR001 + PROGR003 + PROG009
2) PROGR011 + PROGR021
Com base nestas informações, poderemos montar dois pacotes de programas que processarão numa
mesma sequência lógica. A este pacote denominamos JOB. Também poderemos montar outro JOB com
PROGR008 + PROG010 ou PROGR008 + PROGR012.
Agora vamos monta a cadeia de Jobs com base nos programas que estão dentro destes Jobs. Portanto
agora temos uma sequência de Jobs e dentro destes Jobs uma sequência de programas.
COMPONENTES DO SISTEMA OPERACIONAL
CATÁLOGO DO SISTEMA OPERACIONAL x VTOC
Imagine a cena: você chega a um hotel onde irá encontrar-se com alguém hospedado. Você não sabe onde
ele se encontra. Você se identifica á recepção do hotel que consulta um catálogo. Após encontrar o
hóspede que você procura, a recepcionista então te indica pegar um elevador e se dirigir ao 15o. andar, no
apartamento 1506. Você se encaminha e ao tocar a campainha você cumpriu seu roteiro.
Catálogo do hotel ---> catálogo do sistema operacional.

Elevador ---> canal
Numeração dos apartamentos ---> VTOC
Campainha ---> Header do arquivo.
O catálogo do sistema contém a informação de todos os arquivos existentes no sistema. Ele recebe a
solicitação vinda do cartão DD, procura o arquivo no catálogo, encontra o disco onde está o arquivo.
Chegando no disco, procura pela VTOC onde há um catálogo interno contendo todas as informações
daquele volume com o endereço físico do registro dentro do disco. O sistema então lê o registro em blocos
para a memória do computador.

CATÁLOGO DO SISTEMA OPERACIONAL x VTOC
O conceito de catálogo é o endereçamento dos conteúdos dos volumes para que possamos acessar um
arquivo, este endereçamento está dividido em níveis, o primeiro nível (catálogo) apontará em que volume
se encontra o arquivo que desejamos acessar, no segundo nível (VTOC) indicará qual será o endereço físico
do arquivo, como o próprio nome diz, é o índice dos arquivos. Existe o catálogo master que conterá a
definição dos catálogos de sistema, no catálogo de sistema são definidos os prefixos dos arquivos que serão
controlados por ele (Catálogo da produção, da homologação, do desenvolvimento). A cada encerramento
de um aplicativo que crie ou exclua um arquivo o catálogo é atualizado.
LEGENDA
Catálogo : Lista de endereço

Volume : Meio magnético de armazenagem de dados (Disco)
VTOC : Volume Table of Contains (Tabela de conteúdo de volumes)
O catálogo do sistema contém a informação de todos os arquivos existentes no sistema. Ele recebe a
solicitação vinda do cartão DD, procura o arquivo no catálogo, encontra o disco onde está o arquivo.
Chegando ao disco, procura pela VTOC onde há um catálogo interno contendo todas as informações
daquele volume com o endereço físico do registro dentro do disco. O sistema então lê o registro em blocos
para a memória do computador.

ARQUIVOS DO SISTEMA OPERACIONAL
Um arquivo de informações (ou dados) é um conjunto formado por dados (ou informações) de um
mesmo tipo ou para uma mesma aplicação. Por exemplo, podemos ter um arquivo de alunos de
uma turma (contendo informações sobre cada aluno individualmente), ou um arquivo contendo as
instruções de um programa. Cada arquivo é constituído por itens individuais de informação (cada
aluno, no nosso exemplo) chamados registros.
CONCEITOS:
ARQUIVO: Conjunto de registros aglomerados sequencialmente em um meio físico.

REGISTRO: Conjunto de campos que formam uma informação.
CAMPO: Menor parte de uma informação.
Todo arquivo reside em um meio físico, que pode ser em disco, fita ou cartucho.
Disco: Unidade de armazenamento, composta de cilindros. Um disco é um conjunto de cilindros,

suportados por um eixo.
Também chamado de DASD (Direct Access Sequential Device), é um periférico onde são
armazenados os dados dos arquivos. O acesso, para leitura ou gravação, dos dados dos arquivos
pode ser executado de maneira seqüencial, direta ou indexada.
Cilindro: A idéia do cilindro é que se os dados de um arquivo estão gravados em trilhas

concêntricas, a cabeça de leitura/gravação, não precisa se mover para ler os dados do arquivo.

Trilha: Nos discos os dados são gravados em circunferências concêntricas. Em cada uma das
circunferências concêntricas, onde estão gravados os dados, chamamos de trilha.
Tipos de Arquivos:
O sistema operacional z/OS, possui 3 tipos de arquivos distintos:
Arquivo Sequencial: É o tipo de arquivo utilizado, para armazenar informações em uma

seqüência lógica, ou seja, os registros são gravados ou lidos de forma seqüencial, um
após o outro.
Arquivo Particionado: É o tipo de arquivo utilizado para armazenar membros que contém
informações, que serão utilizadas em um processamento, tais como:
Programas
Jobs
Parâmetros
Arquivo Indexado: É o tipo de arquivo utilizado, para armazenar informações através de

um índice. Os arquivos indexados são também conhecidos como arquivos VSAM (Virtual
Storage Access Method).

Formato e blocagem dos registros
Os arquivos no ambiente z/OS normalmente, podem possuir um dos quatro tipos de registros
descritos a seguir:
F – Fixo Desblocado - Significa que todos os blocos físicos do arquivo possuem apenas
um registro lógico de tamanho fixo por bloco em disco.
FB – Fixo Blocado - Significa que todos os blocos físicos do arquivo possuem mais de
um registro lógico de tamanho fixo por bloco em disco.
V – Variável Desblocado- Significa que todos os blocos físicos do arquivo possuem

apenas um registro lógico de tamanho variável por bloco em disco.
VB – Variável Blocado - Significa que todos os blocos físicos do arquivo possuem mais
de um registro lógico de tamanho variável por bloco em disco.
U – Indefinido - Significa que o tamanho dos registros são variáveis e os blocos físicos e
lógicos do arquivo não possuem estrutura pré-definida.
Registros Lógicos e Físicos
Os arquivos no sistema z/OS podem tanto ter registros lógicos como físicos.
Um registro lógico é a unidade que o programa deseja processar. Normalmente, consiste de um
número de campos concatenados.
Um registro físico descreve o montante de dados transferidos nas operações de E/S.
A combinação de múltiplos registros lógicos num único registro físico (chamamos de blocagem)
possui certas vantagens através do armazenamento e recuperação de um registro lógico bem
como um registro físico. Estas incluem maior eficiência no uso do espaço em disco, bem como,
melhor desempenho na transferência dos dados.

Nomenclatura para nomes de arquivos
O DSName pode conter até 44 caracteres, sendo permitido a utilização de letras (A-Z; a-z),
números (0-9), e caracteres nacionais americanos @, #, $.
O primeiro qualificador identificado como High Level Qualifier (HLQ), pode identificar o ALIAS
associado a um catalogo.
O DSName para designar um arquivo particionado segue as mesmas regras quanto a

identificação do arquivo.
Porém, para referenciar um membro no PDS deve-se colocar entre parênteses.

ESCOLA
DE PROGRAMADORES
FORMAÇÃO MAINFRAME
MÓDULO : TSO
WWW.ESCOLADEPROGRAMADORES.COM.BR
TSO
Aula 1
TSO - Time Sharing Option / Extensions (TSO/E)
 Permite que os usuários criem uma sessão interativa com o sistema operacional z /OS.
 No sistema operacional z /OS, cada usuário recebe uma identificação de userid e uma
password (senha) previamente cadastrada e configurada para logon no TSO.
 Para interagir com o TSO é necessário um dispositivo de exibição de um terminal 3270 ou

um emulador TN3270 rodando em um PC.
 A tela de logon tem a mesma finalidade como um painel de logon do Windows, ou seja,
permitir que o usuário cadastrado no sistema possa acessar os aplicativos.
 A maioria dos usuários trabalham com TSO através de sua interface baseada em menus,
chamada ISPF (Interactive System Productivity Facility).
 Esta coleção de menus e painéis oferece uma ampla gama de funções para ajudar os
usuários a trabalharem com arquivos de dados, programas, serviços, catálogos, aplicativos
de segurança e gerenciamento.
 TSO e ISPF permite que pessoas com variados níveis de experiência e conhecimento
possam interagir com o Sistema Operacional z/OS.
Porém vale a pena lembrar que cada perfil de usuário, possui permissão, apenas para os
aplicativos que farão parte da sua rotina de trabalho dentro das empresas.
Direitos Autorais – ISP Consultoria e Treinamentos em Tecnologia Ltda 1

TSO
PRINCÍPIOS FUNDAMENTAIS
O TSO é um componente do sistema operacional, composto por vários aplicativos, dentre eles o
editor de textos PDF. O TSO tem como função primordial promover a interação do usuário com o
ambiente. Através do TSO você pode criar arquivos, deletar, visualizar, submeter job, alocar
arquivos, renomear, mover, copiar, e também utilizar outros aplicativos do sistema operacional que
rodam sob o TSO como por exemplo RACF, HCD, SDSF, Control/M, Endevor etc. O TSO controla
todos estes aplicativos.
Os nossos objetos de estudos serão os aplicativos PDF e SDSF para criarmos jobs, programas,
manusear arquivos, submeter jobs etc.
PF – Teclas de funções pré-programadas:

TSO
Tela inicial do Sistema Operacional

TSO
LOGANDO NO TSO
Se logar no TSO/E significa começar uma sessão de TSO. Para se logar é preciso de uma userid e
senha de acesso.
 A instalação pode ter vários processos de LOGON.

 Podemos digitar nesta tela as seguintes opções:
L usuário
L Tso
Tso
 Após digitar uma das opções, apertar a tecla Enter

TSO
NESTA TELA
VOCÊ DEVERÁ
DIGITAR O SEU
USUÁRIO !!!!
 Após digitar seu usuário, apertar a tecla Enter
NESTA TELA
VOCÊ DEVERÁ DIGITAR A SUA
PASSWORD, FORNECIDA PELO
INSTRUTOR !!
 Após digitar sua password, apertar a tecla Enter

TSO
 Você deverá digitar uma senha válida de 6 digitos:

o Pode ser somente número
o Pode ser número e letras
o Pode ser somente letras
 Após digitar sua password, apertar a tecla Enter
 Após digitar a senha nova, o TSO solicitará que você digite novamente a mesma senha,
para que seja feita a confirmação de alteração de senha.
 Após digitar novamente sua password, apertar a tecla Enter

TSO
 Esta tela mostra que seu logon foi efetuado com sucesso
 Caso não tenha sido exibida esta tela, refaça os passos anteriores.
 Após esta etapa, apertar a tecla Enter

TSO
Uso de painéis e alguns serviços:

ISPF/PDF - Interactive System Productivity Facility(ISPF) Program Development Facility
Esta é a tela principal do TSO. O único destes aplicativos que é nativo no TSO é o PDF. Os demais
são adicionados ao sistema operacional. Após sua instalação, eles „rodam‟ debaixo do TSO. Nosso
objeto de estudo serão os aplicativos PDF e o SDSF.

TSO
OPÇÃO ‘2’ DO PDF
A opção 2 não é muito diferente da opção 1. Nesta opção você já entra direto na opção EDIT que
permite você alterar um arquivo.

TSO
OPÇÃO 3 DO PDF
Este menu é o mais utilizado. Auto-explicativo, exibe display das funções. As opções mais utilizadas
deste menu, são as opções de 1 a 4.
Além destas, as opções 12 e 13 para comparar data-sets e 14 e 15 que pesquisa string dentro de
particionados.
Vamos agora estudar os sub-menus da opção 3 (Utilities)

TSO
Opção 3.1 do PDF
1 Library Compress or print data set. Print index listing. Print, rename, delete, browse, edit or
view members
Você deverá preencher a opção, que define o que você deseja executar sobre o arquivo em
questão. O nome do arquivo a ser trabalhado, deve ser preenchido na área ISPF Library ou na
área Other Partitioned or Sequential Data Set (neste caso o nome deverá estar entre aspas
simples). Neste exemplo, escolhemos a opção „I‟, ou seja, vamos visualizar as informações do
ARQUIVO GR.IBMUSER.JCLDATA.

TSO
Retornando á opção 3 (F3 1x)
Opção 3.2 DO PDF

2 Data Set Allocate, rename, delete, catalog, uncatalog, or display information of an entire data
set
A opção „A‟ para alocar um novo data-set. Escolhemos o nome GR.IBMUSER.ARQUIVO.

TSO
Vamos preencher com os dados solicitados pelo sistema. Trilhas, tamanho lógico, formato, etc.
Após o ENTER, será visualizada a mensagem de confirmação da alocação.

TSO
Opção 3.4 do PDF
4 Dslist Print or display (to process) list of data set names. Print or display VTOC information.
Vamos listar todos os arquivos do catálogo que começam com GR.IBMUSER.

TSO
Podemos trabalhar com os data-set listados acima. Podemos editar (E), visualizar (B), deletar (D),
renomear (R), copiar (C), mover (M), etc. Uma outra opção, nesta tela é utilizar o comando barra
(como no exemplo), que vai abrir várias opções, inclusive as citadas acima.
Veja o resultado:
Um pop-up foi aberto e várias opções sobre o que fazer com o arquivo selecionado. Basta
selecionar o número da opção. Funcionar como os comandos citados.
A partir deste comando quase todas as funções mostradas até o momento poderão ser feitas a
partir desta opção.
As opções de 5 a 11 estão desabilitadas e por isso não serão objetos de estudo. Elas são de uso da
área de suporte operacional.

TSO
Exercícios de Fixação
1. Cite 3 componentes do Sistema Operacional ?
2. Quais as funções do Sistema Operacional ?
3. Cite 3 características do TSO ?
4. Quais os tipos de arquivos existentes no Sistema Operacional ?

TSO
PRINCIPAIS COMANDOS DE TSO

Comandos de TSO são entradas na linha de comando, sempre usados no manuseio de
arquivos editados. Lembre-se que qualquer arquivo para ser alterado ou incluir
informações ele precisa ser editado. Portanto um arquivo editado é um arquivo „alterável‟.
F MARIA - procura pela palavra Maria dentro do arquivo. Para continuar procurando a
mesma ocorrência no restante do arquivo, continue teclando „F5”,
C SECTION SECAO ALL  altera todas as ocorrências „section‟ para „secao‟ (em todo
arquivo).
SAVE  salva o arquivo em uso (com o mesmo nome evidentemente).
CANCEL  cancela todas as alterações realizadas desde o último save. O arquivo

mantém as mesmas características anteriores.
RECOVERY ON  Uma única vez, habilita a opção UNDO (desfazer) uma função.
L PGM01  Este comando só poderá ser executado quando dentro de uma biblioteca.
Utilizado para localizar um membro dentro de uma biblioteca.
HEX  Exibe o arquivo em hexa
HEX OFF  Retorna a decimal.
RES  Limpa mensagens do sistema.
M+F8  Posiciona cursor na ultima linha
M+F7  Posiciona cursor na primeira linha
L 26  Posiciona cursor na linha 26
EXC SECTION ALL  Exclui todas as linhas com a ocorrência „section‟ – (sem all,
somente a primeira)

TSO
COMANDOS DE LINHAS
COLS  Cria régua na linha superior
C  copia linha
CC + CC  Copia bloco de linhas
A  Localizador para os comandos Copy e Move. A=after
M  Move 1 linha
MM + MM  Move bloco de linhas
R  Repete linha
RR + RR  Repete bloco de linhas.
| - Insere linhas
N+ - Desloca o texto N colunas para direita
N - Desloca o texto N colunas para a esquerda
Se um Member for aberto no modo VIEW, as alterações efetuadas não poderão ser gravadas. Para
descartar as alterações em COMMAND digite CANCEL e <enter>.
Para gravar as alterações digite CC na primeira linha e CC na ultima linha e em COMMAND digite
REPLACE “nome do member” e <enter>.
Para criar uma cópia de um Member sendo editado (EDIT) ou visualizado (VIEW) , digite CC na
primeira e última linha e em COMMAND digite CREATE “nome do novo membro” e <enter>.

TSO
O SDSF
Esta é a tela principal do System Display Search Facility, ou simplesmente SDSF. É um aplicativo
que, a exemplo do PDF, roda debaixo do TSO. A principal função deste aplicativo é permitir o
acompanhamento e monitoração de jobs dentro do sistema operacional.
Nesta tela acima podemos perceber que as opções mostram as diversas áreas do sistema
operacional por onde trafegam os jobs batch. Nem todas as opções estarão habilitadas para você
na sua empresa. E mesmo dentre as opções liberadas existem funções como por exemplo, cancelar
jobs, deletar sysout, monitorar job de outro usuário que você certamente não terá permissão, pois o
SDSF é controlado pelo RACF.
LOG  Exibe a log da console máster do sistema operacional.
DA  Exibe jobs em execução (certamente os que você tem permissão de visualizar)
I  Jobs presos na Input queue.
O  Jobs na output queue (não liberados para visualização)
H  Jobs em hold
ST  Jobs na saída, liberados para visualização (sysouts de execução)
PR  Impressoras do sistema operacional
INIT  Status dos initiators

Demais funções utilizadas pelo suporte técnico.

TSO
Opção ST
Visualizar jobs
NOTA: O usuário IBMUSER só consegue visualizar os jobs iniciados com „IBMUSER‟. A opção „S‟
(de select) abre a visualização da sysout do jobs como veremos a seguir.
Resultado:

TSO

TSO
NAVEGANDO ENTRE TELAS

Usando F2 e F9
Imagine a situação: Você entrou no sistema pela opção P.3.4, abriu um job e o submeteu. Para
visualizar a sysout de execução, você deveria teclar F3 4 vezes, voltar ao menu principal, entrar no
SDSF, e entrar na opção ST. Você vê o job, mas precisa submeter. Você sai da função ST, retorna
ao PDF e vai navegando até retornar ao job. Acerta o job, submete e tem que voltar ao SDSF.
Para minimizar este esforço você pode dividir a tela com F2 e trabalhar como se fossem 2 usuários
simultâneos. Você navega entre ambos utilizando a tecla F9.
Repare que a tela está dividida. A linha pontilhada indica a divisão em 2 sessões simultâneas.

TSO
SAINDO DO TSO
Você deve pressionar F3 até aparecer a tela abaixo.
Digite 2 em Process option e pressione <Enter>.
Escreva o comando LOGOFF e pressione <Enter>.

TSO
LOGOFF
• O comando LOGOFF (que você deverá digitar logo abaixo de READY) encerra a sessão de TSO.
Como confirmação da ação e‟ enviada a seguinte mensagem ao terminal:
NOTA : Nunca saia do TSO sem LOGOFF – o USUÁRIO fica retido e você não
conseguirá efetuar o logon novamente. Se isto acontecer, solicite ao instrutor,
para fazer o cancelamento de sua sessão.

TSO
COMANDOS RÁPIDOS PARA NAVEGAÇÃO
 Ir do menu principal para o menu do SDSF
o Digite na linha de comando do TSO - =M.5 ou TSO @SDSF
 Ir para outra sessão do TSO
o Digite na linha de comando do TSO – START
 Dar nome a uma sessão no TSO
o Digite na linha de comando do TSO - SCRNAME (NOME DA SESSÃO)
 Verificar a lista de sessões abertas
Digite na linha de comando do TSO – SWAP LIST
 Retirar as PFS da barra inferior do TSO
o Digite na linha de comando do TSO – PFSHOW OFF
 Colocar as PFS da barra inferior do TSO
o Digite na linha de comando do TSO – PFSHOW ON
 Navegar entre painéis do TSO
o Escolha a opção desejada e digite o comando na linha do TSO

o Exemplo:
=2 – vai para o PDF
=x – Sair do TSO
=3.4 – Ir para tela do DSLIST
=M.5;st – Ir para a tela do SDSF na opção ST
 Abrir outro membro em cima de um membro já aberto
o Edit (nome do membro)

TSO
Exercícios de Fixação
1. Crie um membro em sua biblioteca de trabalho e anote o resultado ?
2. Consulte na opção SDSF, o seu usuário logado e veja o que acontece se você colocar
“P” no lado esquerdo do seu usuário ?
3. Execute todos os passos de navegação, oferecidos no item COMANDOS RÁPIDOS

PARA NAVEGAÇÃO ?

ESCOLA
DE PROGRAMADORES
MÓDULO : JCL
JCL
SUMÁRIO
JOB CONTROL LANGUAGE................................................................................................................................. 2
1.1 DEFINIÇÃO ..................................................................................................................................................... 2
1.2 DESENHO DE UM JOB ..................................................................................................................................... 2
1.3 ESTRUTURA DE UM JOB ................................................................................................................................. 3
1.4 REGRAS PARA CONFECÇÃO DE UM JOB ......................................................................................................... 4
1.5 PARÂMETROS ESPECIAIS ................................................................................................................................ 4
1.5.1 JOBCARD – PARÂMETROS MAIS COMUNS ............................................................................................. 4
1.5.2 JOBCARD – PARÂMETROS MENOS USUAIS ............................................................................................ 7
1.5.2 EXEC ..................................................................................................................................................... 10
1.5.3 DD (DATA DEFINITION) ........................................................................................................................ 12
1.5 JOBLIB .......................................................................................................................................................... 18
1.6 STEPLIB ......................................................................................................................................................... 18
1.7 DDNAME X DSN(DSNAME) ........................................................................................................................... 19
1.7.1 DDNAME .............................................................................................................................................. 19
1.7.2 DSN (DSNAME) ..................................................................................................................................... 19
1.8 PARM ........................................................................................................................................................... 20
1.10 JCL ERROR X ABEND X FLUSH....................................................................................................................... 20
1.10.1 JCL ERROR .......................................................................................................................................... 20
1.10.2 ABEND ................................................................................................................................................ 20
1.10.3 FLUSH ................................................................................................................................................. 20
CAPÍTULO 3 – ABENDS SISTEMA OPERACIONAL .............................................................................................. 21
Direitos Autorais – GPTI Treinamento 1

JCL
JOB CONTROL LANGUAGE
1.1 DEFINIÇÃO
É a linguagem utilizada pelos mainframes para execução dos JOBs (Tarefas). Os JOBs solicitam
recursos (programas, arquivos, etc) ao Sistema Operacional para execução de programas.
Os JOBs são responsáveis por atualização de contas correntes, geração de contratos, emissão de
boletos e duplicatas, baixa de pagamentos e muitas outras tarefas em bancos, seguradoras e
financeiras.
JOB / JOBNAME
É a composição de uma série de programas (Cobol ou Utilitários) que devem ser processados numa
determinada sequência. Um job representa um conjunto de STEPs.
STEP / STEPNAME
É a execução de um programa Cobol ou um programa Utilitário.
1.2 DESENHO DE UM JOB
JOBXX01D
STEP001 SORT
STEP002 COBXX01
STEP003 IDCAMS
STEP004 COBXX02

JCL
O JOB JOBXX01D é formado por 4 STEPs. São eles : STEP001, STEP002, STEP003 e STEP004.
O STEP001 executa o programa Utilitário SORT.
O STEP002 executa o programa Cobol COBXX01.
O STEP003 executa o programa Utilitário IDCAMS.
O STEP004 executa o programa Cobol COBXX02.
1.3 ESTRUTURA DE UM JOB
----+----1----+----2----+----3----+----4----+----5----+----6----+----7--
//JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20)
//********************************************************************
//* STEP001 - UTILITARIO SORT - ORDENA ARQUIVO POR DATA DE PAGAMENTO *
//********************************************************************
//STEP001 EXEC PGM=SORT
//SYSOUT DD SYSOUT=*
//SORTIN DD DSN=GR.GPYYXX.ARQPGTO,DISP=SHR
//SORTOUT DD DSN=GR.GPYYXX.ARQPGTO,DISP=SHR
//SYSIN DD *
SORT FIELDS=(01,08,CH,A)
//********************************************************************
//* STEP002 - PROGRAMA COBXX01 - GERACAO RELATORIO PAGAMENTOS *
//********************************************************************
//STEP002 EXEC PGM=COBXX01
//STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR
//ARQPGTO DD DSN=GR.GPYYXX.ARQPGTO,DISP=SHR
//RELATO DD SYSOUT=*
//********************************************************************
//* STEP003 - UTILITARIO IDCAMS - DELECAO ARQUIVO ARQSERA *
//********************************************************************
//STEP003 EXEC PGM=IDCAMS
//SYSPRINT DD SYSOUT=*
//SYSIN DD *
DELETE GR.ARQUIVO.ARQSERA
//********************************************************************
//* STEP004 - PROGRAMA COBXX02 - GERACAO ARQUIVO ARQSERA *
//********************************************************************
//ARQSERA DD DSN=GR.GPYYXX.ARQSERA,
// DISP=(NEW,CATLG,DELETE),
// UNIT=3390,
// SPACE=(TRK,(5,1),RLSE),
// DCB=(RECFM=FB,LRECL=800,BLKSIZE=0)

JCL
Visualizando o JOB anterior parece complexo o entendimento da linguagem JCL. Contudo, nos
próximos tópicos estaremos abordando todas as instruções utilizadas durante a confecção de um
JOB.
1.4 REGRAS PARA CONFECÇÃO DE UM JOB
 Todo JOB deve possuir pelo menos 1 STEP

 Todo JOB deve iniciar com a instrução // (barra barra) a partir da coluna 01
 Todo JOB deve possuir a palavra reservada JOB. A palavra reservada JOB solicita ao
Sistema Operacional a execução de JOBs
 O nome do JOB deve possuir 8 carácteres. Deve ser informado na primeira linha do JCL
 Comentário é representado pela instrução //* (barra barra asterisco) a partir da coluna 01 até a
coluna 03
 JOBNAME, STEPNAME e DDNAME devem ser codificados da coluna 03 até a coluna 10
 JOB, EXEC e DD devem iniciar antes da coluna 16
 Continuação de JOBCARD deve ser feito entre as colunas 4 e 16
1.5 PARÂMETROS ESPECIAIS

O JCL precisa de alguns parâmetros especiais para efetivar a execução dos JOBs. São eles :
 JOBCARD
 EXEC
 DD (Data Definition)
1.5.1 JOBCARD – PARÂMETROS MAIS COMUNS

É a primeira linha do JCL. Efetiva a identificação do JOB para o Sistema Operacional. Todo JOB inicia
com a instrução // (barra barra) a partir da coluna 01.
Exemplo :
JOBNAME
É o nome do JOB (JOBNAME). Em caso de falha no JOB a primeira a coisa a ser verificada é o
JOBNAME. Formado por 8 carácteres.

JCL
Exemplo :
JOB
Todo JOB deve possuir a palavra reservada JOB. A palavra reservada JOB solicita ao Sistema
Operacional a execução de JOBs.
Exemplo :
ACCOUNT INFORMATION
São as informações para geração de estatísticas. Essas informações são chamadas de ACCOUNT
INFORMATION. Normalmente, informa-se o nome da companhia, do departamento, do programador,
analista, etc.
Exemplo :
CLASS
Define a classe de entrada dos JOBs. Existem 36 classes disponíveis. As classes disponíveis vão de
A-Z (26 classes) e de 0 a 9 (10 classes).
Exemplo :

JCL
MSGCLASS
Define a classe de saída dos JOBs. Existem 36 classes disponíveis. As classes disponíveis vão de
A-Z (26 classes) e de 0 a 9 (10 classes).
Exemplo :
NOTIFY
Define o usuário que receberá as notificações dos JOBs executados. Se informado
NOTIFY=&SYSUID as notificações irão para o usuário que estiver logado no TSO.
Exemplo :
//JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=&SYSUID,TIME=(0,20)
TIME
É o CPU TIME (Tempo de Processamento de Máquina). É o tempo necessário para que o JOB
termine a sua execução.
Exemplo :
Onde :
0 = (Quantidade em Minutos)
20 = (Quantidade em Segundos)
Exemplo :
//JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(,20)

JCL
Onde :
20 = (Quantidade em Segundos)
Exemplo :
//JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=5
Onde :
5 = (Quantidade em Minutos)
DICA 1 - IMPORTANTE !
O maior valor permitido para execução de um JOB é 1440 minutos.
CPU TIME não é a quantidade de segundos corridos. O cálculo do CPU TIME depende de fatores
como : quantidade de base de dados a serem acessados, quantidade de instruções, quantidade de
jobs executando concorrentemente, entre outros fatores.
O sistema operacional retorna o abend S322 quando existe estouro de CPU TIME. A causa mais
normal do abend S322 são programas em looping ou programas que fazem acessos a muitas bases
de dados.
1.5.2 JOBCARD – PARÂMETROS MENOS USUAIS
MSGLEVEL
Define o nível das mensagens a serem geradas pelo JOB.
Sintaxe :
MSGLEVEL=(X,Y)
X = refere-se as sentenças JCL

 0 = Gerará apenas os relatórios do JOB
 1 = Todo JOB será impresso, incluindo as Procedures
 2 = Imprimirá somente os inputs do JOB

JCL
Y = refere-se as mensagens
 0 = As mensagens de alocação não serão impressas a não ser que o JOB termine com falha
 1 = As mensagens de alocação sempre serão impressas
Exemplo :
//JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,MSGLEVEL=(1,1),NOTIFY=GPYYXX
TYPRUN
Quando informado esse parâmetro o JOB não é executado.
HOLD = prende a execução do JOB

SCAN = verifica se o JOB possui erros de sintaxe
Exemplo :
//JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TYPRUN=HOLD
//JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TYPRUN=SCAN

JCL
PRTY
Define a prioridade de execução do JOB. Os valores de prioridade variam entre 0 e 15. Sendo 15 a
maior prioridade e 0 a menor prioridade.
Exemplo :
//JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,PRTY=15
REGION
Indica a quantidade de memória a ser utilizada para execução do JOB. Pode ser informada
Megabytes ou Kilobytes.
Exemplo :
//JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,REGION=4M
//JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,REGION=512K
Se informado REGION=0M ou REGION=0K, utiliza-se a maior memória disponível para execução do

JOB.

JCL
RESTART
Indica a partir de qual STEP será feita a execução do JOB. Os steps anteriores não serão executados.
Utilizado por analista de produção para reiniciar a execução do JOB em caso de falha.
Exemplo :
//JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,RESTART=STEP003
1.5.2 EXEC
Informa qual o programa, utilitário ou procedure será executado pelo STEP do JOB.
STEPNAME
É o nome do STEP (STEPNAME). Em caso de falha no JOB, a segunda a coisa a ser verificada é o
STEPNAME. Formado por até 8 carácteres.
Exemplo ( STEPNAME ) :

//********************************************************************
//********************************************************************
//SYSIN DD *
Execução de Utilitário :

//********************************************************************
//********************************************************************
//SYSIN DD *

JCL
Execução de Programa :

//********************************************************************
//********************************************************************
Execução de Procedure :

//********************************************************************
//* EXECPROC – EXECUCAO DE PROCEDURE *
//********************************************************************
// JCLLIB ORDER=GR.GERAL.JOBLIB
//EXECPROC EXEC JOBPROCS
JCLLIB
É a biblioteca que possui as PROCEDURES que serão executadas.
ORDER
Referencia o nome da biblioteca.
Procedure que será executada :
//JOBPROCS PROC
//*****************************************************************
//* STEP001 - EXECUTA PROGRAMA COBXX01 *
//*****************************************************************
//*****************************************************************
//* STEP002 – EXECUTA PROGRAMA COBXX02 *
//*****************************************************************

JCL
1.5.3 DD (DATA DEFINITION)

Define qual dispositivo será solicitado ao Sistema Operacional.
Pode ser :
 DSN ( DataSet Name )

 * (Asterisco) ( Dados de Entrada )
 DUMMY ( Simulação de Dados de Entrada )
 SYSOUT ( Saída para Impressão )
 DISP ( Disposição do Arquivo)
 SPACE ( Espaço para Alocação )
 UNIT ( Unidade )
 VOLUME ( Volume )
 DCB ( Data Control Block )
DSN (DATA SET NAME)

Referencia o arquivo físico.
Exemplo :

//********************************************************************
//********************************************************************
* (ASTERICO)
Referencia dados de entrada para o programa que está sendo executado.
Exemplo :

//********************************************************************
//********************************************************************
//SYSIN DD *

JCL
DICA – IMPORTANTE !
SORT FIELDS=(01,08,CH,A) é passado como parâmetro para o programa que está sendo
executado. No nosso exemplo, o utilitário SORT.
DUMMY
Faz simulação de dados para o programa que está sendo executado. A instrução DUMMY permite
que o programa execute mesmo que o DataSet não exista.
Exemplo :

//********************************************************************
//********************************************************************
//ARQPGTO DD DUMMY
SYSOUT
Gera para o Sistema Operacional um DataSet com as saídas geradas pelo programa.
Exemplo :

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

JCL
DISP
Refere-se como o DataSet será disponibilizado para o sistema operacional.
[TERCEIRO PARÂMETRO]
TÉRMINO ANORMAL
[PRIMEIRO PARÂMETRO]
STATUS
DISP=(NEW,CATLG,DELETE)
[SEGUNDO PARÂMETRO]
TÉRMINO NORMAL
PARÂMETRO(s) DESCRIÇÃO
SHR Significa que o DataSet existe e pode ser lido por outro recurso simultâneamente.
OLD Significa que o DataSet existe e que o programa exige exclusividade na leitura.
NEW Criação de DataSet
MOD Modifica um DataSet sequencial. Acrescenta novos registros no final.
CATLG Cataloga o DataSet. Obviamente que esta opção deve estar sempre
acompanhada de NEW no primeiro sub-parâmetro. Porque se o DataSet estiver
sendo lido é porque já está catalogado.
UNCATLG Descataloga o DataSet. Evite usar sempre.
DELETE Delete o DataSet. Se precisar deletar o DataSet use sempre esta opção.
KEEP Mantem o DataSet do jeito que estava antes.
PASS Passa o DataSet para o próximo STEP do JOB.
VALORES PERMITIDOS POR PARÂMETRO
PRIMEIRO PARÂMETRO SEGUNDO PARÂMETRO TERCEIRO PARÂMETRO

(STATUS) (TÉRMINO NORMAL) (TÉRMINO ANORMAL)
NEW CATLG CATLG
OLD UNCATLG UNCATLG
MOD DELETE DELETE
SHR KEEP KEEP
- PASS -
Exemplo :
//********************************************************************
//********************************************************************
// UNIT=3390,

JCL
Exemplo Inválido :

//********************************************************************
//********************************************************************
// DISP=(NEW,KEEP,DELETE),
// UNIT=3390,
DISP=(NEW,KEEP,DELETE)
Como manter um DataSet, sendo que o DataSet nem foi criado ainda.
DEFAULT
Se você colocar apenas DISP=SHR o sistema assume (SHR,KEEP,KEEP).
SPACE
Espaço físico a ser utilizado.
TRK = alocação em trilhas

CYL = alocação em cilindros ( 1 cilindro tem 15 trilhas )
Onde :
5 = Alocação Primária
1 = Alocação Secundária
Exemplo :

//********************************************************************
//********************************************************************
// UNIT=3390,

JCL
RLSE = libera o espaço não utilizado na alocação do DataSet.
ALOCAÇÃO SECUNDÁRIA
Pode ser extendida até 15 extends.
Logo, nessa alocação de DataSet teríamos no máximo 20 trilhas. Sendo 5 trilhas para alocação
primária e no máximo 15 para alocação secundária.
UNIT
Informa o tipo de dispositivo.
3390 = efetiva o armazenamento em DISCO (dispositivo)

TAPE = efetiva o armazenamento em FITA (dispositivo)
SYSALLDA = informa o dispositivo mais apropriado para alocação do DataSet
SYSDA = utilizado para armazenamento temporário
Exemplo :

//********************************************************************
//********************************************************************
// UNIT=3390,
VOLUME
Informa qual volume dentro do DISCO deve ser referenciado.
SER – especifica o volume a ser referenciado

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

JCL
Exemplo :

//********************************************************************
//********************************************************************
// UNIT=3390,VOL=SER=PR39X7,
PR39X7
É o volume que está sendo referenciado
DCB ( DATA CONTROL BLOCK )

Define o formato do arquivo, tamanho dos registros e o tamanho do bloco para um novo DataSet.
Exemplo :

//********************************************************************
//********************************************************************
// UNIT=3390,
RECFM
Define o formato do arquivo
F = fixo sem blocagem

V = variável sem blocagem
U = indefinido
FB = fixo blocado
VB = variável blocado
FBA = fixo blocado com carácter de impressão
VBA = variável blocado com carácter de impressão

JCL
LRECL
Informa o tamanho do registro do arquivo. No nosso exemplo o tamanho do arquivo é 800 bytes.
BLKSIZE
Define a blocagem do arquivo. Isto é, quantos registros formam um bloco para acessar ao arquivo.
Deve ser sempre um múltiplo de LRECL ou 0(Zero). Se informado 0(Zero) a blocagem ideal é
calculada automaticamente.
1.5 JOBLIB
É a biblioteca na qual todos os STEPs do JOB referenciarão para execução dos programas Cobol.
(Somente objetos, programas que foram compilados e linkeditados).
A JOBLIB deve ser informada antes da execução do primeiro STEP do JOB.
Exemplo :

//JOBLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR
1.6 STEPLIB
É a biblioteca na qual um determinado STEP referencia para a execução do programa COBOL.
A STEPLIB deve ser informada no STEP que o programa será executado.
Exemplo :

//********************************************************************
//********************************************************************
A STEPLIB sobrepõe a JOBLIB. Caso informado no JOB, as duas opções a STEPLIB prevalece
sobre a JOBLIB. Isto é, a STEPLIB sobrepõe (override) a JOBLIB.
IMPORTANTE
Caso no JOB não seja referenciado nem a JOBLIB e nem STEPLIB, nenhum programa Cobol
será executado.

JCL
1.7 DDNAME x DSN(DSNAME)

1.7.1 DDNAME
Data Definiton Name. Faz a identificação dos arquivos e relatórios no JOB. Devem possuir no máximo
8 carácteres. Referencia a claúsula ASSIGN TO em programas COBOL. Podem representar : entrada
ou saída de dados.
Exemplo :

//********************************************************************
//********************************************************************
// UNIT=3390,
DDNAMEs
ARQPGTO e ARQSERA são os DDNAMES desse STEP. Sendo ARQPGTO (Entrada) e
ARQSERA (Saída).
1.7.2 DSN (DSNAME)

DataSet Name. É o nome físico do arquivo. Utiliza a claúsula DSN. É onde os dados são
armazenados fisicamente.
Exemplo :

//********************************************************************
//********************************************************************
// UNIT=3390,

JCL
DSNAMEs
GR.GPYYXX.ARQPGTO e GR.GPYYXX.ARQSERA são os DSNAMES desse STEP. Sendo
ARQPGTO (Entrada) E ARQSERA (Saída).
1.8 PARM
Efetiva a passagem de parâmetros para o programa que será executado. Deve possuir no máximo
100 carácteres.
Exemplo :

//********************************************************************
//* STEP001 – O PROGRAMA RECEBE DADOS VIA PARM DO JCL *
//********************************************************************
//STEP001 EXEC PGM=PROGRAMA, PARM=’DADOS PARA O PROGRAMA’
O programa COBOL recebe a passagem de parâmetros do JCL na área de LINKAGE SECTION do

programa COBOL.
1.10 JCL ERROR x ABEND x FLUSH
1.10.1 JCL ERROR

Existem erros de sintaxe no JOB ou algum recurso no JOB está indisponível para o Sistema
Operacional.
O JOB não é executado. Os STEPs não são executados.
1.10.2 ABEND
Representa falha na execução do STEP. O Sistema Operacional ou o programa retornam um código
de retorno ou código de ABEND no STEP.
O JOB é executado. O STEP é executado, porém existem uma falha na execução do STEP.
1.10.3 FLUSH
Significa que determinado STEP não foi executado. Normalmente ocorre o FLUSH no JOB quando
existe dependência entre os STEPs do JOB.
O JOB é executado. Porém o STEP não é executado.

JCL
CAPÍTULO 3 – ABENDS SISTEMA OPERACIONAL
S000 - ABEND DE SISTEMA.

S001 - DCB INCOMPATIVEL COM A ESPECIFICADA NO PROGRAMA.
- TENTAR LER OU GRAVAR UM ARQUIVO DEPOIS DE TE-LO FECHADO.
- ARQUIVO DE LEITURA MAL GRAVADO.
- FALTA CARTAO JCL E/OU SYSOUT.
- 'DCB', 'DCK', 'EROPT-ABE' (BLOCO ERRADO).
- UNIDADE SAIU DE READY.
- LEITURA APOS FIM DE ARQUIVO.
- 04 - ERRO NA 'DCB'. VERIFICAR 'DCB' COM 'LABEL'
- 05 - 'GET' OR 'READ' TENTADO PARA ARQUIVO JA FECHADO.
S002 - O PROGRAMA DE CONTROLE PROCESSANDO UM ARQUIVO SEQUENCIAL E
CRIANDO UM ARQUIVO DE ACESSO DIRETO.
- ABERTURA DE UM ARQUIVO VSAM PELO MODULO QISAM.
- REGISTRO MAIOR QUE O LRECL ESPECIFICADO.
- ESTOURO DE ROW.
S003 - INSTRUCOES DE 'I/O' NAO FORAM EXECUTADAS NA SEQUENCIA CORRETA.
S004 - METODO DE ACESSO CONFLITANTE.
- VOLUME DE IMAGELIB NAO MONTADO.
- FORMATO ESPECIFICADO NA DCB E' INVALIDO.
S005 - GRAVACAO DE UM ARQUIVO DE ENTRADA.
- LEITURA EM UM ARQUIVO DE SAIDA.
- ABRIR OU FECHAR NOVAMENTE O MESMO ARQUIVO.
S012 - LEITURA DE UM ARQUIVO VAZIO.
S013 - NAO EXISTE NADA GRAVADO NO VOLUME ESPECIFICADO.
- TAMANHO DO BLOCO E' MUITO GRANDE.
- NAO EXISTE A 'RDRJOB'
- DCB DESCRITA NO PGM DIFERE DO ARQUIVO DE LEITURA/GRAVACAO.
- MEMBRO DE UM DATASET NAO PODE SER ALOCADO OU NAO ENCONTRADO.
- RECFM=FB, MAS O BLKSIZE NAO E' MULTIPLO DO LRECL.
- REGISTROS FIXOS NAO BLOCADOS (RECFM=U), COM BLKSIZE=O.
- PARA REGISTROS VARIAVEIS NAO SPANNED, BLKSIZE NAO E' 4 VEZES OU
MAIS QUE O LRECL.
- NAO ESPECIFICOU DB. (EX: DB=2).
- BLKSIZE DO PROGRAMA = O, E NAO FOI INFORMADO NO JCL (MESMO PARA
ARQUIVOS COM DUMMY).
S020 - VERIFIQUE SE O PROGRAMA NAO ALTERA A 'DCB' OU SE O PROGRAMA CRIA
ARQUIVO APOS INSTRUCAO 'OPEN'.
S025 - ENDERECO INVALIDO NA DCB. FORA DOS LIMITES DA MEMORIA VIRTUAL
ASSINALDA PELA TASK.
S026 - ERRO DE OPERACAO DURANTE 'IPL' DO SISTEMA.
S028 - ERRO DE HARDWARE. ERRO DE I/O DETERMINADO PELO SUPERVISOR DE
PAGINACAO ENQUANTO CARREGAVA A PAGINA NA MEMORIA.
S030 - 'DCB' NAO INDICA A MANEIRA CORRETA DE OPERAR.
S031 - CARTAO 'DD' COM ASTERISCO SEM NECESSIDADE.
- LEITURA/GRAVACAO DE ARQUIVO 'DA' SEM A CLAUSULA INVALID KEY.
- TAMANHO DO BLOCO NAO PODE SER CARREGADO.
- RECORD KEY FORA DE SEQUNCIA OU DUPLICADO.
- TAMANHO DO REGISTRO MAIOR QUE O ESPECIFICADO NA DCB.
S032 - INFORMACOES INVALIDAS NA 'DCB' PARA ISAM.
S033 - ERRO NO NIVEL MAIS ALTO DEIM DE UM ARQUIVO 'IS'. (A DCB CONTEM,
RESPECTIVAMENTE, OS ENDERECOS DO PRIMEIRO E DO ULTIMO REGISTROS
NA PRINCIPAL AREA DE OVERFLOW INDEPENDENTE).

JCL
S034 - PARA REGISTRO DE TAMANHO VARIAVEL O PGM DE CONTROLE ENCONTROU

UM ENDERECO ERRADO.
- AREA NA MEMORIA VIRTUAL E' MUITO PEQUENA.
- ENDERECO FORA DA DCB, FORA DOS LIMITES DA MEMORIA VIRTUAL.
S035 - MEMORIA VIRTUAL PEQUENA DEMAIS PARA CONTER UM TRILHA DE MEMORIA
PRINCIPAL.
S03B - O ERRO OCORREU NO OPEN PARA UM DATASET 'IS'. NENHUM REGISTRO FOI
PROCESSADO PORQUE:
. O ARQUIVO NAO FOI CRIADO OU NAO FOI FECHADO APOS A CRIACAO.
. A DCBRKP ESTA ERRADA OU O TAMANHO DA CHAVE = ZERO.
. O BLKSIZE E' MENOR QUE O LRECL OU NAO E' MULTIPLO DO MESMO.
. O LRECL E' IGUAL A ZERO OU E' DIFIRENTE DO LABEL DE CRIACAO.
. UM ARQUIVO DE SAIDA FOI GRAVADO COM DISP SHR E NAO OLD/NEW.
. O RECFM ESPECIFICADO NAO E' O MESMO DA CRIACAO.
. KEYLEN NAO DEVE SER ESPECIFICADO PARA DATASET'S EXISTENTES.
S03D - BLOCAGEM DE ARQUIVO ERRADA.
- CARTAO DCB SEM PARAMETROS.
- DSORG=IS E RKP=O.
. O ARQUIVO NAO FOI CRIADO OU NAO FOI FECHADO APOS A CRIACAO.
S0A8 - OCORREU ERRO DURANTE A EXECUCAO DE UM PROGRAMA DE APLICACAO VTAM
S0A9 - UM COMANDO 'HALF NET' OU 'CANCEL' OCORREU NUM MODULO 'VTAM'.
- VER CODIGOS DO REGISTRADOR 15 NO MANUAL.
S0BC - ERRO DE HARDWARE DURANTE A EXECUCAO DE UMA SUBROTINA DA 'READER'
OU DA 'WRITER'.
S0B0 - PROVAVEL ERRO DE HARDWARE NA 'JOB QUEUE' DO DATASET.
S0B6 - ERRO LOGICO NO SISTEMA QUANDO FOI ACESSADO 'JOB LIST' RESIDENTE
S0C0 - UM PROGRAMA OMITIDO FOI ENCONTRADO DURANTE A EXECUCAO.
S0C1 - NOME DOS ARQUIVOS (DD) ESTAO ERRADOS. (FILE STATUS 90).
- FALTAM OU ESTAO ERRADOS OS CARTOES DD.
- DCB (QUANDO PASSADO 2.BLP).
- ROTINA DE PROCESSAMENTO SEM LOGICA.
- ABRIR OU FECHAR MAIS DE UMA VEZ UM ARQUIVO.
- LEU OU GRAVOU ARQUIVO FECHADO - ERRO NO OPEN.
- TENTAR GRAVAR UM ARQUIVO INPUT.
- ARQUIVO DIFERE TAMANHO COM LRECL DO SEQSAI.
S0C2 - 'SYS.... DD MISING', INCLUIR A SYS... QUE ESTA FALTANDO.
- STOP RUN DENTRO DO SORT.
S0C3 - O OBJETO DE UM EXECUTE E' OUTRO EXECUTE.
- FALTA FECHAR ARQUIVO OU TESTE APOS FECHAR ARQUIVO.
- TESTE EM CAMPOS DA FD APOS DAR CLOSE NO ARQUIVO.
S0C4 - ERRO DE PROGRAMA. PROVAVELMENTE 'LOOPING' EM ALGUMA INDEXACAO.
- FALTA CARTAO DD.
- VERIFICAR SE NAO FALTA PARAMETRO EM ALGUM 'CALL'.
- DISPLAY NO PROGRAMA SEM CARTAO SYSOUT.
- ACCEPT NO PROGRAMA SEM CARTAO SYSIN.
- ERRO DE ENDERECAMENTO (ESTOURO NA TABELA).
- MANUSEIO DE CAMPOS COM O ARQUIVO FECHADO.
- MOVER PARA AREA DE SORT ANTES DE DAR O COMANDO SORT.
- USO DA LINKAGE SEM DAR ENTRY OU USING NA PROCEDURE.
- MOVER CAMPOS PARA SORT INTERNO APOS O FIM DO OUTPUT.

JCL
S0C5 - ENDERECAMENTO INVALIDO.

- ABRIR OU FECHAR DUAS VEZES O MESMO ARQUIVO.
- INVERTER OS COMANDOS ENTRE OS ARQUIVOS DE I/O.
- ESTOURO DE TABELA.
- FALTA DE SECTION EM PROGRAMA COM SORT INTERNO.
- CLOSE ANTES DE DAR OPEN.
- MOVIMENTACAO PARA FD ANTES DO PRIMEIRO READ.
- REWRITE COM KEY ERRADA.
S0C6 - ERRO NO ENDERECAMENTO OU NA ALOCACAO DE ROTINAS EXTERNAS
(ACCT, DATA, ABEND, ETC...).
- CARTOES 'JCL' PODEM ESTAR FORA DE ORDEM.
- DD 'MISSING'.
- FALTA ESPACO NA MEMORIA.
- SORT INTERNO SEM SELECT.
- RETURN ARQUIVO VAZIO - SORT INTERNO.
- DIVISAO POR ZERO.
S0C7 - MANUSEIO DE CAMPO NUMERICO COM CONTEUDO NAO NUMERICO.
- NAO ESPECIFICAR O VALOR DE SORT-CORE-SIZE.
S0C8 - PONTO FIXO DE 'OVERFLOW' OMITIDO.
S0C9 - O QUOCIENTE EXCEDEU O TAMANHO DO REGISTRADOR.
'ENTRY-POINT-ADDRESS' EXCEDEU O TAMANHO DO REGISTRADOR.
- DIVISAO POR ZERO.
S0C8 - 'SIZE ERROR' SEM PROCEDIMENTO ALTERNATIVO. PROVAVEL DIVISAO POR
ZERO.
S0CE - EXPRESSAO OMITIDA. O RESULTADO FOI UMA FRACAO ZERADA.
S0CF - PONTO FLUTUANTE DE DIVISAO OMITIDO.
S0DD - ERRO OCORREU COMO RESULTADO DA TRADUCAO DE UM SEGMENTO INVALIDO.
S0D1 - ERRO OCORREU COMO RESULTADO INVALIDO DE UM 'PAGE DEFAULT INTER-
RUPTION'.
S0D3 - ERRO OCORREU COMO RESULTADO DE UMA INSTRUCAO DE MAQUINA DO SIS-
TEMA.
S0E1 - PROBLEMA DE ENDERECAMENTO. SUBMETER NOVAMENTE.
S0FC - ERRO DE MAQUINA. REPROCESSAR.
S0F1 - PARAMETRO 'DCB', 'IOB', 'DEB' DO PROGRAMA INCORRETOS.
S0F2 - PARAMETROS INCORRETOS PASSADOS PARA O 'TYPE ISVC ROUTINE'.
S0F3 - ERRO DE HARDWARE DETERMINADO PELA CHECAGEM DO SISTEMA.
S0F4 - PARAMETRO INVALIDO NA AREA DE WORK.
S0F5 - PARAMETRO INVALIDO NA AREA DE WORK.
S03B - ERRO OCORREU NO 'OPEN' DE UM DATASET 'IS' NAO PROCESSOU REGS.
S03D - CARTAO 'DCB' SEM PARAMETROS 'DSORG=IS' E RKP=O.
S031 - TENTATIVA DE CRIAR ARQUIVO 'IS' COM REGISTROS FORA DE ORDEM.
S101 - O PROGRAMA USA MAIS OCORRENCIAS QUE O ESPECIFICADO NA 'DCB'.
S102 - ENDERECAMENTO NA 'DCB' INVALIDO.
S103 - ENDERECO DO 'REQUEST BLOCK' NA 'DCB' INVALIDO.
- 'DCB' ESPECIFICADA JA ESTAVA LIGADA.
S106 - AUMENTAR 'REGION'.
- PROBLEMA COM A CATALOGACAO DO PROGRAMA.
- REGISTRO INVALIDO NO PGM DE CARGA OU ERRO I/O.
S113 - ERRO DE 'I/O' NA ABERTURA DO ARQUIVO.
S117 - ERRO DE 'I/O' DURANTE FECHAMENTO DE UM ARQUIVO EM FITA POR VO-
LUME OU DEVICE DEFEITUOSO.
S122 - JOB EM LOOP OU NAO HA ESPACO DISPONIVEL EM DISCO
CANCELADO COM 'DUMP' PELO OPERADOR.
S130 - ERRO NA MACRO 'DEQ' ESPECIFICA UM RECURSO NAO ESPECIFICADO NA
JCL
MACRO 'ENQ'.
S137 - ERRO NO FIM DE VOLUME EM FITA.
- 04-08-0C-10-14-18 ERRO DE POSICIONAMENTO, LEITURA OU GRAVA-
CAO EM FIM DE VOLUME REPROCESSAR COM BACKUP
- 1C - 'TRAILER LABEL' INVALIDO.
- 20 - 'HEADER LABEL' INVALIDO.
S13F - 'RESTART NOT SUCESSUFUL'. REPROCESSAR.
S180 - 'GDG' DO ARQUIVO DE LEITURA/GRAVACAO NAO FOI CRIADO.
S1F9 - DURANTE A EXECUCAO DE UM COMANDO MODIFY PAA PARAR OU RESTARTAR
UMA LINE, A IMPRESSORA OU UM PGM EXTERNO ABENDOU.
S200 - ERRO DE MAQUINA. REPROCESSAR.
S201 - ENDERECAMENTO DA 'DCB' INVALIDO.
S207 - ROTINA DE 'EXIT'NAO SINCRONIZADA.
S213 - ERRO DURANTE INSTRUCAO DE 'OPEN' DE ARQUIVO EM DISCO.
- 04 - O ARQUIVO NAO FOI ENCONTRADO, VERIFICAR DE 'DSN' E 'VOL'
ESTAO CORRETOS. INEXISTENCIA DO ARQUIVO OU ACESSO A DISCO ERRADO
- DSCB NOT FOUND. I/O R/W DSCB.
- LEITURA DE UM ARQUIVO CATALOGADO EM QUE HA O NOME DO ARQUIVO NA
VTOC, MAS OS DADOS FORAM DELETADOS.
- DSNAME OU VOLUME INCORRETOS.
S214 - ERRO OCORREU DURANTE A EXECUCAO DE UMA INSTRUCAO DE 'CLOSE' PA-
RA UM ARQUIVO EM FITA. REPROCESSAR.
- ERRO DE I/O NA LEITURA DO LABEL DO USUARIO NUMA FITA.
S217 - ERRO DE FECHAMENTO DE UM ARQUIVO 'BSAM'.
S222 - CANCELADO PELO OPERADOR SEM 'DUMP'.
S22D - ENDERECAMENTO FORA DOS LIMITES DA MEMORIA VIRTUAL.
S23D - ERRO NA MACRO 'DEQ'. TAMANHO ERRADO.
S237 - ERRO NO FIM DO VOLUME.
- 04 - ERRO NA CONTAGEM DOS BLOCOS. SE OCORREU NO COMECO DE UM
ARQUIVO COM VARIOS VOLUMES OU SE TIVER 'CHECKPOINT', TENTAR
REPROCESSAR SENAO FAZER FD.
S2F3 - JOB CANCELADO POR QUEDA DO SISTEMA.
S22D - ENCERRAMENTO FORA DOS LIMITES DA MEMORIA VIRTUAL.
S301 - INSTRUCAO DE 'WAIT' NA 'DCB' JA ESTAVA LIGADA.
S306 - MODULO ACESSADO NAO ENCONTRADO.
S30A - AUMENTAR A 'REGION'.
- FALTA CLAUSULA OBJECT-COMPUTER.
S313 - UM VOLUME OU 'DEVICE' DEFEITUOSO CAUSOU ERRO.
S314 - ERRO DE FECHAMENTO DE UM ARQUIVO.
S317 - ERRO DE FECHAMENTO DE UM ARQUIVO 'BSAM' CAUSADO POR UM VOLUME
OU DEVICE DEFEITUOSO.
S322 - AUMENTAR O 'TIME' DO CARTAO JOB.
S32D - LINKEDITE O PGM PROBLEMA NOVAMENTE E REEXECUTE O JOB STEP
ABEND NO SORT - CARTAO DE CONTROLE ERRADO.
S330 - ERRO NA MACRO 'DEQ'. ESPECIFICOU UMA OPCAO RESET-MUST-COMPLETE
OU GENERICO OU DIRETO DE 'DEQ'. SENDO ESSAS OPCOES VALIDAS
APENAS EM ESTADO SUPERVISOR.
S337 - O ERRO OCORREU QUANDO UM FIM DE ARQUIVO FOI ALCANCADO.
04 - O FIM DE ARQUIVO FOI ALCANCADO E NAO EXISTE ROTINA DE
'EOF'. OCORRE QUANDO EXISTE UM ARQUIVO MULTIVOLUME E NAO
FORAM FORCADOS TODOS OS VOLUMES.
S3FE - UMA 'TASK' TERMINANDO, EDITA UM 'I/O' A SER EXECUTADO POR
OUTRA 'TASK'.
S400 - FALTA CARTAO 'SYSOUT' PARA O PROGRAMA.
S402 - COLOCADO ENDERECOS DA TABELA DE EVENTOS DA 'DCB' ANTES DA OCOR-
RENCIA DE UM EVENTO ASSOCIADO A 'DCB'.
JCL
S406 - O PROGRAMA PRODUZIDO PELO 'LINK-EDITOR' CONTEM 'OL' NO CARTAO

EXEC.
S413 - ERRO DE OPEN PARA ARQUIVO DE FITA OU DISCO.
- 08-0C-10-14-20 - ERRO DE POSICIONAMENTO OU GRAVACAO.
REPROCESSAR.
S414 - DISPOSITIVO DIFERENTE ESPECIFICADO NO PARAMETRO 'UNIT', OU
DEVICE.
S422 - FALTOU QUEUE. EXCESSO DE CARTOES DD NO JOB.
- ESPACO EXIGIDO PELO JOB NA QUEUE E' MUITO GRANDE PARA INICIAR.
S42A - PROGRAMA DE CONTROLE ACHOU UM PARAMETRO 'LIST' CRIADO NA ROTINA
'EXIT' NA INSTRUCAO MACRO 'DEQ' ANTERIORMENTE PEDIDA NA MESMA
TASK, MAS AINDA NAO RECEBEU O CONTROLE DA ROTINA.
S42D - ENDERECO DA 'DCB' NAO ESTA NA MEMORIA.
S482 - ABEND DO SISTEMA. SUBMETA NOVAMENTE.
S4FE - IDEM AO 'S3FE', SO QUE A 'TASK' NAO E' DE TELEPROCESSAMENTO.
S506 - REDUZA O TAMANHO DE ENTRADA DO PROGRAMA OU DO SEGMENTO DE
'OVERLAY'.
S513 - ERRO NA ABERTURA DE UM DATASET EM FITA. REPROCESSAR.
S514 - ERRO DE FECHAMENTO DE UM ARQUIVO CAUSADO POR VOLUME OU DEVICE
DEFEITUOSO.
S522 - 'TIME' DE MAQUINA. (PROVAVEL LOOP).
- OUTLIM DEFAULT ATINGIDO.
- ESPERA DE RESPOSTA P/ MONTAGEM DO ARQUIVO NAO ATINGIDA.
S604 - O ENDERECO PEDIDO ESTA FORA DA MEMORIA VIRTUAL PEDIDA NA 'TASK'
S605 - ENDERECO DE ALOCACAO FORA DOS LIMITES DA MEMORIA VIRTUAL.
S606 - REDUZA O TAMANHO DE ENTRADA DO PROGRAMA OU DO SEGMENTO DE 'OVER
LAY'. ACRESCENTE O TAMANHO DA REGIAO NO CARTAO EXEC.
S60A - ESPECIFICACAO INVALIDA DE UMA AREA A SER LIBERADA.
S613 - ERRO OCORREU DURANTE A EXECUCAO DE INSTRUCAO DE 'OPEN' PARA
ARQUIVO EM FITA.
- 04-08-10-14 - ERRO DE POSICIONAMENTO DE LEITURA/GRAVACAO.
REPROCESSAR.
S614 - ERRO DE FECHAMENTO DE ARQUIVO CAUSADO POR VOLUME OU DEVICE
DEFEITUOSO.
S637 - ERRO OCORREU DURANTE O FIM DE VOLUME EM UMA CONCATENACAO
DE ARQUIVOS.
- 0C - CONCATENACAO DE ARQUIVOS COM DIFERENCA DE ATRIBUTOS NAO
ESPECIFICADOS NA 'DCB' FOI DETECTADO
- SORT COM DD CONCATENADOS. OS ARQUIVOS DEVEM ESTAR EM UM MESMO
TIPO DE UNIDADE.
- DEMAIS CODIGOS REPROCESSAR.
S706 - ERRO DE PROGRAMA ENCONTRADO PELO 'LINKAGE-EDITOR' NO MODULO
DE CARGA.
S713 - DATA DE EXPIRACAO DE UM ARQUIVO NAO ENCONTRADA.
S714 - ERRO OCORREU DURANTE A EXECUCAO DE UM 'CLOSE' PARA ARQUIVO EM
FITA.
- ERRO DURANTE GRAVACAO DE 'TRAILER-LABEL' OU 'TAPE-MARK'.
REPROCESSAR.
S717 - IDEM AO 'S417'.
S722 - 'OUTLIM' ESPECIFICADO NA 'SYSOUT' ATINGIDO.
S737 - PROBLEMAS COM 'SPACE'. AUMENTAR / OU / OVERRIDE EM EXCESSO.
S804 - FALTA O PARAMETRO REGION NOS CARTOES JOB OU EXEC, OU A
QUANTIDADE ESPECIFICADA E' PEQUENA.
- QUANDO BLOCO E' IGUAL A 0 E BLKSIZE DA DCB MUITO GRANDE.
S806 - MODULO OU PROGRAMA INDICADO NO CARTAO EXEC NAO ENCONTRADO.
S80A - IDEM AO 'S804'.
JCL
S813 - ERRO DE 'OPEN' PARA ARQUIVO EM FITA. CHECAR 'DSN' DO JCL COM
LABEL. COLOCAR 'DSN' E GERACAO CORRETOS.
- LABEL DA FITA NAO COMBINA COM A DESCRITA NO PGM.
- LABEL DA FITA DESTRUIDO.
S814 - FALTA PARAMETRO 'REGION' NOS CARTOES JOB OU EXEC, OU ENTAO
A QUANTIDADE ESPECIFICADA E' PEQUENA.
S822 - ESPACO PEDIDO EM 'V=R' NAO DISPONIVEL.
S837 - AUMENTAR O 'VOLCOUNT' EX.: VOL=(,,,6).
S878 - IDEM AO 'S804'.
S905 - O ENDERECO DA MEMORIA NAO E UMA 'DOUBLEWORD' OU NAO E'
MULTIPLO DE 8.
S906 - ALTERE O PROGRAMA PARA ACEITAR O 'LINKAGE-EDITOR' SERIAL/
REUSAVEL.
S90A - ERRO DE PROGRAMA. ERRO NA INSTRUCAO 'FROM' OU DAR 'CLOSE' EM
ARQUIVO FECHADO.
S913 - ERRO NA 'PASSWORD' DE ABERTURA DO ARQUIVO.
SA0A - A CHECAGEM DO SISTEMA DETECTOU UM ERRO DE HARDWARE.
SA04 - MANAGEMENT QUEUE DA MEMORIA ALTERADO INCORRETAMENTE.
SA05 - PROGRAMA DE CONTROLE ACESSOU UMA AREA EM BRANCO DA MEMORIA
VIRTUAL.
- ABRIR OU FECHAR DUAS VEZES O MESMO ARQUIVO.
SA06 - ALTERE O PROGRAMA PARA ESPERAR ATE' QUE LOADER SEJA SERIALMENTE
REUSAVEL.
SA13 - UM 'OPEN' FOI TENTADO PARA ABRIR UM ARQUIVO EM FITA, MAS ESTE
NAO FOI ENCONTRADO NA MESMA. VERIFICAR SE O VOLUME SEQUENCIAL
ESTA CORRETO. CHECAR O PARAMETRO 'LABEL', SE ESTIVER SALTANDO
ARQUIVOS. ERRO NA 'DCB' DA FITA.
SA14 - ERRO DE 'I/O' CAUSADO POR UM VOLUME OU DISPOSITIVO DEFEITUOSO.
SB0A - CHAVE DE INTERRUPCAO FOI TECLADA PELO OPERADOR.
SB04 - ESPACO REQUISITADO ESPECIFICADO INCORRETAMENTE.
SB06 - ERRO DE MAQUINA, SUBMETA NOVAMENTE SUA TASK.
SB13 - ERRO NA ABERTURA DE UM ARQUIVO DE IMPRESSAO.
SB14 - NOME DUPLICADO EM UM ARQUIVO PARTICIONADO.
SB37 - ERRO OCORREU DURANTE FIM DE VOLUME. ESPACO RESERVADO NAO FOI
SUFICIENTE. AUMENTAR AREA OU RETIRAR O 'CLOSE UNIT'.
- BIBLIOTECA SEM ESPACO.
- SE O ARQUIVO FOR EM DISCO JA OCORRERAM 16 EXTENDS, MAS O
ARQUIVO PRECISOU DE MAIS ESPACO.
- NAO HA MAIS ESPACO DISPONIVEL PARA ALOCAR NO VOLUME PEDIDO.
- MAIS ESPACO FOI PEDIDO MAS O VTOC ESTA CHEIO.
- INSUFICIENCIA DE ESPACO PARA COMPILAR/LINKEDITAR O PGM.
SC03 - FALTOU CLOSE EM UM ARQUIVO NO PROGRAMA EXECUTADO SOB LOADER.
SC06 - ERRO DE MAQUINA, SUBMETA O JOB NOVAMENTE.
SC13 - ERRO NA ABERTURA DE UM ARQUIVO CONCATENADO PARTICIONADO.
- ERRO NA ABERTURA DE GRAPHIC DEVICE.
SC2D - LINKEDITE O PROGRAMA NOVAMENTE E REEXECUTE O JOB.
SD13 - ERRO NA 'DCB' DA IMPRESSORA.
SD14 - FECHAR UM ARQUIVO NAO ABERTO.
SD2D - LINKEDITE O PROGRAMA NOVAMENTE E REEXECUTE O JOB.
SD23 - 'BUFFERS' NAO ACESSAVEIS.
SD37 - ESTOURO DE DISCO. AUMENTAR 'SPACE', COLOCAR OU AUMENTAR AREA
SECUNDARIA. PODE SER ESTOURO NA BIBLIOTECA.
SE13 - ERRO DE 'DCB' NO CARTAO DD.
SE2D - LINKEDITE O PROGRAMA NOVAMENTE E REEXECUTE O JOB.
SE23 - AREA DA MEMORIA VIRTUAL PARA REPOSICAO INVALIDA.
SE37 - FALTA ESPACO NO 'VOLCOUNT'.
JCL
- FALTA ESPACO NA BIBLIOTECA PARA CATALOGAR O PGM.

SF37 - FALTA ESPACO NO 'VOLCOUNT'.
SFF9 - O ENDERECO DO ABEND APONTA PARA O 'ONEP', APESAR DE O PROBLEMA
SER NO 'ADABAS'. SUBMETER NOVAMENTE.
SIFA - ABEND DE SISTEMA.
0004 - FALTA DE CARTAO CONTROLE (FB).
0016 - EXCEDEU A CAPACIDADE DO SORT - AUMENTAR SORTWORKS.
0018 - ERRO NO CONTROL FIELD PARAMETRO - ACERTAR SE FOR POSSIVEL.
0024 - ERRO NO PROGRAMA GENERICO - SUSPENDER.
0039 - AUMENTAR REGION.
0042 - ERRO NO CARTAO DO SORT - TIRAR O CARTAO SYSOUT.
0043 - AUMENTAR REGION.
0046 - EXCEDEU A CAPACIDADE DO SORT - AUMENTAR SORTWORKS.
0056 - SORT OU SORTOUT NAO DEFINIDO.
0061 - DCB OU I/O ERROR DEVICE.
0063 - ERRO NO CARTAO SORT - COLOCAR /* SORTIN.
- SE EXISTIR SORTWORKS, COLOCAR O CARTAO SYSOUT E SORTLIB.
0068 - DCB FORA DE SEQUENCIA, REGISTROS FORA DE SEQUENCIA (NO MERGE).
- TIRAR LABEL DOS ARQUIVOS E COLOCAR OS DE MAIOR DCB ANTES.
0078 - AUMENTAR A REGION.
0220 - ACCT EM LOCAL INADEQUADO QUANDO NO OPEN INICIAL.
- DCB INCOMPATIVEL.
0230 - ACCT - HOUVE CONDICAO DE ERRO PERMANENTE EM UM DOS ARQUIVOS.
- BLKSIZE NAO E' MULTIPLO DO LRECL OU DIFERE DO PROGRAMA.
1001 - FALTA DD GO.DDCHECK.
2000 - PROBLEMA COM FW-I/O ERROR LEITURA OU PARM XX INVALIDO.
2048 - ABEND DO LIBRARIAN - QUANDO NAO DEPENDER DE INF. EXTRA ACERTAR.
3500 - ABEND FORCADO PELO PROGRAMA - SEM DUMP.
3501 - ABEND FORCADO PELO PROGRAMA - COM DUMP.
914I - ERRO NO MEMBRO ALOCADO.

ESCOLA
DE PROGRAMADORES
MÓDULO : COBOL
COBOL
INDICE
1 INTRODUÇÃO À LINGUAGEM COBOL ....................................................................................... 3
2 INTERPRETAÇÃO DOS FORMATOS NA APOSTILA ................................................................. 6
2.1 INDENTAÇÃO ....................................................................................................................................... 6

2.2 FORMATO DO FONTE COBOL........................................................................................................... 8
3 DIVISÕES DO COBOL ................................................................................................................. 11
3.1 IDENTIFICATION DIVISION............................................................................................................. 12

3.2 ENVIRONMENT DIVISION ............................................................................................................... 13
3.3 CONFIGURATION SECTION ............................................................................................................ 14
3.4 INPUT-OUTPUT SECTION ................................................................................................................ 15
3.5 DATA DIVISION ................................................................................................................................. 16
4 ESPECIFICAÇÃO PARA DADOS OU VÁRIAVEIS..................................................................... 18
5 COMANDOS ................................................................................................................................. 23
5.1 ACCEPT RECEBENDO DADOS DO SISTEMA ............................................................................... 23

5.2 DISPLAY .............................................................................................................................................. 25
5.3 STOP RUN ............................................................................................................................................ 25
6 COMANDOS ARITMÉTICOS ....................................................................................................... 26
6.1 Opção ROUNDED ................................................................................................................................ 26

6.2 Opção ON SIZE ERROR ...................................................................................................................... 26
6.3 Opção END-… (Delimitador de escopo) .............................................................................................. 27
ADD ............................................................................................................................................................ 27
SUBTRACT ................................................................................................................................................ 28
DIVIDE ....................................................................................................................................................... 29
MULTIPLY ................................................................................................................................................. 30
COMPUTE .................................................................................................................................................. 31
7 ESTRUTURA LÓGICA - DECISÃO ............................................................................................. 33
7.1 Comandos de Decisão ........................................................................................................................... 33

7.2 Operadores Relacionais ......................................................................................................................... 34
7.3 Operadores Lógicos ............................................................................................................................... 34
7.4 CONTINUE OU NEXT SENTENCE ................................................................................................. 36
7.5 EVALUATE .......................................................................................................................................... 37
8 ESTRUTURA LÓGICA – REPETIÇÃO ........................................................................................ 38
8.1 PERFORM ............................................................................................................................................ 39

PERFORM parágrafo [THRU parágrafo-fim] ............................................................................................. 39
PERFORM parágrafo [THRU parágrafo-fim] N TIMES ............................................................................ 39
PERFORM parágrafo [THRU parágrafo-fim] UNTIL condição ................................................................ 40
PERFORM parágrafo [THRU parágrafo-fim] VARYING campo FROM n BY m UNTIL condição ....... 40
Direitos Autorais – ISP Consultoria
www.escoladeprogramadores.com.br
1
COBOL
9 LÓGICA ESTRUTURADA ............................................................................................................ 41
10 ARQUIVOS SEQÜENCIAIS ....................................................................................................... 43
10.1 Conceitos Básicos ................................................................................................................................ 43
11 COMANDOS PARA PROCESSAMENTO DE ARQUIVOS SEQUENCIAIS ............................. 44
11.1 ENVIRONMENT DIVISION - INPUT-OUTPUT SECTION ........................................................... 45

11.2 DATA DIVISION - FILE SECTION .................................................................................................. 46
12 FLUXOGRAMA ........................................................................................................................... 47
13 ABERTURA DE ARQUIVOS ...................................................................................................... 52
14 MOVIMENTAÇÃO DE CAMPOS................................................................................................ 53
15 GRAVAÇÃO DE REGISTROS ................................................................................................... 55
16 FECHAMENTOS DE ARQUIVOS .............................................................................................. 56
17 LEITURA DE ARQUIVOS SEQÜENCIAIS ................................................................................. 57
18 INICIALIZAÇÃO DE CAMPOS E CONJUNTO DE VARIÁVEIS ............................................... 58
19 ENCERRAMENTO DE PARÁGRAFOS ..................................................................................... 59
20 RELATÓRIOS ............................................................................................................................. 60
20.1 COMANDOS PARA PROCESSAMENTO DE RELATÓRIOS ....................................................... 63

20.2 Totalização e Quebra de Relatórios ..................................................................................................... 65
21 LÓGICA BALANCEADA ............................................................................................................ 66
22 TABELAS DE MEMÓRIA – CLÁUSULA OCCURS .................................................................. 69
22.1 NÍVEIS DE TABELAS ....................................................................................................................... 71
23 CHAMANDO UM SUB-PROGRAMA ......................................................................................... 72
24 COMPILAÇÃO E LINKEDIÇÃO DE PROGRAMAS .................................................................. 73
25 FILE STATUS ............................................................................................................................. 74

2
COBOL
1 Introdução à Linguagem COBOL
O COBOL foi criado em 1959 durante o CODASYL (Conference on Data Systems

Language), um dos três comitês propostos numa reunião no Pentágono em Maio de 1959,
organizado por Charles Phillips do Departamento de Defesa dos Estados Unidos. O CODASYL foi
formado para recomendar as diretrizes de uma linguagem para negócios. Foi constituído por
membros representantes de seis fabricantes de computadores e três órgãos governamentais, a
saber: Burroughs Corporation, IBM, Minneapolis-Honeywell (Honeywell Labs), RCA, Sperry Rand,
e Sylvania Electric Products, e a Força Aérea dos Estados Unidos, o David Taylor Model Basin e a
Agência Nacional de Padrões (National Bureau of Standards ou NBS). Este comitê foi presidido
por um membro do NBS. Um comitê de Médio Prazo e outro de Longo Prazo foram também
propostos na reunião do Pentágono. Entretanto, embora tenha sido formado, o Comitê de Médio
Prazo nunca chegou a funcionar; e o Comitê de Longo Prazo nem chegou a ser formado. Por fim,
um subcomitê do Comitê de Curto Prazo desenvolveu as especificações da linguagem COBOL.
O COBOL foi definido na especificação original, possuia excelentes capacidades de
autodocumentação, bons métodos de manuseio de arquivos, e excepcional modelagem de dados
para a época, graças ao uso da cláusula PICTURE para especificações detalhadas de campos.
Entretanto, segundo os padrões modernos de definição de linguagens de programação, tinha
sérias deficiências, notadamente sintaxe prolixa e falta de suporte de variáveis locais, recorrência,
alocação dinâmica de memória e programação estruturada. A falta de suporte à linguagem
orientada a objeto é compreensível, já que o conceito era desconhecido naquela época.
O COBOL possui muitas palavras reservadas, e é difícil evitar de usar alguma
inadvertidamente sem o uso de alguma convenção, como adicionando um prefixo a todos os
nomes de variáveis. A especificação original do COBOL suportava até código auto-modificável
através do famoso comando "ALTER X TO PROCEED TO Y". Entretanto, a especificação do
COBOL foi redefinida de tempos em tempos para atender a algumas das críticas, e as últimas
definições do COBOL corrigiram muitas destas falhas, acrescentando estruturas de controle
melhoradas, orientação a objeto e removendo a possibilidade de codificação auto-modificável.
O COBOL provou ser durável e adaptável. O padrão atual do COBOL é o COBOL2002. O
COBOL2002 suporta conveniências modernas como Unicode, geração de XML e convenção de
chamadas de/para linguagens como o C, inclusão como linguagem de primeira classe em
ambientes de desenvolvimento como o .NET da Microsoft e a capacidade de operar em ambientes
fechados como Java (incluindo COBOL em instâncias de EJB) e acesso a qualquer base SQL.
No Brasil a área financeira e de seguros são os principais mercados de COBOL e está
aquecido devido grandes compras e fusões das instituições.
Como seu nome indica, o objetivo desta linguagem é permitir o desenvolvimento de

aplicações comerciais. Depois de escrito o programa COBOL (chamado de programa fonte), é
necessário traduzí-lo para a linguagem interna do computador (linguagem de máquina),
convertendo-se então em um programa objeto. Esta conversão é feita através de um job
executado no sistema operacional, chamado de compilador COBOL.

3
COBOL
Teremos em seguida a definição de alguns termos importantes para o desenvolvimento do curso:
 Byte: Conjunto de 8 bits que formam uma posição de memória.
bit 0 bit 1 bit 2 bit 3 bit 4 bit 5 bit 6 bit 7
Conversão de números Decimais para números Binários:
A conversão do número inteiro, de decimal para binário, será feita da direita para a
esquerda, isto é, determina-se primeiro o algarismos das unidades ( o que vai ser multiplicado por
0 1
2 ) , em seguida o segundo algarismo da direita ( o que vai ser multiplicado por 2 ) etc...
A questão chave, por incrível que pareça, é observar se o número é par ou ímpar. Em
binário, o número par termina em 0 e o ímpar em 1. Assim determina-se o algarismo da direita,
pela simples divisão do número por dois; se o resto for 0 (número par) o algarismo da direita é 0;
se o resto for 1 (número ímpar) o algarismo da direita é 1.
Vamos converter 25 de decimal para binário.

4
COBOL
Para saber o resultado em binário, basta verificar os restos das divisões de baixo para cima.
Exemplo:
Decimal Binário
0 0000
1 0001
2 0010
3 0011
4 0100
5 0101
6 0110
7 0111
8 1000
9 1001
10 1010
11 1011
12 1100
13 1101
14 1110
15 1111
ASCII (American National Standard Code for Information Interchange): é uma codificação de
caracteres de oito bits baseada no alfabeto inglês. Os códigos ASCII representam texto em
computadores, equipamentos de comunicação, entre outros dispositivos que trabalham com texto.
Desenvolvida a partir de 1960, grande parte das codificações de caracteres modernas a herdaram
como base.
 EBCDIC (Extended Binary Coded Decimal Interchange Code): é uma codificação de

caracteres 8-bit que descende diretamente do código BCD com 6-bit e foi criado pela IBM como
um padrão no início dos anos 1960 e usado no ibm 360.
 Programa fonte: é o conjunto de palavras ou símbolos escritos de forma ordenada, contendo

instruções em uma das linguagens de programação existentes, de maneira lógica.
 Programa objeto: Existem linguagens que são compiladas e as que são interpretadas. As
linguagens compiladas, após ser compilado o código fonte, transformam-se em software, ou seja,
programas executáveis.
 Compilador: é usado principalmente para os programas que traduzem o código de fonte de

uma linguagem de programação de alto nível para uma linguagem de programação de baixo nível.
 Linguagem de Alto Nível: é como se chama, na Ciência da Computação de linguagens de

programação, uma linguagem com um nível de abstração relativamente elevado, longe do código
de máquina e mais próximo da linguagem humana.
 Linguagem de Baixo Nível: trata-se de uma linguagem de programação que compreende as

características da arquitetura do computador. Assim, utiliza somente instruções do processador,
para isso é necessário conhecer os registradores da máquina.

5
COBOL
2 INTERPRETAÇÃO DOS FORMATOS NA APOSTILA
1. Palavras sublinhadas são obrigatórias.

2. O símbolo | (pipe) indica que apenas uma das palavras é obrigatória.
3. Palavras em letras maiúsculas são palavras reservadas do COBOL.
4. A palavra “identificador” significa um campo ou registro definido na DATA DIVISION.
5. As Chaves {} significam que uma das palavras em seu interior, separadas ou não pelo símbolo
| (pipe), é obrigatória.
6. As reticências ou pontos (...) indicam que dois ou mais campos ou literais podem ser
especificados.
7. A palavra “literal” significa uma constante numérica ou alfanumérica.
8. As palavras entre [] significam que são palavras reservadas do COBOL, mas sua utilização é
opcional para o comando.
2.1 INDENTAÇÃO
O processo de indentação consiste em alinhar comandos, de forma que fique mais fácil ao
programador que estiver analisando o código, visualizar e, por decorrência, entender o conjunto de
instruções. Algumas instruções trabalham com Subconjuntos (blocos) de (outras) instruções; por
meio da indentação colocam-se instruções que façam parte de um mesmo bloco num mesmo
alinhamento.
O caso mais comum é o das instruções condicionais (IF), onde normalmente existe pelo
menos um bloco de instruções que deve ser executado quando a condição for verdadeira; e,
opcionalmente, outro bloco de instruções que devem ser executadas quando a condição for falsa,
exemplo:
IF condição
bloco para condição verdadeira
ELSE
bloco para condição falsa
END-IF
Visualmente facilita-se bastante se deslocarmos os blocos algumas posições à direita

(duas ou três posições são suficientes), para que fique destacado o ELSE e o END-IF, facilitando
a análise do código fonte.

6
COBOL
Se a especificação fosse feita sem indentação:
IF condição
COMPUTE A = (B * C ) ** 4
COMPUTE C = A / 0,005
ELSE
END-IF
Ficaria mais difícil analisar do que se houvesse sido especificado com indentação:
IF condição
ELSE
END-IF.
A vantagem desta técnica é que fica muito mais evidente quando houver IFS encadeados :
Sem indentação : Com indentação :
IF condição IF condição
COMPUTE A = (B * C ) ** 4 COMPUTE A = (B * C ) ** 4
COMPUTE C = A / 0,005 COMPUTE C = A / 0,005
ELSE ELSE
END-IF END-IF
ELSE ELSE
ELSE ELSE
END-IF END-IF
END-IF. END-IF.

7
COBOL
2.2 FORMATO DO FONTE COBOL
Todo programa escrito na linguagem COBOL possui algumas regras a serem seguidas.
Uma destas regras se refere ao formato das linhas de comando (instruções) dentro do seu editor
de fonte. Uma linha de comando COBOL pode ter até 65 caracteres, conforme o formato abaixo:
Colunas de 1 a 6: Área de numeração seqüencial de linhas do editor
Coluna 7: Área de indicação de comentários ou continuação
Colunas de 8 a 11: Área A ou Nível A para codificação das palavras da linguagem
Colunas de 12 a 72: Área B ou Nível B para codificação dos comandos da linguagem
Colunas de 73 a 80: Não utilizadas na programação

8
COBOL
ÁREA DE NUMERAÇÃO SEQÜENCIAL (COLUNAS DE 1 A 6)
Normalmente consiste em seis dígitos em ordem crescente que são utilizados para
numerar as linhas do programa fonte.
ÁREA DE INDICAÇÃO (COLUNA 7)
HÍFEN (-)
Se o hífen estiver nesta posição indica que existe uma continuação de uma cadeia de
caracteres, (uma palavra ou frase), que foi iniciada na linha anterior. Uma literal que não caiba
numa linha, para que seja continuada na próxima linha, precisa ter na próxima linha a indicação da
continuação (hífen na coluna 7) e, em qualquer coluna a partir da 12, um apóstrofe ou aspas
indicando o início da continuação.

9
COBOL
ASTERISCO (*)
Nesta posição indica, para o compilador COBOL, que toda a linha deve ser tratada como
uma linha de comentário.
ÁREA A – ÁREA B (COLUNAS DE 8 A 72)
Área A: Posição a partir da qual se escreve nome das Divisões, Sessões, parágrafos, palavras
reservadas e níveis de dados.
Área B: Posição a partir da qual se escrevem as instruções na linguagem COBOL.
Exemplo:

10
COBOL
3 DIVISÕES DO COBOL
O COBOL consiste basicamente em quatro divisões separadas:
 IDENTIFICATION DIVISION
A IDENTIFICATION DIVISION possui informações documentais, como nome do programa,

quem o codificou e quando essa codificação foi realizada.
 ENVIRONMENT DIVISION
A ENVIRONMENT DIVISION descreve o computador e os periféricos que serão utilizados pelo

programa.
 DATA DIVISION
A DATA DIVISION descreve os layouts dos arquivos de entrada e saída que serão usadas
pelo programa. Também define as áreas de trabalho e constantes necessárias para o
processamento dos dados.
 PROCEDURE DIVISION
A PROCEDURE DIVISION contém o código que irá manipular os dados descritos na DATA
DIVISION. É nesta divisão que o desenvolvedor descreverá o algoritmo do programa.

11
COBOL
3.1 IDENTIFICATION DIVISION
Esta é a divisão de identificação do programa. Não contêm Sections, mas somente alguns
parágrafos pré-estabelecidos e opcionais. O único parágrafo obrigatório é o PROGRAM-ID (Nome
do programa). O nome do programa deve ser uma palavra com até 8 caracteres (letras ou
números), começando por uma letra.
Esta divisão possui a seguinte estrutura:
Todas as cláusulas que possuem a palavra “comentário” à direita, não possuem nenhum
efeito na aplicação. São apenas parâmetros opcionais para documentação do programa.
A IDENTIFICATION DIVISION pode ser abreviada para ID DIVISION.

12
COBOL
3.2 ENVIRONMENT DIVISION
Esta divisão é para a qualificação de ambiente, equipamentos e arquivos, que serão

utilizados pelo programa. Possui duas SECTION e sua estrutura é a seguinte:

13
COBOL
3.3 CONFIGURATION SECTION
Esta seção destina-se a descrição dos equipamentos que serão utilizados pelo programa.
Esta SECTION é composta por três parágrafos: SOURCE-COMPUTER, OBJECT-COMPUTER e
SPECIAL-NAMES. A declaração destes parágrafos eram necessárias até a versão do MVS/ESA,
pois um programa só podia ser executado em apenas uma máquina. Após as versões OS/390 e
z/OS, e a nova versão do COBOL II, estes parágrafos, tornaram-se obsoletos, pois um programa
pode ser executado em qualquer máquina.
SOURCE-COMPUTER: identifica o computador onde foi confeccionado o programa.
OBJECT-COMPUTER: identifica o computador do ambiente de produção.
SPECIAL-NAMES: específica o sinal monetário, escolhe o tipo de ponto decimal, específica

caracteres simbólicos e possibilitar adaptar o programa para se comunicar com programas de
outras linguagens.
Têm comandos pré-definidos em Cobol, para especificar alfabeto, moeda, ou separador

de decimal (virgula ou ponto), mas todos os comandos são opcionais. O separador de decimais é
usado mais freqüentemente.
Formato:
SPECIAL-NAMES.
DECIMAL-POINT IS COMMA.
Esta instrução informa que a vírgula (COMMA) será usada como separador de
decimais.DECIMAL-POINT IS COMMA deve estar na área B.

14
COBOL
3.4 INPUT-OUTPUT SECTION

Esta seção destina-se a declaração dos arquivos de entrada e saída que será utilizado pelo
programa.
Formato:

15
COBOL
3.5 DATA DIVISION
A DATA DIVISION é a divisão do programa onde são descritos os layouts ou mapeamento

dos registros de dados, incluindo as variáveis e constantes necessárias. A DATA DIVISION é
composta pelas Sessões: FILE SECTION, WORKING-STORAGE SECTION e LINKAGE
SECTION.
FILE SECTION
A FILE SECTION é usada para detalhar o conteúdo dos registros dos arquivos, utilizando-
se da FILE DESCRIPTION (FD) que descreve as características do arquivo, que possuem alguns
parâmetros importantes e o mapeamento dos campos do registro.
Formato:
Para todo arquivo declarado no INPUT-OUTPUT SECTION, é necessário haver uma descrição e
um layout do mesmo na FILE SECTION.

16
COBOL
WORKING-STORAGE SECTION
NA WORKING-STORAGE SECTION onde são definidas todas as variáveis que o

programa irá utilizar. Não há parágrafos e os dados podem ser definidos como grupos hierárquicos
ou independentes (níveis 01 a 49), ou dados independentes (nível 77) em qualquer ordem, desde
que não se crie um nível 77 no meio de uma hierarquia de níveis causando seu rompimento.
Formato:
PROCEDURE DIVISION
Nesta divisão é onde serão codificados os comandos necessários para a execução do

programa. As instruções de um programa COBOL podem ser reunidas em parágrafos, definidos
pelo programador com o fim de tornar o programa mais fácil de ser entendido. Os comandos
podem ser verbos, ações ou tomadas de decisão.

17
COBOL
4 ESPECIFICAÇÃO PARA DADOS OU VÁRIAVEIS

A definição de um dado em COBOL é feito com o seguinte formato:
Nível identificador-1 Formato Valor-inicial
NÍVEL
Os números de níveis definem a hierarquia dos campos dentro dos registros ou a
hierarquia nas áreas auxiliares criadas pelo programador. O registro também deve ser numerado,
pois ele é um item de grupo, A numeração para itens de grupo é “01”, por definição todos os itens
de grupo serão itens alfanuméricos.
Dentro dos itens de grupo estão os itens elementares, e estes podem receber uma
numeração entre “02 e “49”.
Exemplo:
Os níveis de 50 a 99 tem uso específico, ou reservados para futuras expansões do Cobol.

Nesta faixa há um nível de uso muito freqüente.

18
COBOL
Número de Níveis Especiais 77 e 88
O nível 77 define áreas auxiliares independentes, onde estes não são subdivididos, são
usados para contadores, acumuladores e indexadores.
O nível 88 define nomes de condições que devem ser associados à valores definidos ao
conteúdo de um determinado campo, pois podemos associar um valor a um nome fantasia.
Nota:
Podemos fazer a pergunta pelo campo WK-ESTADO CIVIL , SOLTEIRO ou CASADO,
IF WK-ESTADO-CIVIL = 1
DISPLAY „SOLTEIRO‟
END-IF
Ou
IF CASADO
DISPLAY „2‟
END-IF
NOME-DO-DADO (identificador)
Podemos usar qualquer palavra que não seja usada internamente no COBOL (palavra
reservada). Esta palavra pode ter no máximo 30 caracteres, incluindo letras, números e hífen,
sendo que pelo menos um dos caracteres deve ser uma letra.
Exemplo:
77 WK-CAMPO-01-ATUAL
FILLER: Palavra reservada que preenche determinados espaços definidos na Picture, sendo que
não temos acesso ao item elementar, somente quando manipulamos o item de grupo à que ele
esteja subordinado. Eles são usados freqüentemente para não poluirmos o programa fonte com
nomes desnecessários de variáveis.
Exemplo:
01 WK-CAMPO-ATUAL.
03 FILLER
03 WK-CAMPO-01.

19
COBOL
FORMATOS DA PICTURE:
A – O dado é alfabético e contém somente letras e espaços.

9 – O dado é numérico e contém somente números.
X – O dado é alfanumérico e pode conter letras, números e outros caracteres especiais.
A definição de um dado em COBOL tem o seguinte formato:
Nível Nome-do-dado Formato Valor-inicial

02 SOMA-CREDITOS PIC 9(6)V99 VALUE ZEROS.
Em memória este dado ficará assim:
1 2 3 4 5 6 7 8
Neste exemplo, o dado conterá 6 bytes inteiros e dois bytes decimais.
Quando usamos a cláusula de valor inicial (VALUE), no momento que esta variável é carregada
em memória, o dado ficará assim:
0 0 0 0 0 0 0 0
A quantidade de caracteres contidos no dado é especificada no formato, podendo repetir a

característica do formato, que representará a quantidade. Porém isto só é válido para formatos
numéricos.
Por exemplo, se o item QUANT-PROD tem 5 algarismos, seu formato será:
01 QUANT-PROD PIC 99999.
Pode-se abreviar esta repetição colocando o número de repetições entre parênteses:
01 QUANT-PROD PIC 9(5).
Em uma variável numérica armazenada na memória, não existe o ponto e nem a vírgula decimal.
Se o item VALOR-PROD tiver, por exemplo, o valor de 2,35 fica na memória como 235. Mas o
programa COBOL precisa saber em que posição estava a vírgula que desapareceu (vírgula
implícita). A vírgula implícita é definida no formato pela letra V, como abaixo:
01 VALOR-PROD PIC 99999V99.

Ou
01 VALOR-PROD PIC 9(5)V99.

20
COBOL
Em um grupo de itens contidos em uma hierarquia (com níveis de 01 a 49) só podem ter a
cláusula PIC, os itens no nível mais baixo da hierarquia (itens elementares).
Exemplo:
A linguagem COBOL suporta itens numéricos com até 18 algarismos, e itens alfanuméricos até
32.768 caracteres (dependendo do sistema operacional).
Existem ainda formatos especiais da PIC para itens a serem exibidos ou impressos, chamados de
mascaras de edição.
A cláusula PICTURE (ou PIC) tem alguns formatos próprios para fazer edição de variáveis
numéricas no momento de uma impressão que são mostrados na tabela abaixo:
PICTURE VALUE IMPRESSÃO

$ZZZZ9,99 2 $ 2,00
$$$$$9,99 2 $2,00
$****9,99 2 $*****2,00
+ZZZZ9,99 -2 - 2,00
--------9,99 -2 -2,00
++++9,99 -2 -2,00
++++9,99 +2 +2,00
ZZ.ZZ9,99+ -2002 2.002,00-
BLANK WHEN ZERO
Esta cláusula, usada após a máscara de edição da PICTURE, envia espaços em branco para a
impressora quando a variável numérica a ser impressa tem valor zero, independente do formato
da máscara.
Exemplo:
03 VALOR PIC ZZ.ZZ9,99 BLANK WHEN ZERO.

21
COBOL
VALUE - VALOR INICIAL
Esta cláusula é opcional em COBOL. Seu objetivo é definir um valor para a variável. Se ela for
omitida, o item correspondente terá valores imprevisíveis. No caso de uma variável numérica, por
exemplo, é conveniente que ele comece com o valor zero. O valor-inicial é definido no COBOL
pelo formato:
Em COBOL existem 2 tipos de literais: numérica e alfa-numérica.
As literais numéricas são escritas colocando-se o valor na instrução, sem apóstrofe ou aspas.
Exemplo:
77 IDADE-MINIMA PIC 99 VALUE 18.

77 IDADE-MAXIMA PIC 9(2) VALUE ZEROS.
As literais alfanuméricas devem ser colocados entre apostrofes („) ou aspas (“).
Exemplo:
77 NOME-RUA PIC X(20) VALUE „RUA FIDALGA‟.
Não se pode misturar em um programa COBOL o uso de apóstrofes com aspas, ou seja, se uma
literal começou a ser escrito com apóstrofe, deve-se usar apóstrofe para terminar a literal.
Pode-se usar ainda como valor-inicial as CONSTANTES FIGURATIVAS, como por exemplo,
ZEROS, SPACES, LOW-VALUES ou HIGH-VALUES.
ZEROS|ZERO|ZEROES – O item (deve ser numérico) será preenchido com algarismos 0 (zero).
SPACE|SPACES – O item (deve ser alfabético ou alfa-numérico) será preenchido com espaços.
LOW-VALUE|LOW-VALUES – (menor valor) Indica que este item na memória deve ter todos os
seus bytes com todos os bits desligados.
HIGH-VALUE|HIGH-VALUES - (maior valor) Indica que este item na memória deve ter todos os
seus bytes com todos os bits ligados.
Exemplo:
77 TOTAL PIC 9(10) VALUE ZEROS.

22
COBOL
5 COMANDOS
5.1 ACCEPT RECEBENDO DADOS DO SISTEMA
O comando ACCEPT recebe uma informação de dados, dependendo das cláusulas que
completam o comando, que podem ser: ESTRUTURA DE DADOS, DATA DO SISTEMA, DIAS
DO ANO, DIA DA SEMANA e TEMPO.
Esta opção recebe uma área de dados da SYSIN do JOB de execução do programa, e
NÃO recebe dados digitados na tela, devemos assinalar uma área de entrada no JCL.
É importante lembrar que todo parâmetro SYSIN, passado via JCL, possui uma limitação
de tamanho, que é de 72 bytes.
Para que o programa possa receber estes dados, não basta apenas codificar o comando
ACCEPT, temos que codificar uma variável na WORKING-STORAGE.
Exemplo:
Obs.: Quando a opção FROM SYSIN é omitida o default FROM SYSIN é assumido.

23
COBOL
Regras:
 SYSIN
Cada vez que o programa COBOL executa a instrução ACCEPT, uma linha da SYSIN do
JCL é carregada na variável. É necessário prever com cuidado quantas linhas terá a SYSIN do
JCL, porque se o comando ACCEPT não encontrar uma linha para carregar na sua variável, o
sistema operacional emitirá uma mensagem de erro para o operador e o programa ficará
suspenso até a intervenção do operador.
 DATE Formato implícito PIC 9(06)

Formato YYMMDD- data gregoriana
20/12/2009 será expresso como 091220
 DAY Formato implícito PIC 9(05)

Formato YYDDD- data Juliana
04/07/1981 será expresso como 81185
 DAY-OF-WEEK
Formato implícito PIC 9(1), onde:

1 = Monday,
2 = Tuesday,
3 = Wednesday,
4 = Thursday,
5 = Friday,
6 = Saturday,
7 = Sunday.
 TIME Formato implícito PIC 9(08)
Formato HHMMSSCC – Hora, minuto, segundo, centésimos.
2:41 da tarde será expresso como 14410000

24
COBOL
5.2 DISPLAY
Exibe o conteúdo de uma variável podendo ser concatenada com uma literal, o conteúdo da
variável será exibido num dispositivo de saída.
Exemplos:
5.3 STOP RUN
A instrução STOP RUN encerra a execução do programa.
Formato:
STOP RUN.

25
COBOL
6 Comandos Aritméticos
As instruções para efetuar cálculos aritméticos em COBOL são:
ADD(Adição)
SUBTRACT(subtração)
MULTIPLY(multiplicação)
DIVIDE(divisão)
COMPUTE(calcular)
Todas as instruções aritméticas podem ser completadas com as opções
ROUNDED ou ON SIZE ERROR.
Formato básico para instruções aritméticas:
Instrução aritmética
[ ROUNDED ]
[ [NOT] ON SIZE ERROR instrução imperativa … ]
[END-{nome-da-instrução}]
6.1 Opção ROUNDED

Usa-se a opção ROUNDED quando se operam com números decimais e existe perda de
algarismos no resultado. Para obter resultados arredondados, a opção ROUNDED pode ser
especificada em qualquer instrução aritmética. Em todos os casos, ela vem imediatamente após o
nome do operando resultante. O COBOL faz um arredondamento clássico para o resultado da
instrução aritmética (valores perdidos menores que 5nn.. são truncados, e os maiores são
arredondados para cima). Exemplo: ADD WS-VALOR1 TO WS-VALOR2 ROUNDED
6.2 Opção ON SIZE ERROR

Quando a variável que recebe o resultado da operação aritmética não tem tamanho
suficiente para conter o resultado, o COBOL trunca o valor resultante (o valor perde algarismos à
esquerda), e o COBOL não emite avisos ou código de erro. Para que se possa detectar esta
situação é necessário codificar na instrução aritmética a clausula ON SIZE ERROR, onde
podemos colocar uma mensagem de erro, parar o programa ou desviar para um parágrafo
especial de tratamento de erro.
Exemplo:
ADD VALOR-1 TO VALOR-2

ON SIZE ERROR
DISPLAY „ESTOUROU O CAMPO DE RESULTADO‟
MOVE “S” TO WS-ESTOURO
END-ADD.

26
COBOL
6.3 Opção END-… (Delimitador de escopo)

Utilizado como delimitador em todas as instruções aritméticas do COBOL
ADD VALOR-1 TO VALOR-3

ON SIZE ERROR
DISPLAY „ESTOUROU O CAMPO DE RESULTADO‟
MOVE “S” TO WS-ESTOURO
END-ADD.
ADD
Acumula dois ou mais operandos numéricos e armazena resultados.
Formato:
ADD { identificador-1 ... constante-1 ...} TO | GIVING
{ identificador-de-resultado ... }
Regras:
1. Todos os campos e constantes que são parte da adição devem ser numéricos. Após a palavra
GIVING, contudo, o campo pode ser um campo editado (campo numérico com mascara de
edição).
2. O campo identificador-de-resultado, após TO ou GIVING, deve ser um nome de dados, e não

uma constante.
3. Pelo menos dois operandos deverão anteceder a palavra GIVING.
4. Ao usar TO, o conteúdo inicial do identificador-de-resultado, que deve ser numérico, é somado
junto ao dos outros campos (identificador-1 ... constante-1...).
5. Ao usar o formato GIVING, o campo identificador-de-resultado receberá a soma, mas seu

conteúdo inicial não será parte da instrução ADD. Ele pode ser tanto um campo numérico como
um campo editado.
Exemplos:
ADD WS-VALOR TO WS-AC-TOTAL.
 Efetua: WS-AC-TOTAL = WS-AC-TOTAL + WS-VALOR.
ADD WS-VALOR TO WS-AC-TOTAL1

WS-AC-TOTAL2.
 Efetua: WS-AC-TOTAL1 = WS-AC-TOTAL1 + WS-VALOR.
 Efetua: WS-AC-TOTAL2 = WS-AC-TOTAL2 + WS-VALOR.
ADD WS-AC-TOTAL1
WS-AC-TOTAL2
WS-AC-TOTAL3 TO WS-AC-TOTGERAL.
 Efetua: WS-AC-TOTGERAL = WS-AC-TOTGERAL +

WS-AC-TOTAL1 + WS-AC-TOTAL2 + WS-AC-TOTAL3.
ADD WS-VALOR1 WS-VALOR2 GIVING WS-AC-VALOR.

 Efetua: WS-AC-VALOR = WS-VALOR1 + WS-VALOR2.

27
COBOL
SUBTRACT
Subtrai um ou mais operandos numéricos e armazena resultados.
Formato 1:
SUBTRACT { identificador-1 ... constante-1 ...}

FROM identificador-de-resultado1 …
Formato 2:
SUBTRACT { identificador-1 ... constante-1 ...}

FROM identificador-2|constante-2
GIVING identificador-de-resultado1 ...
Regras:
1. No Formato 1, o conjunto de operandos identificador-1... constante-1, são subtraídos de

identificador de resultado1...
2. No Formato 2, o identificador de resultado1, armazenará o resultado de identificador-2

constante-2 subtraídos de identificador-1... constante-1...
3. Com o Formato 2, pode vir qualquer número de operandos imediatamente após a palavra
SUBTRACT ou a palavra GIVING, mas depois da palavra FROM é permitido um único
identificador ou constante.
4. Todas as constantes e campos que são parte da instrução SUBTRACT devem ser
numéricos. Depois da palavra GIVING, contudo, o campo pode ser um campo numérico editado.
5. O campo identificador de resultado1, após FROM ou GIVING, deve ser um nome de variável
e não uma constante.
6. Ao usar o formato GIVING, o campo identificador de resultado1 receberá o resultado da
subtração, mas seu conteúdo inicial não será considerado, ou seja, sobreposto. Ele pode ser tanto
um campo numérico como um campo numérico editado.
Exemplos:
SUBTRACT VL-CHEQUE FROM SALDO.
 Efetua: SALDO = SALDO – VL-CHEQUE.
SUBTRACT VL-CHEQUE FROM SALDO GIVING SALDO-ATUAL
 Efetua: SALDO-ATUAL = SALDO – VL-CHEQUE.
SUBTRACT TAXA FROM 100 GIVING COMPLEMENTO
 Efetua: COMPLEMENTO = 100 – TAXA.

28
COBOL
DIVIDE
Efetua uma divisão, disponibilizando o quociente e, se indicado, o resto.
Formato 1:
DIVIDE {identificador-1|constante-1} INTO
{identificador-2|constante-2}
[ GIVING identificador-de-resultado …]
[ REMAINDER identificador-de-resto ]
Formato 2:
DIVIDE {identificador-1|constante-1} BY
GIVING identificador-de-resultado ...
[ REMAINDER identificador-de-resto ]
Regras:
1. Observar que GIVING é opcional com INTO, mas obrigatório com BY.
2. No Formato 1, identificador-2 ou constante-2 é o dividendo e identificador-1 ou constante-1 é

o divisor. Se a opção GIVING não for utilizada, o resultado fica em identificador-2(dividendo).
3. No Formato-1, se a opção GIVING não for utilizada, o dividendo terá de ser identificador-
2(não poderá ser usado constante-2).
4. No formato 2, identificador-1 ou constante-1 é o dividendo e identificador-2 ou constante-2 é

o divisor.
5. A opção REMAINDER é utilizada quando se faz necessário guardar o resto da divisão em

outro identificador. Neste caso, a Picture da variável utilizada como resultado não poderá ter casas
decimais.
Exemplos:
DIVIDE 2 INTO WS-NUMERO
 Efetua WS-NUMERO = WS-NUMERO / 2
DIVIDE WS-VL-DOLAR INTO WS-VL-REAIS

GIVING WS-RESULT
 Efetua WS-RESULT = WS-VL-REAIS / WS-VL-DOLAR
DIVIDE WS-NUM BY 2
GIVING WS-RESULT
REMAINDER WS-RESTO
 Efetua WS-RESULT = WS-NUM / 2 (resto em WS-RESTO)

29
COBOL
MULTIPLY
Efetua a multiplicação entre variáveis.
Formato:
MULTIPLY {identificador-1|constante-1} BY
[ [GIVING identificador-de-resultado1 ...]
[END-MULTIPLY] ]
Regras:
1. Observe a colocação das reticências (...). O resultado será armazenado em todos os

identificadores de resultado após GIVING.
2. Se a opção GIVING não for utilizada, o resultado irá para identificador-2, e neste caso não
poderá ser usado constante-2.
Exemplos:
MULTIPLY 2 BY VALOR ROUNDED
 Efetua VALOR = 2 * VALOR (com arredondamento)
MULTIPLY VALOR BY 2 GIVING DOBRO
 Efetua DOBRO = VALOR * 2
MULTIPLY 2 BY VALOR GIVING DOBRO
Efetua DOBRO = 2 * VALOR

30
COBOL
COMPUTE
Com a instrução COMPUTE, as operações aritméticas podem ser combinadas em fórmulas sem
as restrições impostas para o campo receptor quando é usado ADD, SUBTRACT, MULTIPLY e
DIVIDE. Quando as operações aritméticas são combinadas, a instrução COMPUTE é mais
eficiente que as instruções aritméticas escritas em série.
Formato:
COMPUTE identificador-de-resultado [ROUNDED] =

formula-aritmética
[ [NOT] ON SIZE ERROR instrução-imperativa]
Regras:
1. A opção ROUNDED e ON SIZE ERROR segue a mesma regra utilizada para expressões
aritméticas.
2. Os símbolos que podem ser utilizados em uma instrução COMPUTE, conforme sua ordem de
prioridade de execução, são:
( ) Parênteses
** Exponenciação
* Multiplicação
/ Divisão
+ Adição
- Subtração
3. O sinal de igual, assim como os símbolos aritméticos, devem ser precedidos e seguidos de um
espaço. Assim, para calcular B+C+D**2 e colocar o resultado em A, use a seguinte instrução:
COMPUTE A = B + C + D ** 2. Na abertura e fechamento de parênteses não é obrigatório o
uso de espaço.
4. A ordem em que são executadas as operações em uma expressão aritmética que contenha
mais de um operador segue a seguinte prioridade:
1 º ( ) Expressões dentro de parênteses
2 º Exponenciação
3 º Multiplicação, divisão
4 º Adições e Subtrações
 Quando houver operadores de mesma prioridade, eles serão executados da esquerda

para a direita.
Exemplos:
COMPUTE WS-RESULT ROUNDED = (AA + BB) / CC

COMPUTE WS-RESULT = (((AA + BB) / CC) / DD) * (EE ** 2)
A fórmula A = B² + C²
ficará em Cobol da seguinte forma:
COMPUTE A = (B ** 2 + C ** 2) ** (0,5).

31
COBOL
Vamos relembrar no capítulo de lógica, o algoritmo para calcular a média de um aluno.

Abaixo está demonstrada a solução em COBOL:
IDENTIFICATION DIVISION.
PROGRAM-ID. ALUNO01.
* PROGRAMA - CALCULAR A MEDIA DE 4 NOTAS
DATA DIVISION.
WORKING-STORAGE SECTION.
01 N1 PIC 99 VALUE ZERO.

01 N2 PIC 99 VALUE ZEROES. (isso existe !!!)
01 N3 PIC 9(02) VALUE 0.
01 N4 PIC 9(02) VALUE 00.
77 MEDIA PIC 9(03) VALUE ZEROS.
PROCEDURE DIVISION.
ACCEPT N1 FROM SYSIN.
COMPUTE MEDIA = (N1 + N2 + N3 + N4) / 4.
DISPLAY '------------------'.
DISPLAY 'MEDIA => ' MEDIA.
DISPLAY '------------------'.
STOP RUN.

32
COBOL
7 Estrutura Lógica - Decisão
7.1 Comandos de Decisão
IF / ELSE / END-IF.
Formato:
IF CONDIÇÃO
instruções (para condição verdadeira)
[ELSE
instruções (para condição falsa)
END–IF]
Regras:
 Se o teste da condição foi VERDADEIRO, o bloco de instruções situado após o comando IF

será executado, até que se encontre um PONTO, um ELSE ou um END-IF.
 Se o teste da condição foi FALSO será executado o bloco de instruções situado após o ELSE,
até que se encontre um PONTO ou um END-IF. Não havendo ELSE dentro do contexto do
IF(conjunto de instruções terminadas por PONTO ou END-IF), não serão executadas
instruções para o teste de condição FALSO do IF.
 PONTO e END-IF indicam o fim da especificação da instrução IF. As instruções que estão
após o PONTO e o END-IF, portanto, são executadas tanto para os casos de condição
VERDADEIRO quanto para os casos de condição FALSO.
 CONDIÇÃO
Pode ser uma condição simples ou composta. As tabelas de operadores lógicos e relacionais
abaixo podem ser utilizadas para compor a condição a ser testada.

33
COBOL
7.2 Operadores Relacionais
Descrição Em COBOL
Igual = EQUAL
Diferente NOT = NOT EQUAL
Maior que > GREATER
Menor que < LESS
Maior ou igual a >= NOT LESS
Menor ou igual a <= NOT GREATER
7.3 Operadores Lógicos
Os operadores lógicos com exceção do NOT devem ser utilizados em condições compostas.
Os operadores lógicos são:
OPERADOR DESCRIÇÃO
"NÃO": NOT <condição VERDADEIRO> é
Not igual a FALSO e NOT <condição FALSO> é
igual a VERDADEIRO.
"E": Condições associadas com AND
And resultam VERDADEIRO quando todas forem
VERDADEIRO.
"OU": Condições associadas com OR
Or resultam VERDADEIRO bastando apenas
uma delas ser VERDADEIRO.
Categorias Notação alternativa

Teste de sinal IS POSITIVE
IS NEGATIVE
Teste de classe IS NUMERIC
IS ALPHABETIC

34
COBOL
Exemplos:
Suponha que temos três variáveis A = 5, B = 8 e C =1, os resultados das expressões seriam:
Expressões Resultado
A = B AND B > C Falso
A NOT = B OR B < C Verdadeiro
NOT (A > B) Verdadeiro
A < B AND B > C Verdadeiro
A >=B OR B = C Falso
NOT(A <= B) Falso
A tabela abaixo mostra todos os valores possíveis criados pelos três operadores lógicos (AND, OR
e NOT)
OPERADOR AND OPERADOR OR OPERADOR

(E) (OU) NOT (NÃO)
A B A AND B A B A OR B A NOT A
V V V V V V V F
V F F V F V F V
F V F F V V
F F F F F F

35
COBOL
7.4 CONTINUE OU NEXT SENTENCE

A instrução CONTINUE ou NEXT SENTENCE pode ser usada quando nada deve ser executado
no caso da instrução IF avaliar VERDADEIRO, ou quando nada deve ser executado após a
cláusula ELSE (condição FALSO).
Formato:
CONTINUE | NEXT SENTENCE
Exemplo: Exemplo 1: (IF SEM ELSE)

IF A > B IF WS-CAMPO1 EQUAL WS-CAMPO-2
PERFORM 10-00-PESQUISA
{ CONTINUE | NEXT SENTENCE }
END-IF.
ELSE
DISPLAY „A MENOR OU = B‟
END-IF.
DISPLAY “COMPARAÇÃO EFETUADA”.
Exemplo 2: (IF COM ELSE) Exemplo 3: (IF COM NEXT

SENTENCE)
IF WS-CAMPO1 < WS-CAMPO-2
ADD 1 TO WAC-CAMPO3 IF WS-CAMPO1 > WS-CAMPO-2
ELSE NEXT SENTENCE
COMPUTE WS-TOTAL = WS-VALOR1 + WS-VALOR2 ELSE
END-IF. ADD WS-CAMPO4 TO WS-TOTAL
END-IF.
Exemplo 4: (NINHOS DE IF COM CONTINUE)

IF WS-CAMPO1 = WS-CAMPO-2
MOVE “N” TO WS-CAMPO3
IF WS-CAMPO < WS-CAMPO4
ADD 1 TO WS-CAMPO
PERFORM 15-00-SITUAÇÃO1
END-IF
IF WS-CAMPO5 > WS-CAMPO6
ELSE
IF WS-CAMPO7 EQUAL “H”
CONTINUE
END-IF
END-IF
ELSE
END-IF.

36
COBOL
7.5 EVALUATE
Pode ser utilizado em substituição de ninhos de IF‟s sobre uma única variável.
Na instrução EVALUATE, a comparação de faixa só pode ser feita com a claúsula THRU, não
podendo ser usados os operadores relacionais (=, <, >).
Formato:
EVALUATE variável
WHEN identificador-1 [THRU identificador-2 …]
Instrução- 1
[WHEN OTHER
Instrução- 2]
END-EVALUATE.
Exemplos:
Usando ninhos de IF‟s sobre uma única variável:
IF SIGLA-UF = „SP‟
DISPLAY 'SÃO PAULO'
ELSE
IF SIGLA-UF = „SC‟
DISPLAY 'SANTA CATARINA'
ELSE
IF SIGLA-UF = „RS‟
DISPLAY 'RIO GRANDE DO SUL'
ELSE
DISPLAY 'OUTRO ESTADO'
END-IF
END-IF
END-IF.
Usando EVALUATE para o mesmo propósito:

EVALUATE SIGLA-UF
WHEN 'SP' DISPLAY 'SÃO PAULO'
WHEN 'SC' DISPLAY 'SANTA CATARINA'
WHEN 'RS' DISPLAY 'RIO GRANDE DO SUL'
WHEN OTHER DISPLAY 'OUTRO ESTADO'
END-EVALUATE.
Usando EVALUATE com a cláusula THRU:

EVALUATE WS-SALDO
WHEN ZEROS THRU 10000 DISPLAY “CLIENTE COMUM”
WHEN 10001 THRU 20000 DISPLAY “CLIENTE ESPECIAL”
WHEN > 20000 DISPLAY “CLIENTE SUPER-ESPECIAL”
END-EVALUATE.

37
COBOL
8 Estrutura Lógica – Repetição
Toda estrutura de repetição envolve um teste de condição. De acordo com o resultado da

condição, VERDADEIRO ou FALSO, serão executadas instruções, sendo que uma delas deverá
configurar o teste de condição para o oposto do resultado verificado, se as instruções foram
executadas para VERDADEIRO, esta instrução deverá configurar a condição para FALSO e vice-
versa, sem a qual, esta estrutura entrará em looping. Após a execução de todas as instruções,
será obrigatória uma instrução de desvio do fluxo lógico para este mesmo teste de condição.
Exemplo:
MOVE ZEROS TO ACUM.
TESTE.
IF ACUM = 10
STOP RUN
ELSE
ADD 1 TO ACUM
DISPLAY ACUM
GO TO TESTE
END-IF.
Programas bem projetados e estruturados são aqueles que possuem uma série de construções
lógicas, em que a ordem na qual as instruções são executadas é padronizada. Em programas
estruturados, cada conjunto de instruções que realiza uma função específica é definido em uma
rotina ou um parágrafo. Ele consiste em uma série de instruções relacionadas entre si e em
programação estruturada, os parágrafos são executados por meio da instrução PERFORM.

38
COBOL
8.1 PERFORM
A instrução PERFORM permite que o controle passe temporariamente para um parágrafo

diferente e depois retorne para o parágrafo original de onde a instrução PERFORM foi executada.
Há dois tipos de instrução PERFORM.
1. PERFORM OUT–LINE: Um parágrafo é especificado, ou seja, é dado um PERFORM em um

PARÁGRAFO ou SECTION.
2. PERFORM IN–LINE: As instruções acionadas estão logo abaixo do comando PERFORM.

Estas instruções devem ser delimitadas pelo comando END-PERFORM.
 Há 4 Formatos de PERFORM.
1. PERFORM básico
2. PERFORM com opção TIMES
3. PERFORM com opção UNTIL
4. PERFORM com opção VARYING
Formato 1 (básico):
PERFORM parágrafo [THRU parágrafo-fim]

A opção THRU é opcional e deve ser utilizada quando devem ser executados mais de um
parágrafo.
Este formato não é um comando de repetição, o parágrafo ou section são executados uma única
vez
Exemplo:
PERFORM INICIALIZAR.
PERFORM PROCESSAR THRU PROCESSAR-FIM.
Formato 2 (opção TIMES):
PERFORM parágrafo [THRU parágrafo-fim] N TIMES
O parágrafo referido é executado N TIMES, onde N pode ser uma constante ou variável numérica.
Exemplo: PERFORM com opção TIMES
20-00-CALCULA-TOTAL.
MOVE ZEROS TO WS-TOTAL
PERFORM 25-00-CALCULO 3 TIMES.
20-99-EXIT. EXIT.

39
COBOL
Formato 3 (opção UNTIL):
PERFORM parágrafo [THRU parágrafo-fim] UNTIL condição
O parágrafo referido é executado repetidamente até que a condição especificada pela opção
UNTIL seja verdadeira.
Exemplo 1: PERFORM com opção UNTIL
00-00-MAIN-LINE.
MOVE “N” TO WS-FIM .
PERFORM 10-00-INICIALIZAR.
PERFORM 20-00-LER-ARQUIVO.
PERFORM 30-00-PROCESSAR UNTIL WS-FIM = “S”.
PERFORM 40-00-FINALIZAR.
00-00-EXIT. EXIT.
Exemplo 2: PERFORM com opção UNTIL (IN-LINE)

PERFORM UNTIL WS-FIM = “S”
IF WS-LIN > 50
PERFORM 50-00-CABECALHO
END-IF
PERFORM 60-00-ROT-DETALHE
PERFORM 20-00-LER-ARQUIVO
END-PERFORM.
Formato 4 (opção VARYING):
PERFORM parágrafo [THRU parágrafo-fim] VARYING campo FROM n BY m UNTIL condição
Executa o parágrafo especificado, até que a condição especificada seja satisfeita. Antes de
executar o bloco de instruções pela primeira vez, atribui o valor N a variável CAMPO. Após cada
execução do bloco, antes de voltar a executá-lo, incrementa M à variável CAMPO.
Exemplo 1: PERFORM com opção VARYING

30-00-PROCESSAR.
PERFORM 50-00-ROT-CABECALHO.
PERFORM 60-00-ROT-DETALHE VARYING WS-LIN
FROM 1 BY 1 UNTIL WS-LIN = 60.
...
60-00-ROT-DETALHE.
PERFORM 70-00-IMPRIMIR-DETALHE.
PERFORM 20-00-LER-ARQUIVO.

40
COBOL
9 Lógica Estruturada
Programação Estruturada é o resultado de um trabalho da IBM com o objetivo de padronizar as

estruturas lógicas de programas.
Uma das premissas é que todo programa tem procedimentos iniciais, procedimentos repetitivos
controlados por condições simples ou compostos e procedimentos finais.
Outra premissa descreve que é muito mais fácil dividir um problema em partes (módulos)
logicamente conectadas entre si e desenvolver cada parte isoladamente do que resolver o
problema como um todo.
Uma terceira premissa é a de eliminar comandos de desvio do fluxo lógico de execução (GO TO),
substituindo-os por comandos de execução de módulos (PERFORM).
Baseado na primeira premissa, os três primeiros comandos de um programa COBOL são:
PERFORM INICIO.
PERFORM PROCESSAR UNTIL <condição>.
PERFORM FINALIZA.
Estes três comandos constituem o módulo principal do programa e controlam o fluxo de execução
do mesmo.

41
COBOL
Exemplo:
__________________________________________________________
* PROGRAMA - MAIOR E MENOR NUMERO
__________________________________________________________
PROGRAM-ID. ALUNO01.
AUTHOR. ALUNO.
*
DATA DIVISION.
01 WS-NUMERO PIC 9(03) VALUE ZEROS.
01 WS-MAIOR PIC 9(03) VALUE ZEROS.
01 WS-MENOR PIC 9(03) VALUE 999.
*
PROCEDURE DIVISION.
*
PRINCIPAL.
PERFORM INICIO.
PERFORM PROCESSA UNTIL WS-NUMERO EQUAL ZEROS.
PERFORM FINALIZA.
STOP RUN.
*
INICIO.
DISPLAY ' INICIO DO PROCESSAMENTO '.
ACCEPT WS-NUMERO FROM SYSIN.
*
PROCESSA.
DISPLAY 'O NUMERO EH => ' WS-NUMERO.
PERFORM MAIOR-MENOR.
ACCEPT WS-NUMERO FROM SYSIN.
*
MAIOR-MENOR.
IF WS-NUMERO GREATER WS-MAIOR
MOVE WS-NUMERO TO WS-MAIOR
END-IF.
IF WS-NUMERO LESS WS-MENOR
MOVE WS-NUMERO TO WS-MENOR
END-IF.
*
FINALIZA.
DISPLAY ' TERMINO DO PROCESSAMENTO '.
DISPLAY 'O MAIOR NUMERO EH => ' WS-MAIOR.
DISPLAY 'O MENOR NUMERO EH => ' WS-MENOR.

42
COBOL
10 Arquivos Seqüenciais
Arquivo é um meio de armazenar informações que foram processadas e que poderão ser
utilizadas novamente. Para isso precisamos relembrar os conceitos aplicados no módulo de lógica.
Vamos rever !!!!
10.1 Conceitos Básicos
ARQUIVO é um conjunto de registros armazenados de forma seqüencial.

Exemplo: O arquivo de Clientes da Empresa, onde estão armazenados os dados de todos os
clientes da empresa.
Registro 1
Registro2
REGISTRO é um conjunto de campos.
Exemplo: Registro de Clientes (definem uma ocorrência da entidade Cliente).
COD-CLI NOME ENDEREÇO FONE

00001 MARIA DAS GRAÇAS RUA DAS DORES,1400 9888-9876
CAMPO é a menor parte da informação em memória.

Exemplo: Campo Nome, Campo Endereço
Nome
Maria das Graças
Os arquivos estudados neste modulo são arquivos seqüenciais utilizados para processamento
BATCH. Os arquivos seqüenciais devem estar ordenados por um campo-chave afim de serem
processados.
Os arquivos seqüenciais podem ser armazenados em disco ou fita magnética. Um arquivo

seqüencial não admite leitura direta de um registro, regravação e exclusão de um registro.

43
COBOL
11 COMANDOS PARA PROCESSAMENTO DE ARQUIVOS SEQUENCIAIS
Regras:
 Os arquivos devem ser declarados na INPUT-OUTPUT SECTION (ENVIRONMENT

DIVISION), com a instrução SELECT.
 O conteúdo do arquivo deve ser descrito na FILE SECTION (DATA DIVISION) com a
clausura FD e definição do(s) registro(s) em nível 01.
 Na PROCEDURE DIVISION é necessário escrever instruções para gravar ou ler estes
arquivos.

44
COBOL
11.1 ENVIRONMENT DIVISION - INPUT-OUTPUT SECTION
Esta seção destina-se a declarar os arquivos que o programa usa.

 FILE-CONTROL – Cláusula SELECT
No parágrafo FILE-CONTROL, usado para definir arquivos, usamos uma instrução SELECT para
declarar cada um dos arquivos usados pelo programa.
Formato:
SELECT nome-arquivo-lógico ASSIGN TO nome-arquivo-fisico.
Nome-arquivo-logico.
É o nome do arquivo que será usado dentro do programa, pode ser diferente do nome físico e
pode ter até 30 caracteres.
Nome-arquivo-fisico.
O nome externo pode ter no máximo 8 caracteres e será usado no JOB no tipo de cartão DD, para
associá-lo a um arquivo físico, chamado de DDNAME.
Exemplo:
//DDNAME DD DSN= Nome do Arquivo Físico
No exemplo abaixo mostramos a ENVIRONMENT DIVISION de um programa que irá acessar um
arquivo CLIENTES.
Neste exemplo escolhemos como nome-arquivo-lógico dentro da instrução SELECT a palavra

CLIENTES. CLIENTES será usado em todos os comandos do programa como referência para
este arquivo.

45
COBOL
11.2 DATA DIVISION - FILE SECTION
A FILE SECTION é a Section usada para detalhar o arquivo e o conteúdo dos registros dos
arquivos que o programa irá ler/gravar. Vimos anteriormente, na INPUT-OUTPUT SECTION
(ENVIRONMENT DIVISION), que para cada arquivo a ser tratado no programa havia uma
instrução SELECT especificando e definindo um nome lógico para o arquivo. Na FILE SECTION
precisamos agora detalhar cada um destes arquivos. Isto é feito usando a clausula FD (FILE
DESCRIPTION).
FD (FILE DESCRIPTION)
FD nome-do-arquivo.
01 nome-do-registro. ...
[03 nome-de-campo ...]
Exemplo:

46
COBOL
12 Fluxograma
O fluxograma é a representação gráfica do programa e os arquivos que serão processados pelo

mesmo, sem desenvolver a lógica do programa.
Estes dois exemplos de fluxograma dão uma visão geral dos arquivos envolvidos em cada um dos
programas. O primeiro diz que haverá um arquivo de entrada que será usado para leitura, um
processamento principal e um arquivo de saída que será usado para gravação. Já o segundo
exemplo diz que haverá um arquivo de leitura, um processamento, e a saída será gerado um
relatório.
1º Exemplo 2º Exemplo
ARQUIVO
DE ARQUIVO
ENTRAD CLIENTE
A
PROGRAMA PROGRAMA
ARQUIVO
DE RELATÓRIO
SAÍDA

47
COBOL
ID DIVISION.
PROGRAM-ID. EXEMPLO.
AUTHOR. ALUNO.
*=============================================================
*OBJETIVO: LER UM ARQUIVO SEQUENCIAL E GRAVAR INFORMACOES EM
* UM ARQUIVO DE SAIDA
*=============================================================
ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
SPECIAL-NAMES.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT ARQENT ASSIGN TO ARQENT
FILE STATUS IS WS-FS-ARQENT.
SELECT ARQSAI ASSIGN TO ARQSAI

FILE STATUS IS WS-FS-ARQSAI.
*=============================================================
DATA DIVISION.
FILE SECTION.
FD ARQENT
BLOCK CONTAINS 0 RECORDS
RECORD CONTAINS 100 CHARACTERS
LABEL RECORD IS STANDARD
RECORDING MODE IS F.
01 REG-ARQENT.
02 ARQENT-NOME PIC X(20).
02 ARQENT-ENDERECO PIC X(30).
02 ARQENT-TELEFONE PIC X(09).
02 ARQENT-CODIGO PIC 9(06).
02 ARQENT-IDADE PIC 9(03).
02 FILLER PIC X(32).
FD ARQSAI
01 REG-ARQSAI.
02 ARQSAI-NOME PIC X(20).
02 ARQSAI-ENDERECO PIC X(30).
02 ARQSAI-TELEFONE PIC X(09).
02 ARQSAI-CODIGO PIC 9(06).
02 ARQSAI-IDADE PIC 9(03).
02 FILLER PIC X(82).
*=============================================================
77 WS-FS-ARQENT PIC 9(02) VALUE ZEROS.
77 WS-FS-ARQSAI PIC 9(02) VALUE ZEROS.
77 WS-CONT-LIDOS PIC 9(05) VALUE ZEROS.
77 WS-CONT-GRAVA PIC 9(05) VALUE ZEROS.
*=============================================================
PROCEDURE DIVISION.
ROT-MESTRE SECTION.
48
COBOL
PERFORM INICIO THRU INICIO-FIM.

PERFORM PROCESSA THRU PROCESSA-FIM UNTIL
WS-FS-ARQENT = 10.
PERFORM FINALIZA THRU FINALIZA-FIM.
STOP RUN.
ROT-MESTRE-FIM.
EXIT.
*=============================================================
* ROTINA DE ABERTURA DOS ARQUIVOS *
*=============================================================
INICIO SECTION.
OPEN INPUT ARQENT.

IF WS-FS-ARQENT NOT EQUAL ZEROS
DISPLAY '======================================='
DISPLAY ' ERRO NO OPEN DO ARQUIVO ARQENT '
DISPLAY ' FILE STATUS = ' WS-FS-ARQENT
DISPLAY '======================================='
STOP RUN.
OPEN OUTPUT ARQSAI.

IF WS-FS-ARQSAI NOT EQUAL ZEROS
DISPLAY '======================================='
DISPLAY ' ERRO NO OPEN DO ARQUIVO ARQSAI '
DISPLAY ' FILE STATUS = ' WS-FS-ARQSAI
DISPLAY '======================================='
STOP RUN.
PERFORM LER-ARQENT THRU LER-FIM.
INICIO-FIM.
EXIT.
*===============================1==============================
* ROTINA DE LEITURA DO ARQUIVO DE ENTRADA *
*=============================================================
LER-ARQENT SECTION.
READ ARQENT.
IF WS-FS-ARQENT NOT EQUAL ZEROS AND 10

DISPLAY '======================================='
DISPLAY ' ERRO NO READ DO ARQUIVO ARQENT '
DISPLAY '======================================='
STOP RUN.
ADD 1 TO WS-CONT-LIDOS.
LER-FIM.
EXIT.

49
COBOL
*=============================================================
* ROTINA DE PROCESSAMENTO *
*=============================================================
PROCESSA SECTION.
INITIALIZE REG-ARQSAI.
MOVE ARQENT-NOME TO ARQSAI-NOME.
MOVE ARQENT-ENDERECO TO ARQSAI-ENDERECO.
MOVE ARQENT-TELEFONE TO ARQSAI-TELEFONE.
MOVE ARQENT-CODIGO TO ARQSAI-CODIGO.
MOVE ARQENT-IDADE TO ARQSAI-IDADE.
PERFORM GRAVA-SAIDA THRU GRAVA-SAIDA-FIM.

PERFORM LER-ARQENT THRU LER-FIM.
PROCESSA-FIM.
EXIT.
*=============================================================
* ROTINA DE GRAVACAO DO ARQUIVO DE SAIDA *
*=============================================================
GRAVA-SAIDA SECTION.
WRITE REG-ARQSAI.

DISPLAY '======================================='
DISPLAY ' ERRO NA GRAVACAO DO ARQSAI '
DISPLAY '======================================='
STOP RUN.
ADD 1 TO WS-CONT-GRAVA.
GRAVA-SAIDA-FIM.
EXIT.
*=============================================================
* ROTINA DE FINALIZACAO E FECHAMENTO DOS ARQUIVOS *
*=============================================================
FINALIZA SECTION.
CLOSE ARQENT.
DISPLAY '======================================='
DISPLAY ' ERRO NO CLOSE DO ARQUIVO ARQENT '
DISPLAY '======================================='
STOP RUN.
CLOSE ARQSAI.
DISPLAY '======================================='
DISPLAY ' ERRO NO CLOSE DO ARQUIVO ARQSAI '
DISPLAY '======================================='
STOP RUN.

50
COBOL
DISPLAY '================================================='
DISPLAY 'QTDE. REG. LIDOS NO ARQENT = ' WS-CONT-LIDOS
DISPLAY 'QTDE. REG. GRAVADOS NO ARQSAI = ' WS-CONT-GRAVA
DISPLAY '================================================='
FINALIZA-FIM.
EXIT.

51
COBOL
13 Abertura de Arquivos
A linguagem COBOL exige que todo arquivo antes do processamento de leitura, seja aberto como
entrada e que todo arquivo, antes da gravação de seus registros, seja aberto como saída.
OPEN
Todo arquivo antes de ser processado deve ser aberto pelo comando OPEN. Este comando abre
o contato com o dispositivo físico do arquivo e reserva, na memória (WORKING-STORAGE
SECTION), áreas necessárias para a troca de dados entre o computador e o dispositivo
externo. Indica quais arquivos serão de entrada e quais serão de saída.
Formato:
OPEN [INPUT | OUTPUT ] Nome-arquivo1 ...
Regras:
1. INPUT: Permite abrir o arquivo apenas para operações de leitura.
2. OUTPUT: Permite abrir o arquivo para operações de gravação. Esta operação pode ser
especificada quando o arquivo estiver sendo criado. Esta opção não permite comandos de leitura
no arquivo.
3. NOME-Arquivo1 ... : Nome lógico do(s) arquivo(s) definido(s) na clausula SELECT e na FD:
4. Teste de file status é obrigatório.
Exemplo:
*=============================================================
* ROTINA DE ABERTURA DOS ARQUIVOS *
*=============================================================
INICIO SECTION.
OPEN INPUT ARQENT.

DISPLAY '======================================='
DISPLAY ' ERRO NO OPEN DO ARQUIVO ARQENT '
DISPLAY '======================================='
STOP RUN.
OPEN OUTPUT ARQSAI.

DISPLAY '======================================='
DISPLAY ' ERRO NO OPEN DO ARQUIVO ARQSAI '
DISPLAY '======================================='
STOP RUN.

52
COBOL
14 Movimentação de Campos
MOVE
A instrução MOVE transfere dados de uma área de memória para uma ou mais áreas. Se o campo
receptor dos dados for numérico, ocorrera um alinhamento numérico, caso contrário, ocorrerá um
alinhamento alfanumérico conforme as regras abaixo:
 Alinhamento alfabético/alfanumérico
Os dados são acomodados no campo receptor alinhando-se da esquerda para a direita.
Se o campo emissor for maior que o receptor, os BYTES mais a direita, em excesso, serão
truncados no campo receptor. Se o emissor for menor que o receptor, os BYTES faltantes
para preencher o campo receptor serão preenchidos com SPACES.
 Alinhamento Numérico
Os dados são acomodados no campo receptor alinhando-se da direita para a esquerda.
Se o campo emissor for maior que o receptor, os BYTES mais a esquerda do campo
emissor serão truncados.
 Se o emissor for menor que o receptor, os bytes faltantes para preencher

o campo receptor serão preenchidos com zeros.
 Os campos: EMISSOR e RECEPTOR podem ser itens de grupo ou elementares.
 A clausula ALL (opcional) quando usada faz com que o campo emissor seja repetido
várias vezes no campo receptor até preenchê-lo completamente.
Exemplos de MOVE com constantes figurativas
Campo Campo Conteúdo do campo

emissor receptor receptor
Comando (constante formato: após o MOVE
figurativa) (expresso em hexa)
00.00.00.0C
MOVE ZERO TO TOTSAL ZERO PIC 9(7) COMP-3
MOVE ZEROS TO TOTSAL 00.00.00.0C
ZEROS PIC 9(7) COMP-3
MOVE ZEROES TO TOTSAL ZEROES 00.00.00.0C
PIC 9(7) COMP-3
MOVE ZERO TO TOTSAL F0.F0.F0.F0.F0
ZERO PIC 9(5)
MOVE ZEROS TO TOTSAL ZEROS F0.F0.F0.F0.F0
PIC 9(5)
MOVE ZEROES TO TOTSAL ZEROES F0.F0.F0.F0.F0
PIC 9(5)
MOVE SPACE TO SIGLA SPACE 40.40
PIC X(02)
MOVE SPACES TO SIGLA SPACES 40.40
PIC X(02)
MOVE HIGH-VALUES TO CHAVE-ARQUIVO HIGH-VALUES FF.FF.FF
PIC X(03)
MOVE LOW-VALUES TO CHAVE-ARQUIVO LOW-VALUES 00.00.00
PIC X(03)
MOVE ALL „*‟ TO WS-MSG ALL „*‟ 5C.5C.5C.5C.5C
PIC X(05)
ALL „*A‟ 5C.C1.5C.C1.5C
MOVE ALL „*A‟ TO WS_MSG PIC X(05)
 ZEROS – O item (deve ser numérico) será preenchido com algarismos 0 (zero).
 SPACES – O item (deve ser alfabético ou alfa-numérico) será preenchido com espaços.

53
COBOL
 LOW-VALUES - indica que este item na memória deve ter todos os seus bytes com todos
os bits desligados. Um item nestas condições terá o menor valor possível em todas as
comparações.
 HIGH-VALUES - indica que este item na memória deve ter todos os seus bytes com todos
os bits ligados. Um item nestas condições terá o maior valor possível em todas as comparações.
Formatos:
MOVE nome-do-campo-entrada TO nome-do-campo-saida
MOVE nome-do-registro-entrada TO nome-do-registro-saida
MOVE nome-do-campo-entrada TO variável
Regras:
1. A movimentação só é permitida para campos ou variáveis que possuam o mesmo formato.

2. Pode-se movimentar conteúdo numérico para as variáveis de edição.
3. Pode-se movimentar conteúdos numéricos inteiros para variáveis ou campos decimais
Exemplo:
*=============================================================
*=============================================================
PROCESSA SECTION.

54
COBOL
15 Gravação de Registros
WRITE
A gravação consiste na transferência de um registro da memória, para o arquivo. A gravação é

feita registro a registro. Cada novo comando de gravação grava o conteúdo do registro da
memória em seguida ao último registro gravado no arquivo.
A instrução WRITE grava um registro após o último registro gravado em um arquivo de acesso
seqüencial.
Formatos:
WRITE nome-de-registro-1 (Necessita movimentação dos campos)
WRITE nome-de-registro-1 [FROM identificador-1].
Regras:
1. O arquivo de acesso seqüencial associado à instrução WRITE deve ser aberto no modo
OUTPUT ou EXTEND.
2. nome-de-registro-1: Deve ser o nome do registro lógico (nível 01) da FD na DATA

DIVISION.
3. FROM identificador-1: O conteúdo do identificador-1 é copiado para o nome-de-registro-1

antes de ocorrer a gravação. Depois da execução com sucesso da instrução WRITE, o registro
continua disponível no identificador-1.
Exemplo:
*=============================================================
* ROTINA DE GRAVACAO DO ARQUIVO DE SAIDA *
*=============================================================
GRAVA-SAIDA SECTION.
WRITE REG-ARQSAI.

DISPLAY '======================================='
DISPLAY ' ERRO NA GRAVACAO DO ARQSAI '
DISPLAY '======================================='
STOP RUN.
ADD 1 TO WS-CONT-GRAVA.
GRAVA-SAIDA-FIM.
EXIT.

55
COBOL
16 Fechamentos de Arquivos
CLOSE
Efetua o fechamento de arquivos.
Formato:
CLOSE nome-de-arquivo ...
Exemplos:
*=============================================================
* ROTINA DE FINALIZACAO E FECHAMENTO DOS ARQUIVOS *
*=============================================================
FINALIZA SECTION.
CLOSE ARQENT.
DISPLAY '======================================='
DISPLAY ' ERRO NO CLOSE DO ARQUIVO ARQENT '
DISPLAY '======================================='
STOP RUN.
CLOSE ARQSAI.
DISPLAY '======================================='
DISPLAY ' ERRO NO CLOSE DO ARQUIVO ARQSAI '
DISPLAY '======================================='
STOP RUN.

56
COBOL
17 Leitura de Arquivos Seqüenciais
READ
A instrução READ obtém um registro lógico de um arquivo. A cada novo comando READ, o
próximo registro lógico do arquivo será lido. Após cada comando READ, todos os campos
descritos na FD do arquivo estarão preenchidos com os valores do registro lido.
Quando a instrução READ for executada, o arquivo associado deve estar aberto no modo INPUT.
Formato:
READ nome-arquivo
[INTO nome-area-working]
[AT END instrução]
[NOT AT END instrução]
[END-READ].
Regras:
1. INTO: Os campos do registro lido serão movidos da área de leitura do arquivo para uma
área de trabalho.
2. AT END: Se a condição AT END for especificada, e o comando READ não encontrar mais
registros para ler no arquivo (fim do arquivo), a instrução após o AT END será executada. Depois
que um programa executar o AT END, a lógica do programa não deve executar um novo READ.
3. NOT AT END: Enquanto for lido um registro lógico esta condição é verdadeira,podendo
serem incluídos comandos que devem ser executados.
Exemplo:
*=============================================================
* ROTINA DE LEITURA DO ARQUIVO DE ENTRADA *
*=============================================================
LER-ARQENT SECTION.
READ ARQENT.
IF WS-FS-ARQENT NOT EQUAL ZEROS AND 10

DISPLAY '======================================='
DISPLAY ' ERRO NO READ DO ARQUIVO ARQENT '
DISPLAY '======================================='
STOP RUN.
ADD 1 TO WS-CONT-LIDOS.

57
COBOL
18 Inicialização de Campos e conjunto de variáveis
INITIALIZE
Efetua a inicialização (atribuição de valores) de uma variável (ou um conjunto de variáveis).
 Como default variáveis numéricas são inicializadas com zeros e variáveis

alfanuméricas são inicializadas com espaços.
 Se a variável especificada for um item de grupo, todos os seus subitens serão inicializados
de acordo com seu formato: os que forem numéricos, serão inicializados com zero
(respeitando-se seu formato : zonado, compactado ou binário); se a variável for alfa-
numérica ou alfabética, ela será inicializada com espaços.
Formato:
INITIALIZE variável ou Nível “01” do registro.
Exemplos:
*=============================================================
*=============================================================
PROCESSA SECTION.

58
COBOL
19 Encerramento de Parágrafos
EXIT
A instrução EXIT provê um ponto de encerramento comum para uma serie de parágrafos. A
instrução EXIT não tem efeito na compilação nem na execução do programa. É, portanto, usado
com a finalidade de documentar o programa.
A instrução EXIT deve ser única dentro do seu parágrafo.
Formato:
EXIT.
Exemplo:
ROT-MESTRE SECTION.
PERFORM INICIO THRU INICIO-FIM.
PERFORM PROCESSA THRU PROCESSA-FIM UNTIL
WS-FS-ARQENT = 10.
PERFORM FINALIZA THRU FINALIZA-FIM.
STOP RUN.
ROT-MESTRE-FIM.
EXIT.

59
COBOL
20 Relatórios
A impressão de relatórios é o registro de informações processadas pelo programa em um meio de

armazenamento de dados chamado de formulário. Para efetuarmos a impressão de relatórios
devemos nos preocupar com os seguintes aspectos:
 Características do formulário
 Controle de linhas, numeração e salto de página
 Impressão de cabeçalho e estética da página
Características do Formulário
A maioria dos formulários possui um formato padrão, isto é, a quantidade de linhas por página e
de caracteres por linha são constantes.
Controle de Linhas, numeração e salto de Páginas

Uma preocupação com o controle de linhas é não permitir que a impressora imprima fora do
espaço útil do papel reservado para o texto, pois além de esteticamente não ficar bom, haveria
perda de informações. Para controlarmos o número de linhas impressas, devemos criar um
contador de linha e de páginas e não deixar o valor desses contadores ultrapassarem o número
desejado de linhas por página.
Exemplo:
ID DIVISION.
*----------------------------------------------------------------*
PROGRAM-ID. EXEMPLO2.
AUTHOR. ALUNO.
*----------------------------------------------------------------*
SPECIAL-NAMES.
*----------------------------------------------------------------*
FILE-CONTROL.
SELECT PECAS ASSIGN TO ENTRADA.
SELECT RELATORIO ASSIGN TO RELATO.
*----------------------------------------------------------------*
DATA DIVISION.
*----------------------------------------------------------------*
FILE SECTION.
*----------------------------------------------------------------*
FD PECAS
RECORDING MODE F.
01 REG-PECAS.
02 CODIGO PIC 9(005).
02 NOME PIC X(020).
02 DESCRICAO PIC X(020).
02 PRECO PIC 9(007)V99.
02 ESTOQUE PIC 9(007).
*----------------------------------------------------------------*
FD RELATORIO
RECORDING MODE F.
01 REG-RELATO PIC X(132).
60
COBOL
*----------------------------------------------------------------*
*----------------------------------------------------------------*
77 WS-FIM PIC X VALUE SPACES.
01 ACUMULADORES.
02 NPAG-WS PIC 9(02) VALUE ZEROS.
02 NLINHAS-WS PIC 9(02) VALUE ZEROS.
02 NITENS-WS PIC 9(03) VALUE ZEROS.
02 NVALOR-WS PIC 9(7)V99 VALUE ZEROS.
*----------------------------------------------------------------*
01 LIN1.
02 FILLER PIC X(5) VALUE SPACES.
02 DATA-LIN1.
03 DIA PIC 9(02) VALUE ZEROS.
03 FILLER PIC X VALUE "/".
03 MES PIC 9(02) VALUE ZEROS.
03 FILLER PIC X VALUE "/".
03 ANO PIC 9(02) VALUE ZEROS.
02 FILLER PIC X(18) VALUE
"RELATORIO DE PECAS".
02 FILLER PIC X(5) VALUE "PAG. ".
02 NPAG-LIN1 PIC Z9 VALUE SPACES.
*----------------------------------------------------------------*
01 LIN2.
" CODIGO NOME ".
" DESCRICAO".
" PRECO ".
" ESTOQUE".
*----------------------------------------------------------------*
01 DETALHE.
02 CODIGO-DET PIC ZZ.ZZ9 VALUE SPACES.
02 NOME-DET PIC X(20) VALUE SPACES.
02 DESC-DET PIC X(20) VALUE SPACES.
02 PRECO-DET PIC ZZ.ZZZ.ZZ9,99
VALUE SPACES.
02 EST-DET PIC Z.ZZZ.99
VALUE SPACES.
*----------------------------------------------------------------*
01 LINTOT1.
" TOTAL DE ITENS: ".
02 TOTALITENS PIC Z99 VALUE SPACES.
*----------------------------------------------------------------*
01 LINTOT2.
" VALOR DOS ITENS: ".
02 TOTALVALOR PIC $ZZ.ZZ9,99 VALUE SPACES.
*----------------------------------------------------------------*
61
COBOL
01 DATA-ACCEPT.
02 ANO PIC 9(02) VALUE ZEROS.
02 MES PIC 9(02) VALUE ZEROS.
02 DIA PIC 9(02) VALUE ZEROS.
*----------------------------------------------------------------*
PROCEDURE DIVISION.
*----------------------------------------------------------------*
PRINCIPAL.
*----------------------------------------------------------------*
PERFORM INICIAR.
PERFORM PROCESSAR UNTIL WS-FIM = "S".
PERFORM FINALIZAR.
STOP RUN.
FIM-ROTINA-PRINCIPAL.
*----------------------------------------------------------------*
INICIAR.
*----------------------------------------------------------------*
MOVE "N" TO WS-FIM.
MOVE ZEROS TO ACUMULADORES.
MOVE 99 TO NLINHAS-WS.
*
OPEN INPUT PECAS.
OPEN OUTPUT RELATORIO.
*
ACCEPT DATA-ACCEPT FROM DATE.
MOVE CORR DATA-ACCEPT TO DATA-LIN1.
READ PECAS
AT END
MOVE "S" TO WS-FIM
END-READ.
FIM-INICIAR.
EXIT.
*----------------------------------------------------------------*
PROCESSAR.
*----------------------------------------------------------------*
MOVE CODIGO TO CODIGO-DET.
MOVE NOME TO NOME-DET.
MOVE DESCRICAO TO DESC-DET.
MOVE PRECO TO PRECO-DET.
MOVE ESTOQUE TO EST-DET.
*
IF NLINHAS-WS > 35
PERFORM CABECALHO.
WRITE REG-RELATO FROM DETALHE.
ADD 1 TO NLINHAS-WS.
ADD 1 TO NITENS-WS.
ADD PRECO TO NVALOR-WS.
READ PECAS
AT END
MOVE "S" TO WS-FIM
END-READ.
FIM-PROCESSAR.
EXIT.

62
COBOL
*----------------------------------------------------------------*
FINALIZAR.
*----------------------------------------------------------------*
MOVE NVALOR-WS TO TOTALVALOR.
MOVE NITENS-WS TO TOTALITENS.
WRITE REG-RELATO FROM LINTOT1 AFTER 2 LINES.
WRITE REG-RELATO FROM LINTOT2 AFTER 2 LINES.
CLOSE PECAS RELATORIO.
FIM-FINALIZAR.
EXIT.
*----------------------------------------------------------------*
CABECALHO.
*----------------------------------------------------------------*
ADD 1 TO NPAG-WS.
MOVE NPAG-WS TO NPAG-LIN1.
WRITE REG-RELATO FROM LIN1 AFTER PAGE.
WRITE REG-RELATO FROM LIN2 AFTER 2 LINES.
FIM-CABECALHO.
EXIT.
20.1 COMANDOS PARA PROCESSAMENTO DE RELATÓRIOS
O Cobol trata a impressão de relatórios de maneira similar à gravação de arquivos, ou seja, enviar
uma linha de relatório para a impressora é idêntico a gravar um registro em um arquivo. Por isso
precisamos definir o relatório na INPUT-OUTPUT SECTION (ENVIRONMENT DIVISION) com a
instrução SELECT, precisamos definir o conteúdo das linhas de impressão na FILE SECTION
(DATA DIVISION) com a instrução FD, e na PROCEDURE DIVISION devemos usar as instruções
OPEN, WRITE e CLOSE para controlar a impressão. No entanto, obviamente existem diferenças
entre um arquivo e um relatório, e os seguintes detalhes devem ser observados em um
programa:
 Diferentemente dos arquivos, onde todos os registros podem ter o mesmo layout, em um
relatório as linhas de detalhe podem ser diferentes (incluindo sub-totais, títulos de grupos etc.).
Além disso, sempre existe um cabeçalho em cada folha ou ainda linhas de rodapé.
 O programa precisa controlar a mudança de página. Para isto o programa deve criar uma
variável para contar linhas, que deve ser incrementada a cada comando WRITE do relatório.
Quando esta variável atinge o numero de linhas disponíveis na folha, o programa deve comandar
o salto para a nova folha e imprimir as linhas de cabeçalho.
 É comum haver totalizações em vários níveis (subtotais, totais gerais etc.). Estes totais são
emitidos quando muda a identificação de grupo dentro dos registros lidos. Por exemplo, em um
relatório de vendas com totais por mês, o programa deve comparar o mês do registro lido com o
mês do registro anterior para verificar se são diferentes. Nestas mudanças de identificador de
grupo (geralmente conhecido como QUEBRA), o programa deve emitir uma linha de total.

63
COBOL
WRITE {BEFORE | AFTER}

A instrução WRITE tem um formato próprio para impressões de relatórios.
Formato:
WRITE nome-registro-1 [FROM identificador-1]

{BEFORE | AFTER} n [n LINES|PAGE]
[END-WRITE].
Regra:
1. BEFORE: Quando a opção BEFORE for utilizada o Cobol interpreta o comando da seguinte
forma: GRAVAR nome-registro-1 ANTES DE SALTAR N LINHAS ou PAGINA.
2. AFTER: Quando a opção AFTER for utilizada o Cobol interpreta o comando da seguinte
forma: GRAVAR nome-registro-1 DEPOIS DE SALTAR N LINHAS ou PÁGINA.
3. FROM: A opção FROM pode ser utilizada para transferir as linhas do relatório a serem
impressas (definidas na Working-Storage Section), após serem preparadas, para o registro do
arquivo de impressão.
Exemplo:
*----------------------------------------------------------------*
CABECALHO.
*----------------------------------------------------------------*
ADD 1 TO NPAG-WS.
MOVE NPAG-WS TO NPAG-LIN1.
WRITE REG-RELATO FROM LIN1 AFTER PAGE.
WRITE REG-RELATO FROM LIN2 AFTER 2 LINES.
FIM-CABECALHO.
EXIT.

64
COBOL
20.2 Totalização e Quebra de Relatórios
Totalização aplica-se a arquivos com vários registros com a mesma chave.
Exemplo:
Arquivo de lançamentos para contas correntes, onde uma conta pode ter vários lançamentos.
Pode ser necessário um relatório que totalize por conta.
IF NLINHAS-WS > 35
PERFORM CABECALHO.
WRITE REG-RELATO FROM DETALHE.
ADD 1 TO NLINHAS-WS.
ADD 1 TO NITENS-WS.
ADD PRECO TO NVALOR-WS.

65
COBOL
21 Lógica Balanceada
Trata-se do processamento sincronizado de dois ou mais arquivos ordenados pela mesma chave.
Exemplo: arquivo de contas correntes e movimentos, ambos com a chave: CONTA. A lógica
balanceada irá gravar um novo arquivo de contas correntes com os saldos atualizados pelos
valores dos lançamentos das respectivas contas. Com a lógica balanceada, este processamento
será efetuado com apenas uma leitura de cada arquivo, verificando as condições de igual, maior
ou menor, para cada registro lido.
A lógica balanceada também é conhecida como BALANCE LINE ou MERGE.
Exemplo:
PROGRAM-ID. EXEMPLO3.
AUTHOR. ALUNO.
*OBJETIVO: BALANCE LINE ENTRE O ARQUIVO CCANT E MOV.
*===============================================================
SPECIAL-NAMES.
FILE-CONTROL.
SELECT CCANT ASSIGN TO CCANT
FILE STATUS IS WS-FS-CCANT.
SELECT MOV ASSIGN TO MOV

FILE STATUS IS WS-FS-MOV.
SELECT ATUA ASSIGN TO ATUA

FILE STATUS IS WS-FS-ATUA.
*===============================================================
DATA DIVISION.
FILE SECTION.
FD CCANT
01 REG-CCANT.
03 CCANT-CONTA PIC X(3).
03 CCANT-NOME PIC X(20).
03 CCANT-SALDO PIC S9(5)V9(2).
FD MOV
01 REG-MOV.
03 MOV-CONTA PIC X(3).
03 MOV-SALDO PIC S9(5)V9(2).
FD ATUA

66
COBOL

01 REG-ATUA.
03 ATUA-CONTA PIC X(3).
03 ATUA-NOME PIC X(20).
03 ATUA-SALDO PIC S9(5)V9(2).
77 WS-FS-CCANT PIC 9(2) VALUE ZEROS.

77 WS-FS-MOV PIC 9(2) VALUE ZEROS.
77 WS-FS-ATUA PIC 9(2) VALUE ZEROS.
PROCEDURE DIVISION.
PRINCIPAL SECTION.
PERFORM INICIO.
PERFORM PROCESSA UNTIL HIGH-VALUES = CCANT-CONTA
AND MOV-CONTA.
PERFORM FIM.
STOP RUN.
INICIO SECTION.
OPEN INPUT CCANT.

IF WS-FS-CCANT NOT EQUAL ZEROS
DISPLAY 'ERRO NO OPEN DO CCANT = ' WS-FS-CCANT
MOVE 99 TO RETURN-CODE
STOP RUN.
OPEN INPUT MOV.

IF WS-FS-MOV NOT EQUAL ZEROS
DISPLAY 'ERRO NO OPEN DO MOV = ' WS-FS-MOV
STOP RUN.
OPEN OUTPUT ATUA.

IF WS-FS-ATUA NOT EQUAL ZEROS
DISPLAY 'ERRO NO OPEN DO ATUA = ' WS-FS-ATUA
STOP RUN.
PERFORM LER-CCANT.
PERFORM LER-MOV.

67
COBOL
PROCESSA SECTION.
IF CCANT-CONTA = MOV-CONTA
ADD MOV-SALDO TO CCANT-SALDO
PERFORM LER-MOV
ELSE
IF CCANT-CONTA < MOV-CONTA
MOVE REG-CCANT TO REG-ATUA
WRITE REG-ATUA
PERFORM LER-CCANT
ELSE
PERFORM LER-MOV
END-IF
END-IF.
FIM SECTION.
CLOSE CCANT MOV ATUA.
IF WS-FS-CCANT NOT EQUAL ZEROS

DISPLAY 'ERRO NO CLOSE DO CCANT = ' WS-FS-CCANT.
STOP RUN.
IF WS-FS-MOV NOT EQUAL ZEROS

DISPLAY 'ERRO NO CLOSE DO MOV = ' WS-FS-MOV.
IF WS-FS-ATUA NOT EQUAL ZEROS

DISPLAY 'ERRO NO CLOSE DO ATUA = ' WS-FS-ATUA.
LER-CCANT SECTION.
READ CCANT.
IF WS-FS-CCANT NOT EQUAL ZEROS AND 10

DISPLAY 'ERRO NO READ DO CCANT = ' WS-FS-CCANT
STOP RUN
ELSE
IF WS-FS-CCANT EQUAL 10
MOVE HIGH-VALUES TO CCANT-CONTA
END-IF
END-IF.
LER-MOV SECTION.
READ MOV.
IF WS-FS-MOV NOT EQUAL ZEROS AND 10

DISPLAY 'ERRO NO READ DO MOV = ' WS-FS-MOV
STOP RUN
ELSE
IF WS-FS-MOV EQUAL 10
MOVE HIGH-VALUES TO MOV-CONTA
END-IF
END-IF.

68
COBOL
22 Tabelas de Memória – Cláusula OCCURS
TABELAS – OCCURS
Alguns algoritmos mais avançados exigem a definição de uma mesma variável várias vezes,
aumentando o trabalho de codificação do programa correspondente tanto na DATA DIVISION,
como também as instruções resultantes na PROCEDURE DIVISION. Por exemplo, em um
algoritmo para acumular as vendas do ano separadas por mês, precisamos definir 12 campos de
total na DATA DIVISION, e a PROCEDURE DIVISION deverá ter 12 testes do mês da venda para
decidir em que total deve ser feito a soma.
Exemplo:
DATA DIVISION.
03 TOTAL-01 PIC 9(8)V99.
03 TOTAL-02 PIC 9(8)V99.
...
03 TOTAL-12 PIC 9(8)V99.
PROCEDURE DIVISION.
…
IF MES = 01
ADD VENDAS TO TOTAL-01
ELSE
IF MES = 02
ELSE
...
IF MES = 12
A linguagem COBOL possui um recurso para resolver este problema. Na DATA DIVISION a
variável será definida somente uma vez, acompanhada da cláusula OCCURS que definirá quantas
vezes a variável deve ser repetida. A sintaxe da definição do item com OCCURS é:

69
COBOL
Formato:
NÍVEL identificador-1 PIC 9,X OU A OCCURS n [TIMES].
Regras:
1. A cláusula OCCURS só pode ser usada em variáveis de nível 02 a 49.
2. Quando uma variável de uma tabela (definida com OCCURS) for usada na PROCEDURE
DIVISION, ela precisa ser acompanhada de um indexador (subscrito) que definirá qual
ocorrência da tabela está sendo referida. Este subscrito deve estar dentro de parênteses e
pode ser um literal numérico ou uma variável numérica com valores inteiros. Por ex: ADD
VENDAS TO TOTAL-MENSAL(5). Neste caso a soma esta sendo feita na quinta ocorrência
de total-mensal.
Exemplo:
A codificação do algoritmo do exemplo acima ficará reduzida agora a:
DATA DIVISION.
01 TOTAIS-GERAIS.
03 TOTAL-MENSAL PIC 9(8)V99 OCCURS 12 TIMES.
...
PROCEDURE DIVISION.
...
ADD VENDAS TO TOTAL-MENSAL (MES-VENDA).

70
COBOL
22.1 NÍVEIS DE TABELAS
Em COBOL podemos definir um item de uma tabela como uma nova tabela, e assim
sucessivamente até um nível de 3 tabelas. Por exemplo, para obter o total de vendas separado
por estado, e em cada estado por tipo de produto, e para cada produto por mês de venda,
montaremos a DATA DIVISION como abaixo:
DATA DIVISION.
01 TOTAIS-VENDA.
03 VENDAS-ESTADO OCCURS 27 TIMES.
05 VENDAS-PRODUTO OCCURS 5 TIMES.
07 VENDAS-MÊS PIC 9(8)V99 OCCURS 12 TIMES.
Este código montará na memória uma tabela com 3 níveis de 1620 totais (27 estados X 5 produtos
X 12 meses). Para acessar um total desta tabela será necessário um conjunto de 3 indexadores:
PROCEDURE DIVISION.
....
ADD VENDAS TO
VENDAS-MÊS (CD-ESTADO, CD-PRODUTO, MÊS-VENDA).
Importante:
Os indexadores dentro dos parênteses devem estar na mesma seqüência da definição das
tabelas (mesma hierarquia).

71
COBOL
23 Chamando um Sub-Programa
O comando CALL é usado para incorporar ao programa principal (LINK) um sub-programa. A sua
principal função é a redundância de códigos em vários programas, podendo assim, vários
programas usarem a mesma sub-rotina (sub-programa), não necessitando reescrever os códigos
a cada novo programa.
Formatos:
 Chamada estática:
CALL „SUBPRG1‟ USING WS-AREA.
 Chamada Dinâmica:
CALL NOME-DO-SUBPROGRAMA USING WS-AREA
Parâmetros:
USING : Indica a área que servirá de comunicação entre o programa principal e o sub-programa,
definida na WORKING-STORAGE SECTION.
Chamada estática: esta chamada incorpora na linkedição do programa principal o executável do

sub-programa, a desvantagem dessa modalidade é que se houver alterações no sub-programa,
devemos compilar todos os programas principais que usarem o sub-programa.
Chamada dinâmica: esta chamada incorpora o executável do sub-programa ao programa

principal em tempo de execução do mesmo, tornando assim, disponível a última versão do sub-
programa, se este sofreu modificações.
Procedimentos no Sub-Programa:
Esta instrução é usada para sub-programas (programas chamados por CALL num programa
principal) para devolver o controle (retornar) ao programa principal, logo após a instrução CALL.
Parâmetros:
USING: Indica a área que servirá de comunicação entre o sub-programa e o principal, será
definida na LINKAGE SECTION e referenciada na PROCEDURE DIVISION, note que a área tem
que ter o mesmo formato, podendo ter nomes diferentes.
EXIT/GOBACK: Retorna para o programa que chamou, passando a área da linkage.

72
COBOL
24 Compilação e Linkedição de programas
O compilador para linguagem COBOL, é responsável por traduzir as instruções e comandos da

linguagem de alto nível, para a linguagem de baixo nível ou linguagem de máquina.
Todo programa só pode ser executado pelo sistema operacional, se o mesmo estiver em
linguagem de máquina. Desta forma foi desenvolvido um utilitário que transforma os comandos e
instruções em códigos binários, gerando um objeto executável.
Etapas da compilação e linkedição COBOL:
 Verificar os erros de sintaxe do código fonte.

 Transformar o código fonte em linguagem de máquina
 Gerar um módulo objeto
 Acoplar ao módulo objeto, os módulos do sistema operacional
 Gerar o objeto executável
 Disponibilizar este objeto executável em uma biblioteca de carga

73
APOSTILA : COBOL
25 FILE STATUS
Campo com o código de retorno dos comandos executados sobre o arquivo. Devem ter formato
PIC XX e os valores retornados estão na tabela abaixo:
STATUS DESCRIÇÃO
'00' 'SUCCESSFUL COMPLETION'
'02' 'DUPLICATE KEY, NON UNIQ. ALT INDX'
'04' 'READ, WRONG LENGTH RECORD'
'05' 'OPEN, FILE NOT PRESENT'
'CLOSE OPTION INCOMPAT FILE DEVICE OPEN IMPLIES TAPE; TAPE NOT
'07'
USED'
'10' 'END OF FILE'
'14' 'RRN > RELATIVE KEY DATA'
'20' 'INVALID KEY VSAM KSDS OR RRDS'
'21' 'SEQUENCE ERROR, ON WRITE OR CHANGING KEY ON REWRITE'
'22' 'DUPLICATE KEY'
'23' 'RECORD OR FILE NOT FOUND'
'BOUNDARY VIOLATION. WRITE PAST END OF KSDS RECORD. COBOL 370:
'24'
REL: REC# TOO BIG. OUT OF SPACE ON KSDS/RRDS FILE'
'30' 'PERMANENT DATA ERROR. DATA CHECK, PARITY CHK, HARDW'
'BOUNDARY VIOLATION. WRITE PAST END OF ESDS RECORD OR NO SPACE
'34'
TO ADD KSDS/RRDS RECORD. OUT OF SPACE ON SEQUENTIAL FILE'
'35' '35' 'OPEN, FILE NOT PRESENT'
'37' 'OPEN MODE INCOMPAT WITH DEVICE'
'38' 'OPENING FILE CLOSED WITH LOCK'
'39' 'OPEN, FILE ATTRIB CONFLICTING'
'41' 'OPEN, FILE IS OPEN'
'42' 'CLOSE, FILE IS CLOSED'
'43' 'DELETE OR REWRITE & NO GOOD READ FIRST'
'44' 'BOUNDARY VIOLATION/REWRITE REC TOO BIG'
'46' 'SEQUENTIAL READ WITHOUT POSITIONING'
'47' 'READING FILE NOT OPEN AS INPUT/IO/EXTEND'
'48' 'WRITE WITHOUT OPEN IO'
'49' 'DELETE OR REWRITE WITHOUT OPEN IO'
'90' 'UNKNOWN'
'91' 'VSAM - PASSWORD FAILURE'
'LOGIC ERROR/OPENING AN OPEN FILE OR READING OUTPUT FILE OR
'92'
WRITE INPUT FILE OR DEL/REW BUT NO PRIOR READ '
'93' 'VSAM - VIRTSTOR. RESOURCE NOT AVAILABLE'
'94' 'VSAM - SEQUENTIAL READ AFTER END OF FILE OR NO CURRENT

REC POINTER FOR SEQ'
'VSAM - INVALID FILE INFORMATION OR OPEN OUTPUT (LOAD) WITH
'95'
FILE THAT NEVER CONTAINED DATA'
'96' 'VSAM - MISSING DD STATEMENT IN JCL'
'97' 'VSAM - OPEN OK, FILE INTEGRITY VERIFIED FILE SHOULD BE OK'
OTHER 'UNKNOWN REASON'

74
ESCOLA
DE PROGRAMADORES
MÓDULO : DB2
DB2
1 – INTRODUÇÃO.
O DB2 é um banco de dados relacional usado exclusivamente na plataforma alta (IBM).
Os primeiros bancos de dados adotados no Mainframe eram bancos de dados estruturados, onde o
layout de seus registros eram fixos, e todos os programas precisavam declará-los explicitamente.
Quaisquer alteração nestes layout requeriam a recodificação de todos os programas envolvidos com
o banco de dados.
Os bancos de dados relacionais se caracterizam por ter layout flexível, independente dos programas,
além do potencial criado pela linguagem SQL de formular pesquisas nas mais diversas situações, a
qualquer momento.
Conjunto de tabelas, índices

COMO FUNCIONA O DB2 ? e tablespaces agrupados
Forma Alternativa de enxergar

uma tabela a fim de garantir
DATABASE segurança
TABLESPACE
Conjunto de Data Sets
VSAM que contém uma ou
mais tabelas
ÍNDICE TABELA
VIEW
Agiliza a leitura de dados para Conjunto de Atributos

garantir a UNICIDADE de reunidas segundo uma Regra
dados de Negócio
1.1 - O MODELO RELACIONAL.

Dos conceitos do modelo relacional retiramos as seguintes definições:
Banco de Dados É formado por um conjunto de TABELAS. O layout das tabelas é mantido
pelo próprio Banco de Dados. Cada TABELA é formada por um conjunto de
COLUNAS. O nome e formato das COLUNAS são mantidos pelo Banco de
Dados.
Relacionamentos O relacionamento entre as TABELAS é representado pelos VALORES

contidos nestas TABELAS.
Pesquisa (Query) Para se efetuar uma pesquisa nas TABELAS especifica-se uma TABELA
RESULTADO (Result Table). O DB2 pesquisa o conteúdo de suas TABELAS
e monta a Result Table conforme a especificação da pesquisa.

1
DB2
1.2 - ELEMENTOS DO DB2.
1.2.1 – TABELAS.
 São estruturas lógicas mantidas pelo DB2 para representar uma entidade.
1.2.2 – COLUNAS.
 É cada uma das informações que compõem uma tabela.
1.2.3 – LINHA
 É o conjunto de colunas que formam uma instância da entidade.
Quando aplicamos estes conceitos, temos como resultado a figura abaixo.
Tabela Funcionários
Matricula Nome Cargo Depto Salário
000010 Christiane D01 001 260000

000020 Karina R01 002 270010
000030 Júlio S01 003 300010
Linhas 000040 Ingrid P01 004 250500
000050 Juan P02 004 138005
Colunas
1.2.4 KEY (Chave ou índice)

Conjunto de colunas selecionadas para identificar as linhas da tabela. As chaves podem identificar
linhas dentro da própria tabela ou linhas de outra tabela (Foreign Keys). O DB2 aceita os seguintes
tipos de KEY:
1.2.4.1 UNIQUE KEY

Chave que identifica de maneira única uma linha da tabela. Não existe mais de uma linha da tabela
com a mesma UNIQUE KEY.
A UNIQUE KEY tem as seguintes propriedades:
 A UNIQUE KEY não pode ter NULL (não pode estar vazia).
 É necessário criar um UNIQUE INDEX para a UNIQUE KEY.
 Uma tabela pode ter mais de um UNIQUE KEY.

2
DB2
1.2.4.2 - PRIMARY KEY

É a UNIQUE KEY usada na definição da tabela. Suas propriedades são:
 A tabela só pode ter uma PRIMARY KEY.
 A PRIMARY KEY é opcional, isto é, as tabelas não precisam ter PRIMARY KEY.
1.2.4.3 - PARENT KEY

É uma PRIMARY KEY ou UNIQUE KEY de uma TABELA MESTRE (tabela mestre é a tabela da
posição (1) da relação 1:N do MER). O valor da PARENT KEY será replicado nas FOREIGN
KEY(chave estrangeira) das tabelas relacionadas (lado (N) da relação 1:N)
1.2.4.4 – FOREIGN KEY

É uma KEY em uma TABELA RELACIONADA (lado N na relação 1:N) que identifica uma linha da
TABELA MESTRE. As propriedades da FOREIGN KEY são:
 Uma tabela pode ter zero, uma ou varias FOREIGN KEY.
 Dependendo das regras de INTEGRIDADE REFERENCIAL (SET NULL), o valor da
FOREIGN KEY pode ser NULL.
Chave Chave
Primária Estrangeira
Matr Nome Depto EMPR
419 Maria A00

003 Carlos Z13
DeptoCod DeptoNome DEPT
Z13 Reserva
A00 Vendas

3
DB2
1.2.4.5 - REGRAS DE INTEGRIDADE
O DB2 possui algumas regras de validação de seus dados que são definidos no momento da
definição de suas tabelas. Estas validações independem dos programas que atualizam o banco de
dados, e são executadas automaticamente quando se incluem alteram ou excluem dados das
tabelas. As regras de integridade são:
UNICIDADE
Esta regra define que uma ou varias colunas (KEYS), da tabela não podem repetir valores. É a regra
usada para definir UNIQUE KEYS.
INTEGRIDADE DE VALORES (CHECK CONSTRAINTS)

Esta regra define valores permitidos para colunas de uma tabela.
INTEGRIDADE REFERENCIAL
A INTEGRIDADE REFERENCIAL define a validade de uma FOREIGN KEY:
 Se uma FOREIGN KEY não contém NULL, seu valor deve ser o da PARENT KEY da
TABELA MESTRE.
 A INTEGRIDADE REFERENCIAL deve ser definida na criação da tabela.
 O DB2 testa a INTEGRIDADE REFERENCIAL nos comandos de inclusão, alteração e
exclusão dos programas conforme abaixo:
INTEGRIDADE NA INCLUSÃO.
Se uma linha tiver uma coluna FOREIGN KEY com valor NOT NULL, deve haver uma linha na
PARENT TABLE com este valor.na PARENT KEY.
INTEGRIDADE NA ALTERAÇÃO.
Se houver alteração em uma FOREIGN KEY, deve haver na PARENT TABLE uma PARENT KEY
com o novo valor da FOREIGN KEY.
INTEGRIDADE NA EXCLUSÃO.
A exclusão de linhas com FOREIGN KEY não tem restrição. Se uma linha tiver uma coluna com
PARENT KEY, uma das 3 regras de exclusão abaixo deve ser definida na criação da tabela:
 RESTRICT – A exclusão não será efetuada se houver uma TABELA DEPENDENTE
com uma FOREIGN KEY com este valor.
 CASCADE – O DB2 fará a exclusão automática de todas as linhas das TABELAS
DEPENDENTES com este valor na FOREIGN KEY. Se estas exclusões tiverem
sucesso, a linha da PARENT TABLE será excluída.
 SET NULL – As FOREIGN KEY nas TABELAS DEPENDENTES serão alteradas para
NULL.

4
DB2
1.2.5 - TIPOS DE DADOS.

Os formatos dos dados nas colunas de uma tabela DB2 se dividem em 4 grandes grupos:
STRING
NUMERIC
DATETIME
ROWID
1.2.5.1 FORMATO STRING.

É o formato para armazenar caracteres. São eles:
CHAR - Define colunas de caracteres com tamanho fixo com até 255 caracteres. Sintaxe:
Nome-da-coluna CHAR(tamanho)
Exemplo:
CODCLI CHAR(6)
VARCHAR - Define colunas de caracteres com tamanho variável. Podem conter até 32704
caracteres, mas tamanhos acima de 255 tem restrições em alguns comandos SQL.
Sintaxe:
Nome-da-coluna VARCHAR(tamanho-maximo)
Exemplo:
NOMECLI VARCHAR(50)
CLOB - Este tipo (Character Large Object) é usado para armazenar grande volume de texto.
Tem tamanho variável até 2147647 (2GB) bytes. Sintaxe
Nome-da-coluna CLOB(tamanho-maximo)
BLOB - Este tipo (Binary Large Object) é usado para armazenar imagens, ou dados em
formato binário em geral. Seu tamanho é variável até 2147483647 (2GB) bytes.
Nome-da-coluna BLOB(tamanho-maximo)
1.2.5.2 FORMATOS NUMERICOS
INTEGER - Define colunas para conter números inteiros usando 31 bits mais sinal. Uma coluna
INTEGER pode conter valores na faixa de –2147483648 até +2147483647. Sintaxe
para definir uma coluna INTEGER:
Nome-da-coluna INTEGER
Exemplo:
5
DB2
QUANTIDADE INTEGER
SMALLINT - Define colunas para conter números inteiros usando 15 bits mais sinal. Uma coluna
SMALLINT pode conter valores na faixa de –32768 até +32767. Sintaxe:
Nome-da-coluna SMALLINT
Exemplo:
IDADE SMALLINT
DECIMAL - O tipo DECIMAL define colunas com números reais (contendo parte inteira e
decimais). O DB2 aceita coluna DECIMAL com até 31 algarismos. O formato para
definir este tipo é:
Nome-da-coluna DECIMAL(total-de-algarismos decimais)
Exemplo: Para definir a coluna PRECO para 6 algarismos inteiros e 2 decimais

(valores até 9999,99):
PRECO DECIMAL(8,2)
REAL - O tipo REAL define colunas com números no formato PONTO FLUTUANTE. O DB2
usa 32 bits para este formato, e consegue controlar valores na faixa de –7.2E+75 até
7.2E75. Sintaxe:
Nome-da-coluna REAL
DOUBLE - O tipo DOUBLE define colunas com números no formato PONTO FLUTUANTE. O
DB2 usa 64 bits para este formato, e consegue controlar valores na faixa de –
7.2E+75 até 7.2E75 com precisão maior que o tipo REAL. Sintaxe:
Nome-da-coluna DOUBLE
1.2.5.3 FORMATOS DATETIME
Os formatos DATETIME definem formatos para armazenar datas e hora. Os valores no formato
DATETIME podem fazer parte de expressões aritméticas, isto é, podem-se somar duas variáveis com
formato DATETIME.
São 3 os tipos de formato DATETIME:
DATE - O tipo DATE define uma coluna com datas. O formato interno é um formato binário
próprio do DB2, mas o conteúdo da coluna conterá DIA, MES e ANO de uma data. O
formato lido por um programa (Ex.:DDMMAAAA) é função do comando utilizado para
ler a coluna.
Sintaxe para definir uma coluna DATE:

6
DB2
Nome-da-coluna DATE
Exemplo:
DATA-NASCIMENTO DATE
TIME - O tipo TIME define uma coluna com a hora do dia. O formato interno é um formato
binário próprio do DB2, mas o conteúdo da coluna conterá HORA, MINUTO e SEGUNDOS. O
formato lido por um programa (Ex.:HHMMSS) é função do comando utilizado para ler a
coluna.
Sintaxe para definir uma coluna TIME:
Nome-da-coluna TIME
Exemplo:
HORA-PARTIDA TIME
TIMESTAMP - O tipo TIMESTAMP define uma coluna com a data e hora do dia com precisão até
microssegundos. O formato interno é um formato binário próprio do DB2, mas a
coluna conterá DIA, MES, ANO, HORA, MINUTO, SEGUNDOS e
MICROSSEGUNDOS. O formato lido por um programa é função do comando
utilizado para ler a coluna.
Sintaxe para definir uma coluna TIMESTAMP:
Nome-da-coluna TIMESTAMP
Exemplo:
DATA-CRIACAO TIMESTAMP
1.2.5.4 FORMATO ROWID - O formato ROWID define uma coluna onde o DB2 gerará uma
identificação única da linha que está sendo inserida na tabela
(UNIQUE KEY). Pode ser usada em tabelas que não possuem
UNIQUE KEY. Sintaxe para sua definição:
Nome-da-coluna ROWID
Exemplo:
ID-MENSAGEM ROWID
1.2.6 CONSTANTES.
No DB2 as constantes alfanuméricas devem ser colocadas entre aspas simples.
Ex.: ´JOSE´

7
DB2
As constantes numéricas são escritas sem as aspas. As constantes com decimais devem usar o
ponto para separar as decimais.
Ex.: 14.55
As constantes de DATA e HORA devem ser escritas no formato do exemplo abaixo:
14/02/2005
16:35
1.2.7 SPECIAL REGISTERS.
SPECIAL REGISTERS são variáveis internas do DB2 com informações do ambiente que os
programas podem acessar e usar. A lista é extensa, e apresentamos abaixo uma relação das mais
usadas:
CURRENT DATE DATA DO SISTEMA OPERACIONAL NO FORMATO DATE – AAMMDD

CURRENT TIME HORA DO SISTEMA OPERACIONAL NO FORMATO TIME - HHMMSS
CURRENT DATA E HORA DO SISTEMA OPERACIONAL NO FORMATO
TIMESTAMP TIMESTAMP CHAR(26)
USER USUÁRIO DO SISTEMA NO FORMATO CHAR(8)

8
DB2
2 - LINGUAGEM SQL.
O SQL é a linguagem usada para acessar quase todos os bancos de dados relacionais atuais. No
caso do DB2, os comandos SQL podem ser incluídos nos programas escritos em Cobol, Assembler,
C, C++, PL/I, PROLOG, JAVA e outras.
Os comandos SQL podem ser incluídos nos programas em um dos modos abaixo:
STATIC SQL – Neste modo os comandos SQL são codificados dentro do programa fonte. Os
comandos são pré-compilados e portanto são fixos no programa.
DYNAMIC SQL – Neste modo os comandos são informados ao programa em tempo de
execução. O comando é passado em forma de texto para o DB2, para ser resolvido e executado.
ODBC – Neste caso os comandos são passados pelo programa para um utilitário chamado DB2
OPEN DATABASE CONNECTIVITY(ODBC). Este utilitário é o encarregado de interpretar o comando
e executá-lo junto ao DB2. A ODBC só pode ser usada em programas C.
JDBC – É a ODBC para programas em JAVA. A linguagem JAVA tem também o componente
SQLJ que é voltado para tratamento de SQL ESTATICOS.
2.1 - AMBIENTES PARA USO DO SQL.
Os comandos SQL podem ser submetidos para o DB2 pelos seguintes produtos:
 QMF (QUERY MANAGEMENT FACILITY)

Este é um produto da IBM para submeter os comandos SQL para o DB2 e visualizar os
resultados.
 TSO (Time Sharing Options)

O TSO tem uma opção dentro do menu DB2 chamado SPUFI. O SPUFI tem um menu onde
o usuário especifica um data set (pode ser um particionado) contendo o texto do comando
SQL a ser executado, e um data set para receber o resultado do comando. Usando o SPUFI
o usuário pode facilmente executar quase todos os comandos SQL.
 PROGRAMAS.
Os comandos SQL podem ser codificados dentro de programas escritos em várias
linguagens, incluindo o Cobol.
2.2 - COMANDOS SQL.

A Linguagem SQL pode ser separada em três grupos:
 DML
Data Manipulation Language, utilizado para fazer pesquisas e atualizações nas tabelas
DB2.
 DDL
Data Definition Language, utilizado para definir, alterar e eliminar objetos DB2.
 CONTROL
Utilizado para administrar a segurança dos recursos DB2.

9
DB2
STRUCTURED
QUERY
LANGUAGE
SELECT CREATE GRANT

INSERT ALTER REVOKE
UPDATE DROP COMMIT
DELETE ROLLBACK
DML DDL CONTROL
2.2.1 - CRIANDO TABELAS.
Os comandos SQL para criar e alterar tabelas não são usados em programação de aplicativos.
Informamos abaixo sua sintaxe somente para completar os conhecimentos sobre a linguagem SQL.
O comando SQL para criar uma nova TABLE é o CREATE TABLE. Podem ser criadas tabelas com
até 750 colunas e 16 terabytes de tamanho total. O comando define o nome da tabela seguido de
uma serie de especificações de colunas como no exemplo:
CREATE TABLE PRODUTO

(CODIGO CHAR(6) UNIQUE,
NOME VARCHAR(20) ,
PRECO DECIMAL(8,2) NOT NULL,
DEPTOFABR CHAR(3),
DATAFABR DATE DEFAULT)
Neste exemplo o argumento UNIQUE que aparece em CODIGO indica que o valor desta coluna não
pode se repetir nas linhas da tabela.
O argumento NOT NULL da coluna PRECO indica que nas inclusões de novas linhas na tabela
(inclusão de novos produtos no cadastro), o PRECO deve sempre ser informado.
O argumento DEFAULT da coluna DATAFABR indica que nas inclusões de produtos, se a coluna
DATAFABR não for informada, o DB2 preencherá esta coluna com o valor “default” para datas, que é
a data corrente do sistema operacional. O argumento DEFAULT para colunas com tipo alfanumérico
preenche o campo com espaços, e quando o tipo for numérico a coluna será preenchida com zeros.
Outro exemplo:
CREATE TABLE DEPTO

(CODDEPTO CHAR(3) PRIMARY KEY NOT NULL,
NOMEDEPTO CHAR(10) NOT NULL,
ENDERDEPTO VARCHAR(60))

10
DB2
Neste exemplo a tabela DEPTO esta sendo criada com a chave primaria CODDEPTO.
O comando CREATE pode ser usado também para criar índices para colunas definidas como
UNIQUE ou PRIMARY KEY. Os índices aumentam a performance das pesquisas que usam esta
coluna. Exemplo:
CREATE UNIQUE INDEX IDXDEPTO

ON DEPTO(CODDEPTO)
2.2.2 - ALTERANDO TABELAS.

O comando SQL para alterar a estrutura de uma tabela é o ALTER TABLE. Este comando pode ser
usado tanto para alterar a especificação das colunas já existentes como para transformar as colunas
em PRIMARY KEY ou criar INDICES para colunas para aumentar a performance nas pesquisas.
Exemplos:
ALTER TABLE PRODUTO
(PRIMARY KEY(CODIGO),
FOREIGN KEY(DEPTOFABR)
REFERENCES DEPTO
ON DELETE SET NULL)
Este exemplo transforma a coluna CODIGO (que já era UNIQUE) em PRIMARY KEY. Também
transforma a coluna DEPTOFABR em chave estrangeira para a tabela DEPTO. Depois desta
alteração, uma linha de PRODUTO somente poderá ser incluída se houver na tabela DEPTO uma
linha descrevendo o departamento onde este produto será fabricado. Também foi definida uma
restrição para a exclusão da linha do departamento em DEPTO, especificando que se a linha DEPTO
for excluída o DB2 deverá inserir NULL na coluna DEPTOFABR dos produtos relacionados.
2.2.3 - EXCLUINDO TABELAS.

O comando para excluir uma tabela do DB2 é o DROP TABLE. Exemplo:
DROP TABLE PRODUTO
2.2.4 - ACESSANDO E ATUALIZANDO TABELAS.
Os comandos SQL que acessam e atualizam as tabelas serão os comandos que utilizaremos nos
programas aplicativos.
São 4 os comandos SQL usados neste grupo:
SELECT
INSERT
UPDATE
DELETE
2.2.4.1 - SELECT.
O objetivo do comando SELECT é pesquisar dados dentro do DB2. Ele especifica o formato de uma
tabela para conter o resultado da pesquisa e outros parâmetros para definir o processo de pesquisa.
O formato básico do SELECT é
SELECT colunas-ou-valores
FROM tabela, tabela
WHERE condição

11
DB2
Em colunas-ou-valores é especificado o conjunto de colunas ou valores que deverão compor a tabela

resultado da pesquisa. O caracter asterisco (*) pode ser usado em colunas-ou-valores para indicar
que todas as colunas da tabela devem ser selecionadas.
No argumento FROM indicam-se os nomes das tabelas de onde serão retiradas as colunas para
formar a tabela resultado.
No argumento WHERE (que é opcional) especificam-se os critérios de pesquisa.
Exemplo:
SELECT CODFUNC NOMEFUNC SALARIO
FROM EMPREGADOS
WHERE SALARIO > 1000
Neste exemplo a tabela resultado conterá uma relação com o código, nome e salário dos funcionários
da tabela EMPREGADOS, para os empregados que ganham mais de 1000,00.
SELECT *
FROM EMPREGADOS
Este exemplo lista todas as colunas de todos os empregados da tabela.

Os critérios de pesquisa do argumento WHERE envolvem comparações entre valores de colunas,
variáveis, expressões aritméticas ou constantes empregando os operadores da tabela:
Operador Descrição
= != <> Igual Não igual Diferente
> !> >= Maior Não maior Maior ou igual
< !< <= Menor Não menor Menor ou igual
BETWEEN O valor deve estar entre os dois limites
Ex.: IDADE BETWEEN 1 AND 9
IN O valor deve ser um dos fornecidos na lista
Ex.: IDADE IN (1, 3, 5, 7, 9)
LIKE O valor deve ser semelhante ao indicado. No literal indicado pode-se usar % para
representar um conjunto de caracteres, ou _ para representar a posição de um
caracter.
Ex.: NOME LIKE „ALBERTO‟
NOME LIKE „AL%‟ Nomes iniciando com AL
NOME LIKE „%O‟ Nomes Terminando com O
NOME LIKE „%L%‟ Nomes que contenham L
NOME LIKE „___E%‟ Nome com E na posição 4.
O operador NOT pode ser usado junto com quarquer dos operadores acima.
Exemplo:
IDADE NOT IN (1,3,5,7)

12
DB2
Exercícios.
Descreva o resultado dos comandos:
SELECT CODIGO NOME FROM

FUNCIONARIOS
SELECT * FROM FUNCIONARIOS
SELECT CODIGO NOME

FROM FUNCIONARIOS
WHERE CARGO = „VENDAS‟
SELECT NOME SALARIO

FROM FUNCIONARIOS
WHERE CARGO = „VENDAS‟
AND SALARIO > 1000
SELECT NOME SALARIO

FROM FUNCIONARIOS
WHERE SALARIO BETWEEN
500 AND 2000
SELECT CODIGO NOME

FROM FUNCIONARIOS
WHERE CARGO IN
(„VENDAS‟,‟COBRANCA‟)
SELECT NOME
FROM FUNCIONARIOS
WHERE NOME LIKE
„MARIA%‟
SELECT NOME SALARIO

FROM FUNCIONARIOS
WHERE SALARIO * 12 >
50000

13
DB2
2.2.4.1.1 - ORDENAÇÃO DA TABELA RESULTADO.
O DB2 pode ordenar as linhas na tabela resultado com a seguinte sintaxe:
SELECT DISTINCT colunas-ou-valores

FROM tabela, tabela
WHERE condição
ORDER BY colunas ASC
Com esta sintaxe a tabela resultado será ordenada pelas colunas especificadas no argumento
ORDER BY. O argumento DISTINCT é opcional, e quando especificado a tabela resultado não
conterá linhas repetidas.
O argumento ASC da clausula ORDER BY é opcional (pode ser DESC), e indica se a ordenação é
crescente ou decrescente.
2.2.4.1.2 - AGRUPANDO LINHAS NO RESULTADO.
A tabela resultado pode ter suas linhas agrupadas e resumidas segundo o valor de uma coluna
especifica com a sintaxe:
SELECT colunas-ou-valores
FROM tabela, tabela
WHERE condição
GROUP BY colunas
HAVING condição
Com esta sintaxe, cada linha da tabela resultado será o resumo das linhas pesquisadas para cada
valor das colunas especificadas em GROUP BY. O argumento HAVING é opcional, e se especificado
conterá as condições de seleção de cada grupo gerado pelo GROUP BY. Na prática, o argumento
HAVING é o WHERE do GROUP BY.
Exemplos:
SELECT DISTINCT NOME Lista os nomes dos funcionários em ordem

FROM FUNCIONARIOS alfabética.
ORDER BY NOME
SELECT CARGO, SUM(SALARIO) Lista os cargos e respectiva soma de salários da
FROM FUNCIONARIOS tabela de funcionários somente para os cargos cuja
GROUP BY CARGO soma de salários é superior a N$10000,00
HAVING SUM(SALARIO) > 10000
2.2.4.1.3 - BUILT-IN FUNCTIONS.
O DB2 possui um conjunto de funções pre-programadas que podem ser usadas pelos comandos
SQL. Os argumentos passados para as funções podem ser colunas de uma tabela ou expressões
com constantes e variáveis não pertencentes ao DB2.
Quando todos os argumentos não pertencem ao DB2, não existe uma tabela para preencher o
argumento FROM do SELECT. Neste caso deve-se usar a pseudo-tabela SYSIBM.SYSDUMMY1 no
argumento FROM. Exemplo de um SELECT para calcular a raiz quadrada de 25:

14
DB2
SELECT SQRT(25)
FROM SYSIBM.SYSDUMMY1
A lista de funções é extensa e as principais estão na tabela seguinte:
AVG(DISTINCT colunas-ou- Obtém a media aritmética dos valores das colunas ou

expressões) expressões. Se DISTINCT for usado, os valores repetidos
serão desprezados.
COUNT(DISTINCT colunas-ou- Obtém a quantidade de linhas selecionadas. Se DISTINCT
expressões) for usado, as linhas repetidas não serão contadas.
MAX(colunas-ou-expressões) Obtém o maior valor contido nas colunas ou expressões
selecionadas.
MIN(colunas-ou-expressões) Obtém o menor valor contido nas colunas ou expressões
selecionadas.
SUM(DISTINCT colunas-ou- Obtém a soma dos valores das colunas ou expressões
expressões) selecionadas. Se DISTINCT for usado, os valores
repetidos não serão somados.
ABS(expressão) Obtém o valor absoluto de uma expressão.
ABSVAL(expressão)
CHAR(expressão) Converte o resultado de expressão para STRING. O
resultado de expressão pode estar nos formatos:
INTEGER ou SMALLINT
DECIMAL
REAL ou DOUBLE
CHAR(date,formato) Para converter valores do formato DATETIME para formato
CHAR coloca-se no argumento FORMATO o formato da
data que deve ser um destes:
ISO yyyy-mm-dd
USA mm/dd/yyyy
EUR dd.mm.yyyy
JIS yyyy-mm-dd
LOCAL conforme instalação.
VALUE(expressão,expressão) Retorna o valor da primeira expressão cujo valor não for
COALESCE(expressão,expressão) NULL.
CONCAT(expressão,expressão) Retorna um STRING formado pela união das duas
expressões
DAYOFYEAR(expressão) Devolve o dia do ano (numero entre 1 e 366) contido na
expressão que deve ser do tipo DATE.
DATE(expressão-ou-coluna) Devolve um valor DATE contido na expressão ou coluna
DAY(expressão) Devolve o dia do mês se a expressão for do tipo DATE, ou
a quantidade de dias se a expressão representar uma
diferença de datas.
DAYOFMONTH(expressão) Devolve o dia do mês (entre 1 e 31) retirado da expressão,
que deve ser do tipo DATE
DAYOFWEEK(expressão) Devolve o dia da semana contido na expressão que deve
DAYOFWEEK_ISO(expressão) ser do tipo DATE. O dia da semana devolvido é um
numero entre 1 e 7:
Para DAYOFWEEK : 1=Domingo
Para DAYOFWEEK_ISO : 1 = Segunda feira
DAYS(expressão) Devolve um numero inteiro representando o numero de
dias transcorridos entre o valor DATE da expressão e o
dia 01/01/0001.
DECIMAL(expressão,n1,n2) Transforma o valor de expressão em valor no formato
DEC(expressão,n1,n2) DECIMAL, contendo um total de n1 algarismos e n2
15
DB2
decimais.
DIGITS(expressão) Retorna o valor da expressão com os algarismos no
formato de um STRING de caracteres. A expressão deve
estar no formato INTEGER, SMALLINT ou DECIMAL.
DOUBLE(expressão) Retorna o valor da expressão ou coluna no formato
FLOAT(expressão) DOUBLE.
HEX(expressão) Retorna um STRING de dígitos hexadecimais com o valor
da expressão.
HOUR(expressão) Retorna o valor da HORA contido na expressão.
Expressão deve ter formato TIME ou TIMESTAMP.
INSERT(string1,inicio,tamanho,string2) Insere STRING2 em STRING1 a partir da posição INICIO
apagando TAMANHO bytes de STRING1.
INTEGER(expressão) Retorna o valor da expressão no formato INTEGER
INT(expressão)
LCASE(string) Converte os caracteres de STRING para minúsculos.
LOWER(string)
LEFT(string1,tamanho) Retorna um STRING com o comprimento TAMANHO
retirado do inicio de STRING1
LENGTH(expressão) Retorna o numero de caracteres do valor da expressão
(ou coluna)
LOCATE(string1,string2,inicio) Pesquisa a posição de STRING1 dentro de STRING2.
INICIO é opcional e especifica a posição do caracter em
STRING2 onde a pesquisa inicia.
LTRIM(string1) Remove SPACES do inicio de STRING1
MICROSECOND(expressão) Devolve o valor dos MICROSSEGUNDOS contidos na
expressão. Expressão precisa ter formato TIME ou
TIMESTAMP.
MINUTE(expressão) Devolve o valor dos MINUTOS contidos na expressão.
Expressão deve ter formato TIME ou TIMESTAMP
MOD(expressão1,expressão2) Esta função devolve o resto da divisão de EXPRESSÃO1
por EXPRESSÃO2
MONTH(expressão) Devolve o valor do MES contido na expressão.
Expressão deve ter formato DATE ou TIMESTAMP
POWER(expressão1,expressão2) Calcula o valor de EXPRESSÃO1 elevada a potencia
indicada em EXPRESSÃO2.
REPEAT(string1,quantidade) Devolve um STRING formado pela repetição de STRING1
vezes QUANTIDADE.
REPLACE(string1,string2,string3) Substitui todas as ocorrências de STRING2 por STRING3
dentro de STRING1
RIGHT(string,tamanho) Devolve os últimos TAMANHO caracteres de STRING
RTRIM(string) Remove os espaços do fim de STRING.
SECOND(expressão) Devolve o valor dos SEGUNDOS contidos na expressão.
Expressão deve ter formato TIME ou TIMESTAMP
SMALLINT(expressão) Retorna o valor da expressão no formato SMALLINT
SPACE(expressão) Produz um STRING no formato VARCHAR contendo
espaços com o comprimento dado pelo valor de
EXPRESSÃO.
SQRT(expressão) Devolve a raiz quadrada do valor de EXPRESSÃO. O
resultado tem formato DOUBLE.
SUBSTR(string1,inicio,tamanho) Devolve um STRING extraído de STRING1 a partir de
INICIO. O argumento TAMANHO é opcional, e indica o
comprimento do resultado. Se TAMANHO for omitido, a
extração se inicia em INICIO até o fim de STRING1.
TIME(expressão) Converte EXPRESSÃO para o formato TIME.
16
DB2
TIMESTAMP(expressão) Converte EXPRESSÃO para o formato TIMESTAMP.

UCASE(string) Converte STRING para maiúsculas.
UPPER(string)
VARCHAR(expressão) Converte o resultado de EXPRESSÃO para VARCHAR.
WEEK(expressão) Devolve o valor da SEMANA DO ANO (entre 1 e 54)
contido na expressão. Expressão deve ter formato DATE
ou TIMESTAMP
YEAR(expressão) Devolve o valor do ANO contido na expressão. Expressão
deve ter formato DATE ou TIMESTAMP
Exercícios. Descreva a tabela resultado dos SELECT abaixo
SELECT SUM(SALARIO),
AVG(COMISSAO)
FROM FUNCIONARIOS
WHERE DEPTO = „A10‟
SELECT MAX(SALARIO),
MIN(SALARIO)
FROM FUNCIONARIOS
SELECT CARGO,
SUM(SALARIO)
FROM FUNCIONARIOS
GROUP BY CARGO
HAVING
SUM(SALARIO) > 10000
SELECT SALARIO,
DECIMAL(SALARIO,6,1),
INTEGER(SALARIO),
HEX(SALARIO),
DIGITS(SALARIO)
FROM FUNCIONARIOS
SELECT NOME,
LENGTH(NOME)
FROM FUNCIONARIOS
SELECT SUBSTR(NOME,1,3)
FROM FUNCIONARIOS
SELECT COUNT(*)
FROM FUNCIONARIOS
SELECT NOME,
VALUE(COMISSAO,0)
FROM FUNCIONARIOS
WHERE COMISSAO IS NULL
SELECT NOME,
CHAR(DT_NASC, EUR)
FROM FUNCIONARIOS
WHERE CODFUNC = 10

17
DB2
2.2.4.1.4 - JOIN
O JOIN é o processo do SELECT de pesquisar dados de mais de uma tabela. A tabela resultado
conterá valores provenientes de colunas das varias tabelas.
Para que seja possível esta união das linhas de varias tabelas para compor uma linha da tabela
resultado, é necessário que as linhas das varias tabelas tenham em comum uma coluna que tenha
valores correspondentes.
Para exemplificar, vamos usar 2 tabelas:FUNCIONARIOS e DEPARTAMENTO com as seguintes
colunas:
Tabela FUNCIONARIOS
CODFUN
NOMEFUN
DEPTO
SALARIO
Tabela DEPARTAMENTO
CODDEPTO
NOMEDEPT
Queremos fazer uma relação de funcionários com o nome do departamento em que trabalham. A
tabela resultado deste SELECT deverá conter CODFUN, NOMEFUN tirados da tabela
FUNCIONARIOS e conter NOMEDEPTO tirado da tabela DEPARTAMENTO. Este SELECT deverá
fazer um JOIN destas duas tabelas usando como colunas de ligação DEPTO e CODDEPTO. O
SELECT será o seguinte:
SELECT CODFUN, NOMEFUN, NOMEDEPTO

FROM FUNCIONARIOS, DEPARTAMENTO
WHERE FUNCIONARIOS.DEPTO =
DEPARTAMENTO.CODDEPTO.
Podemos colocar as seguintes regras para construir um JOIN:

1- As tabelas envolvidas precisam ter uma coluna com valores iguais.
2- A clausula WHERE do SELECT deve especificar esta correspondência entre colunas.
3- Não é necessário que as colunas do JOIN sejam ligadas como FOREIGN KEY. Esta declaração
só tem finalidade para garantir a INTEGRIDADE RELACIONAL.
4- Note que na clausula WHERE as colunas estão prefixadas pelo nome da tabela. O esquema de
prefixação (nome da tabela, nome da coluna separados por ponto) é usado aqui para definir o JOIN.
O esquema de prefixação pode ser usado no entanto em qualquer local dos comandos SQL para
resolver ambigüidades de nomes de colunas entre varias tabelas.
2.2.4.1.5 - SUB-QUERIES.
O processo de SUB-QUERIES acontece quando os elementos de comparação da clausula WHERE

de um SELECT são resultado de um segundo SELECT. Neste caso usamos um encadeamento de
SELECTS, o que configura o uso de SUB-QUERIES.
Exemplo: - Queremos uma lista dos funcionários do departamento P1 cujo salário é menor que a
media dos salários do departamento P2. Temos aqui o SELECT principal que produz a lista de
funcionários do departamento P1, e o SELECT auxiliar que calcula a media dos salários do
departamento P2. O SELECT completo com a SUB-QUERY fica:
SELECT NOME SALARIO

FROM FUNCIONARIOS
WHERE CODDEPTO = `P1` AND
18
DB2
SALARIO < (
SELECT AVG(SALARIO)
FROM FUNCIONARIOS
WHERE CODDEPTO = `P2`)
No exemplo , a SUB-QUERY produziu somente uma linha. Nos casos em que a SUB-QUERY produz
mais de uma linha, existem operandos no SELECT para decidir o campo de ação da condição do
WHERE. Estes operandos são os do quadro:
A condição do WHERE deve ser satisfeita para TODAS as linhas

ALL
da SUB-QUERY.
IN
A condição do WHERE deve ser satisfeita pelo menos por UMA
ANY
linha da SUB-QUERY
SOME
O WHERE é verdadeiro se a SUB-QUERY tiver pelo menos
EXISTS
UMA linha.
Exemplos:. Indique o resultado destas QUERIES:
SELECT NOME SALARIO

FROM FUNCIONARIOS
WHERE CODDEPTO = `P1` AND SALARIO > ALL (
SELECT SALARIO
FROM FUNCIONARIOS
SELECT NOME SALARIO

FROM FUNCIONARIOS
WHERE CODDEPTO = `P1` AND SALARIO > ANY (
SELECT SALARIO
FROM FUNCIONARIOS
SELECT NOME SALARIO

FROM FUNCIONARIOS
WHERE CODDEPTO = „P1‟
AND EXISTS(
SELECT CODPROJ
FROM FUNCIONARIOS
WHERE CODEPTO = `P1`)
2.2.4.2 - INSERT
O comando INSERT é usado para incluir novas linhas em uma tabela.
Sua sintaxe :
INSERT INTO nome-tabela

(coluna, coluna ...)
VALUES(valor, valor ....)

19
DB2
Este comando SQL define o nome da tabela onde a linha vai ser incluída, em seguida dentro de
parênteses, uma serie de colunas para as quais vão ser informados os valores, e apos o argumento
VALUES, os valores de cada coluna da serie acima.
Quando se inclui uma nova linha em uma tabela, não é necessário fornecer valores para todas as
colunas da linha. Somente as colunas definidas como NOT NULL devem receber obrigatoriamente
valores. As colunas que não recebem valores na inclusão da linha permanecem como colunas
inexistentes na linha (valor = NULL) até que uma alteração crie esta coluna.
A serie de colunas informada no comando INSERT pode ser informada em qualquer ordem, isto é, as
colunas no INSERT não precisam estar na ordem de sua criação na tabela.
Nos casos em que o INSERT preenche valores para todas as colunas da tabela, a seqüência de
colunas pode ser omitida, e o comando se simplifica como:
INSERT INTO tabela

VALUES (valor, valor ....)
Neste caso terá de ser informado os valores de todas as colunas na seqüência em que as colunas
foram definidas na tabela.
Exemplo de comando INSERT:
INSERT INTO EMPREGADOS

(CODEMP, NOMEEMP, SALARIO)
VALUES(„P4550‟,‟JOSE DA SILVA‟,1325.50)
2.2.4.3 – UPDATE
O comando UPDATE é usado para alterar valores em uma ou mais linhas de uma tabela. O comando
enumera as colunas e seus novos valores.
Há duas sintaxes para este comando, porem as duas são equivalentes.
Primeiro formato:
UPDATE nome-da-tabela
SET coluna=valor, coluna=valor, .......
WHERE condição
Exemplo:
UPDATE EMPREGADOS
SET SALARIO=SALARIO * 1.10, BONUS=NULL, COMISSAO=10.00
WHERE CODDEPTO = `P10`
Segundo formato:
UPDATE nome-da-tabela
SET (coluna, coluna, ......)
=(valor, valor, ......)
WHERE condição

20
DB2
Exemplo:
UPDATE EMPREGADOS
SET(SALARIO, BONUS, COMISSAO)
= (SALARIO * 1.10, NULL, 10.00)
2.2.4.4 - DELETE
O comando DELETE exclui linhas inteiras de uma tabela selecionadas pela clausula WHERE. Se a
clausula WHERE não for especificada em um comando DELETE, todas as linhas da tabela serão
apagadas.
Sintaxe:
DELETE FROM nome-da-tabela

WHERE condição
Exemplo:
DELETE FROM EMPREGADOS

WHERE CODEMP = `525252`

21
DB2
3 - PROGRAMANDO EM COBOL
3.1 - INTRODUÇÃO
3.1.1 - FORMATO DOS COMANDOS.
Para codificar um comando SQL em Cobol é suficiente colocar o comando como foi exposto nos
paragrafos anteriores entre as palavras EXEC SQL e END-EXEC como no modelo:
EXEC SQL
Comando
END-EXEC
Exemplo:
EXEC SQL
SELECT *
FROM FUNCIONARIOS
END-EXEC.
3.1.2 – HOST VARIABLES.
Em um programa Cobol os comandos SQL precisam trocar ou comparar valores entre as colunas do
banco de dados e as variaveis do programa. Por exemplo, em um SELECT o DB2 precisará mover
dados de suas colunas para as variaveis do Cobol.
Quando esta troca de informações é realizada, é necessário haver uma compatibilidade completa
entre o formato do dado nas colunas do DB2 e na variavel do Cobol, pois ao contrario do Cobol que
ajusta o formato dos dados nas trocas, o DB2 nas faz nenhuma conversão de formato nestas
operações.
As variaveis Cobol usadas dentro dos comandos SQL recebem o nome de HOST VARIABLES.
Qualquer variavel definida no Cobol pode ser usada como HOST VARIABLE, desde que seu formato
seja completamente compativel (tamanho, PICTURE, decimais etc) com a coluna da tabela com a
qual troca dados.
Para resolver os problemas de compatibilidade, para cada tabela usada no programa define-se na
WORKING-STORAGE uma area de acesso (equivalente a FD do Cobol), contendo todas as colunas
da tabela com o formato conveniente. O DB2 possui um utilitário para produzir estas areas de
comunicação, chamado DCLGEN. O DCLGEN pode ser acionado pelo TSO.
A área produzida pelo DCLGEN é declarada no programa Cobol com o seguinte comando
EXEC SQL
INCLUDE nome-da-area
END-EXEC.
Mostramos abaixo um exemplo de declaração da tabela DBADB2.PRODUTO produzida pelo

DCLGEN:

22
DB2
EXEC SQL DECLARE DBADB2.PRODUTO TABLE

( CODIGO CHAR(6) NOT NULL,
NOME VARCHAR(20) NOT NULL,
QUANTIDADE INTEGER,
PRUNIT DECIMAL(5, 2)
) END-EXEC.
******************************************************************
* COBOL DECLARATION FOR TABLE DBADB2.PRODUTO *
******************************************************************
01 DCLPRODUTO.
10 CODIGO PIC X(6).
10 NOME.
49 NOME-LEN PIC S9(4) USAGE COMP.
49 NOME-TEXT PIC X(20).
10 QUANTIDADE PIC S9(9) USAGE COMP.
10 PRUNIT PIC S9(3)V9(2) USAGE COMP-3.
*****************************************************************
* INDICATOR VARIABLE STRUCTURE *
*****************************************************************
01 IPRODUTO.
10 INDSTRUC PIC S9(4) USAGE COMP OCCURS 4 TIMES.
****************************************************************
* THE NUMBER OF COLUMNS DESCRIBED BY THIS DECLARATION *
* IS 4 *
Todos os comandos SQL devem portanto usar HOST VARIABLES contidos dentro destas areas
produzidas pelo DCLGEN. No exemplo acima estas variaveis estão na area DCLPRODUTO.
Quando usadas nos comando SQL as HOST VARIABLES devem sempre estar precedidas pelo
caracter dois pontos(:). Se o compilador de comandos SQL encontra o (:) antes de uma palavra, ela é
interpretada como HOST VARIABLE, caso contrario é interpretada como nome de coluna do DB2.

23
DB2
3.1.2.1 - INDICATORS.
INDICATORS são variaveis do programa Cobol usadas nos comandos SQL para:
- Informar o comprimento real dos valores contidos em colunas VARCHAR.
- Informar se uma coluna contem NULL.
- Informar erros de conversão entre o valor das colunas e as HOST VARIABLES.
Os INDICATORS devem ser variaveis com formato S9(4) COMP, e quando necessario deve haver
um INDICATOR para cada coluna da tabela.
Na area de declaração da tabela, o DCLGEN ja preve um conjunto de INDICATORS. No exemplo da
tabela DBADB2.PRODUTO mostrada no paragrafo anterior, a variavel NOME-LEN é o INDICATOR
da variavel NOME, que corresponde a uma coluna VARCHAR. Para as outras colunas que não são
VARCHAR, existe uma tabela de INDICATORS (a tabela INDSTRUCT), com 1 INDICATOR para
cada coluna:
INDICATOR COLUNA
INDSTRUCT(1) CODIGO
INDSTRUCT(2) NOME
INDSTRUCT(3) QUANTIDADE
INDSTRUCT(4) PRUNIT
3.1.3 - TESTE DE ERRO NOS COMANDOS.
3.1.3.1 - SQLCODE
O DB2 utiliza uma variavel de nome SQLCODE para retornar o STATUS de todos os comandos SQL.
A variavel SQLCODE esta contida na area SQLCA que deve ser declarada na WORKING-STORAGE
dos programas com a sintaxe:
EXEC SQL
INCLUDE SQLCA
END-EXEC.
Os valores a serem testados no SQLCODE são
SQLCODE = 0 Execução sem erro.

SQLCODE < 0 Comando não foi executado. O codigo do erro é o
valor do SQLCODE.
SQLCODE > 0 O comando foi executado, com um WARNING dado
pelo valor do SQLCODE.
Os codigos de erro dados pelo SQLCODE podem ser encontrados no manual de erros da IBM (DB2
MESSAGES AND CODES).
É necessário testar o código de retorno para todos os comandos SQL executáveis (Os comandos
DECLARE não são executáveis).

24
DB2
Alguns valores importantes do SQLCODE:
SQLCODE = 100 Linha pesquisada não existe

SQLCODE = -803 Linha com esta PRIMARY KEY já existe
* Lista completa dos SQLCODES no apêndice A
3.1.3.2 - WHENEVER
A clausula WHENEVER do DB2 pode ser usada para substituir os testes do SQLCODE, e tem um
funcionamente identico ao comando HANDLE CONDITION do CICS, isto é, ela define uma ação no
programa para onde a execução continuará quando ocorrer o erro apontado no WHENEVER. O
WHENEVER no entanto somente intercepta 3 condições de erro:
SQLWARNING Intercepta WARNINGS nos comandos
SQLERROR Intercepta qualquer erro nos comandos
SQL NOT FOUND Itercepta a condição „valores não entrados‟ na tabela.
Também so podem ser programadas 2 ações para o processar os erros interceptados:
GO TO paragrafo A execução se desvia para o

paragrafo.
CONTINUE A execução continua na proxima
sentença.
Como resultado das definições acima, a sintaxe do WHENEVER pode ser uma das
seguintes:
EXEC SQL
WHENEVER condição
GO TO paragrafo
END-EXEC
Ou
EXEC SQL
WHENEVER condição
CONTINUE
END-EXEC

25
DB2
Exemplo:
EXEC SQL
WHENEVER NOT FOUND
GO TO NÃO-EXISTE
END-EXEC
3.2 - ACESSANDO TABELAS COM O COBOL.
Para se ler dados de uma tabela em um programa Cobol o comando básico usado é o SELECT visto
nos itens anteriores deste manual. O SELECT precisa somente ser ampliado para definir as HOST
VARIABLES que devem receber os dados.
Existem dois processos de leitura no DB2: o primeiro aplica-se quando o SELECT devolve somente
uma linha da tabela, e o segundo processo quando a tabela resultado do SELECT contem mais de
uma linha.
3.2.1 - ACESSANDO 1 LINHA DA TABELA.
Quando a tabela resultado do SELECT contem somente uma linha, o parâmetro INTO acrescentado
ao SELECT é suficiente para definir as HOST VARIABLES de leitura. A sintaxe deste SELECT é:
EXEC SQL
SELECT coluna, coluna, ...
INTO variavel, variavel, ....
FROM tabela
WHERE condição
END-EXEC
A variavel do parametro INTO deve ser uma HOST VARIABLE (portanto precedida por dois pontos).
Alem disso, se a coluna pesquisa for do tipo VARCHAR ou a sua definição permitir valores NULL, é
necessario acrescentar um INDICATOR na HOST VARIABLE respectiva. Este INDICATOR receberá
um dos seguintes valores apos a execução do SELECT:
INDICATOR = -1 Coluna contem NULL

INDICATOR = -2 Erro na conversão de valores
INDICATOR = 0 Coluna contem valores normais
INDICATOR > 0 Comprimento original dos dados que foram
truncados no momento da carga na HOST
VARIABLE ou comprimento de um VARCHAR
Para se codificar o INDICATOR, basta coloca-lo apos a HOST VARIABLE, precedido ou não pela
palavra INDICATOR.
Sintaxes:
:variavel :indicator, :variavel ......
Ou
:variavel INDICATOR :indicator, :variavel.....

26
DB2
Exemplo:
MOVE `000001` TO CODIGO.
EXEC SQL
SELECT NOMEEMP, SALARIO
INTO :NOME INDICATOR :INDNOME, :SALARIO
WHERE CODEMP = :CODIGO
END-EXEC.
Este exemplo lê o nome e salário do empregado 000001. Note que as variáveis NOME, SALARIO e
CODIGO que estão precedidas por (:) são as HOST VARIABLES, e devem estar incluídas na área
do INCLUDE da declaração da tabela EMPREGADO na WORKING-STORAGE.
Também a HOST VARIABLE NOME esta acompanhada pelo seu INDICATOR INDNOME.
OBS.: Se na definição da HOST VARIABLE, houver um sub-nivel da variavel para servir como
INDICATOR, o INDICATOR pode ser omitido na clausula INTO. Exemplo:
.......
10 NOME.
49 NOME-TEXT PIC X(20).
49 NOME-LEN PIC S9(4) COMP.
PROCEDURE DIVISION.
.......
EXEC SQL
SELECT NOME, SALARIO
INTO :NOME, :SALARIO
WHERE CODDEP = :DEPTO
END-EXEC.
Se o comando SELECT estiver selecionando todas as colunas da tabela (SELECT *), o argumento
INTO pode apontar para o nivel 01 das HOST VARIABLES como no exemplo:
EXEC SQL
SELECT *
INTO :DCLPRODUTO
FROM DBADB2.PRODUTO
END-EXEC.
3.2.2 - ACESSANDO MAIS DE UMA LINHA DA TABELA.
Quando o SELECT monta uma tabela resultado com mais de uma linha, a linha resultado que deve
carregar as HOST VARIABLES na clausula INTO fica indefinida. Se a lógica da aplicação estiver
interessada na primeira linha da tabela resultado, a inclusão do parâmetro FETCH FIRST ROW
ONLY seleciona esta linha, e o comando abaixo pode ser aplicado:
EXEC SQL
SELECT coluna, coluna, ...
INTO variavel, variavel, ....
FROM tabela
WHERE condição
FETCH FIRST ROW ONLY
END-EXEC

27
DB2
Exemplo:
MOVE `000001` TO CODIGO.
EXEC SQL
SELECT NOMEEMP, SALARIO
INTO :NOME, :SALARIO
WHERE CODEMP > :CODIGO
FETCH FIRST ROW ONLY
END-EXEC.
3.2.2.1 - CURSOR.
Quando o comando SELECT cria a tabela resultado com mais de uma linha, e o programa precisa ler
todas estas linhas, é necessário usar o componente CURSOR.
O CURSOR é um componente (objeto) criado dentro do programa Cobol através de um comando,
contendo a definição da QUERY (SELECT). É usado para executar o SELECT e em seguida é usado
para ler cada uma das linhas da tabela resultado.
Um programa pode construir vários CURSOR, porem cada um deles deve ter um nome diferente. O
roteiro para operar o cursor é:
Declarar o CURSOR, definindo seu nome e o comando SELECT

Abrir o cursor com o comando OPEN. Neste instante o SELECT é executado.
Executar uma serie de comandos FETCH para ler cada uma das linhas resultado.
Fechar o CURSOR, para o DB2 liberar a tabela resultado.
Sintaxe da declaração do cursor:
EXEC SQL
DECLARE nome-do-cursor CURSOR FOR
Comando SELECT
END-EXEC
Sintaxe do FETCH
EXEC SQL
FETCH nome-do-cursor
INTO :variável, :variável, .....
END-EXEC
Sintaxe do OPEN CURSOR
EXEC SQL
OPEN nome-do-cursor CURSOR
END-EXEC

28
DB2
Sintaxe do CLOSE CURSOR
EXEC SQL
CLOSE nome-do-cursor CURSOR
END-EXEC
Exemplo de um trecho de programa usando CURSOR:
EXEC SQL
DECLARE LER-EMP CURSOR FOR
SELECT CODEMP NOMEMP
FROM FUNCIONARIOS
END-EXEC.
EXEC SQL
OPEN LER-EMP CURSOR
END-EXEC.
IF SQLCODE < 0
GO TO ERRO-SQL.
LEITURA.
EXEC SQL
FETCH LER-EMP CURSOR
INTO :CODIGO, :NOME INDICATOR :INDNOME
END-EXEC.
IF SQLCODE = +100
EXEC SQL
CLOSE LER-EMP CURSOR
END-EXEC
GO TO CONTINUAR.
IF SQLCODE < 0
GO TO ERRO-SQL.
DISPLAY `FUNCIONARIO ` CODIGO ` ` NOME
GO TO LEITURA.
CONTINUAR.
3.2.2.2 - SCROLLABLE CURSOR
No item anterior a tabela resultado foi lida pelo CURSOR seqüencialmente. Após lida a ultima linha
(SQLCODE = 100), o cursor foi fechado e a pesquisa encerrada.
Existe uma opção de CURSOR chamada SCROLLABLE CURSOR onde a pesquisa das linhas na
tabela resultado é aleatória. Esta técnica porem alem de ser mais complexa e pouco usada, exige a
criação pelo setor do suporte de arquivos temporários para suportar a tabela resultado, e não será
estudada neste curso.
3.3 - INCLUINDO LINHAS NA TABELA.

A sintaxe do comando para incluir linhas em uma tabela é a mesma vista nos conceitos de SQL,
somente acrescentando que os argumentos informados em VALUES podem ser constantes ou HOST
VARIABLES.
EXEC SQL
INSERT INTO tabela
(coluna, coluna, ...)
VALUES(valor, valor, ...)
END-EXEC

29
DB2
Se alguma das colunas do comando INSERT for do tipo VARCHAR, o INDICATOR precisa ser
carregado com o comprimento real do valor da coluna. Ex.:
MOVE 10 TO NOME-LEN
EXEC SQL
INSERT INTO PRODUTO
(CODIGO, NOME)
VALUES(:CODIGO, :NOME)
END-EXEC.
3.4 - ATUALIZANDO LINHAS DA TABELA.

A sintaxe do comando para atualizar linhas em uma tabela é a mesma vista no comando UPDATE de
SQL, somente acrescentando que os argumentos informados em VALUES podem ser constantes ou
HOST VARIABLES.
Há dois formatos para o comando UPDATE:
EXEC SQL
UPDATE tabela
SET(coluna, coluna, ...)
=(valor, valor, ...)
WHERE condição
END-EXEC
Ou
EXEC SQL
UPDATE tabela
SET coluna=valor, coluna=valor, ....
WHERE condição
END-EXEC
Se alguma das colunas do comando UPDATE for do tipo VARCHAR, o INDICATOR precisa ser
carregado com o comprimento real do valor da coluna. Ex.:
MOVE 10 TO NOME-LEN
EXEC SQL
UPDATE PRODUTO
SET NOME = :NOME
WHERE CODIGO = :CODIGO
END-EXEC.
3.4.1 - ATUALIZAÇÃO POSICIONADA.
Este tipo de atualização ocorre quando a atualização é feita em uma linha da RESULT TABLE que foi
posicionada por um comando FETCH de um CURSOR. Neste caso a clausula WHERE do UPDATE
não define a condição de seleção da linha, mas declara que está usando a posição corrente do
CURSOR.
Para usar uma atualização posicionada, a declaração do CURSOR precisa definir que ele será usado
para atualizações, preferivelmente citando a coluna que vai ser atualizada com a sintaxe seguinte:

30
DB2
EXEC SQL
SELECT linhas
FROM tabela
WHERE condição
FOR UPDATE OF coluna,coluna ....
END-EXEC
Se a lógica do programa não souber antecipadamente a coluna a ser atualizada numa atualização
posicionada, o CURSOR pode ser declarado para atualização generica com a sintaxe:
EXEC SQL
SELECT linhas
FROM tabela
WHERE condição
FOR UPDATE
END-EXEC
Quando o cursor foi declarado para atualização com as sintaxes acima, após cada FETCH o
programa pode atualizar a linha lida com a sintaxe abaixo:
EXEC SQL
UPDATE tabela
SET coluna=valor, coluna=valor, ....
WHERE CURRENT OF CURSOR
END-EXEC
OBS.: Se o SELECT do CURSOR contiver a clausula ORDER BY, a tecnica de atualização

posicionada somente poderá ser usada se o CUSOR for declarado SCROLLABLE.
A sintaxe do comando para excluir linhas em uma tabela é a mesma vista no comando DELETE de
SQL.
Sintaxe para o comando:
EXEC SQL
DELETE FROM tabela
WHERE condição
END-EXEC

31
DB2
Exemplo:
EXEC SQL
DELETE FROM PRODUTO
WHERE CODIGO = :CODIGO
END-EXEC.
3.5.1 - EXCLUSÃO POSICIONADA.
Este tipo de atualização ocorre quando é feita a exclusão de uma linha da RESULT TABLE que foi
posicionada por um comando FETCH de um CURSOR. Neste caso a clausula WHERE do DELETE
não define a condição de seleção da linha, mas declara que está usando a posição corrente do
CURSOR.
Para usar uma exclusão posicionada, a declaração do CURSOR precisa definir que ele será usado
para atualizações com a seguinte sintaxe:
EXEC SQL
SELECT linhas
FROM tabela
WHERE condição
FOR UPDATE
END-EXEC
Quando o cursor foi declarado para atualização com as sintaxes acima, após cada FETCH o
programa pode excluir a linha lida com a sintaxe abaixo:
EXEC SQL
DELETE FROM tabela
WHERE CURRENT OF CURSOR
END-EXEC
OBS.: Se o SELECT do CURSOR contiver a clausula ORDER BY, a tecnica de atualização

posicionada somente poderá ser usada se o CUSOR for declarado SCROLLABLE.
4 - COMMIT / ROLLBACK
COMMIT - Responsável por efetivar a transação corrente, pois quando se trabalha com um
banco de dados em que vários usuários vão utilizá-lo ao mesmo tempo, tem que se
efetivar a operação, pois sem o COMMIT a alteração não será visualizada para as
outras "sessões", salvo se a sessão em que fez a alteração for fechada, o que por
sua vez, traria muitos prejuízos, pois outros usuários iriam trabalhar com um banco de
dados desatualizado e podendo até causar redundância de dados.
Quando usamos o comando COMMIT o sistema fecha todos os cursores abertos,
destrói todas as sentenças preparadas e torna inválidos todos os cursores que
estejam associados a uma sentença preparada.
Resumo:
 Indica término bem sucedido de uma unidade de trabalho
 Alteração dos dados serão gravadas.
 Todas os PAGE LOCKS serão liberados
 CURSOR fechado, exceto para CURSOR WITH HOLD
32
DB2
EXEC SQL
COMMIT
END-EXEC
ROLLBACK – Desfaz a última alteração.

Quando desenvolvemos um sistema, tentamos fazer todos os tratamentos de erros
possíveis, mas não podemos esquecer da astúcia do usuário, ele sempre consegue
arranjar um jeito de furar o sistema e descobre um bug que você nem imaginava ser
possível. Por isso existeM os tratamentos de erros e se tratando de um banco de
dados essa preocupação tem que triplicar.
Resumo:
 Unidade de trabalho corrente é abandonado

 Atualização dos dados desde o último COMMIT são desfeitas
 Todos os PAGE LOCKS são liberados
 CURSOR fechado
EXEC SQL
ROLLBACK
END-EXEC
Quando se faz uma operação no BD (INSERT, UPDATE, DELETE), este por sua vez
retorna se a operação foi ou não bem sucedida. A partir daqui podemos imaginar
como podem nos ser úteis as cláusulas.
4 – TABELAS DE SISTEMA.
O Sistema de Gestão de Bases de Dados DB2 mantém um conjunto de tabelas (o catálogo do DB2)
com dados relativos aos vários objectos DB2. Estes dados podem ser consultados através do
comando SELECT (usando um interface interactivo - SPUFI ou QMF), tal como se tratassem de
quaisquer outras tabelas. De entre as tabelas do catálogo DB2 destacam-se:
SYSTABLES - Contém informações sobre as Tabelas das aplicações.

SELECT NAME, CREATOR, DBNAME, COLCOUNT, REMARKS
FROM SYSIBM.SYSTABLES
WHERE NAME LIKE 'TTIT%' AND CREATOR = 'SDB2D'
ORDER BY NAME
;
SYSINDEXES - Contém informações sobre os Índices das Tabelas das aplicações.

SELECT NAME, CREATOR, DBNAME, COLCOUNT, REMARKS
FROM SYSIBM.SYSINDEXES
WHERE NAME LIKE 'ITIT063%'
;
SYSKEYS - Contém informações sobre as Colunas dos Índices.

33
DB2
SELECT *
FROM SYSIBM.SYSKEYS
WHERE IXNAME LIKE 'ITIT063%'
;
SYSCOLUMNS - Contém informações sobre as Colunas das Tabelas das aplicações.

SELECT COLNO, NAME, COLTYPE, LENGTH, SCALE, NULLS, DEFAULT, REMARKS
FROM SYSIBM.SYSCOLUMNS
WHERE TBNAME LIKE 'TTIT%'
AND TBCREATOR = 'SDB2D'
ORDER BY COLNO
;
SYSPACKAGE - Contém informações sobre os Packages associados aos programas.

SELECT *
FROM SYSIBM.SYSPACKAGE
WHERE NAME = 'PTNU146A'
;
SYSPLAN - Contém informações sobre os Planos das aplicações.

SELECT *
FROM SYSIBM.SYSPLAN
WHERE NAME = 'DTNU146A'
;
SYSPACKLIST - Contém informações sobre as bibliotecas em que os Planos estão incluídos.

SELECT *
FROM SYSIBM.SYSPACKLIST
WHERE PLANNAME = 'ATNU6190'
;

34
DB2
APÊNDICE A – SQL CODES
DB2 - SQLCode
000 - EXECUÇÃO EFETUADA COM SUCESSO
+100 - Linha não encontrada para FETCH, UPDATE, DELETE ou o resultado de uma QUERY é uma
tabela vazia.
+304 - Um valor com tipo de dado tipo 1 não pode ser contido em uma variável HOST, porquê o seu
conteúdo não é compatível tipo 2
+558 - GRANT foi ignorado porquê já está com GRANT PUBLIC.
+560 - GRANT foi ignorado para alteração
-007 - Comando contém caracter inválido
-010 - STRING iniciada e não terminada
-060 - Especificação inválida
-084 - Comando SQL inaceitável
-101 - O comando é muito longo ou muito complexo
-102 - O tamanho da constante na STRING é maior que 254 caracteres ou 124 caracteres gráficos.
-103 - literal é uma literal numérica inválida.
-104 - Comando contém caracter inválido.
-105 - STRING inválida.
-107 - O nome name é muito longo. Tamanho máximo permitido é size.
-109 - clause cláusula não permitida
-110 - Literal hexadecimal iniciando STRING inválida
-111 - Uma função de coluna não incluiu o nome de uma das colunas
-112 - O operando de uma função de coluna é outra função de coluna ou DISTINCT seguido de uma
expressão.
-113 - Caracter inválido encontrado em um nome: name
-115 - Um predicado é inválido porque o operador de comparação operador é seguido de uma lista
entre parênteses ou pôr um ou todos predicados sem uma subQUERY.
-117 - A quantidade de valores em um INSERT não corresponde ao número de colunas objetos.

35
DB2
-118 - A tabela objeto ou VIEW de um comando INSERT, DELETE, ou UPDATE está também
identificado na clausula FROM.
-119 - Uma coluna citada em uma cláusula HAVING não foi inclusa na cláusula GROUP BY.
-120 - Uma cláusula WHERE ou SET inclui uma função de coluna ou a cláusula WHERE referencia-
se a uma coluna que deriva de uma função de coluna de uma VIEW definida.
-121 - O nome da coluna foi citado mais de uma vez no comando INSERT ou UPDATE
-122 - Um comando SELECT sem cláusula GROUP BY contém um nome de coluna e uma coluna de
função na cláusula SELECT ou, um nome de coluna está contido na cláusula SELECT mas não no
GROUP BY.
-125 - Um integrante da cláusula ORDER BY não identifica o resultado de uma coluna.
-126 - O comando SELECT contém uma cláusula UPDATE e uma cláusula ORDER BY
ao mesmo tempo.
-127 - DISTINCT está especificado mais que uma vez em um subSELECT
-128 - Uso inválido de NULL em um predicado.
-129 - O comando contém nomes de tabelas em excesso.
-131 - O comando com predicado LIKE possui tipos de dados incompatíveis.
-132 - Um predicado LIKE está inválido porquê o primeiro operando não é uma coluna ou o segundo
operando não é um STRING.
-133 - Uma função de coluna em uma SUBQUERY de uma cláusula HAVING está inválida porquê ela
contém uma expressão que utiliza um operador para uma referencia correlata.
-134 - Uso impróprio de uma coluna STRING muito grande nome_de_coluna ou uma variável HOST
com tamanho máximo maior que 254.
-136 - SORT não pode ser executado porquê o tamanho da chave do SORT possui mais que 4000
bytes.
-137 - Resultado de uma concatenação é muito grande.
-138 - O segundo ou terceiro argumento de uma função SUBSTR está fora do limite (RANGE).
-150 - O objeto de um comando INSERT, DELETE, ou UPDATE é uma VIEW que não permite esse
comandos solicitados.
-151 - A coluna nome_da_coluna não pode ser alterado pôr fazer parte também de uma chave
partilhada (partitioning key) de uma tabela partilhada (tablespace partitioned) ou derivada de uma
função ou expressão SQL.
-153 - O comando CREATE VIEW não inclui uma lista de colunas solicitadas.
-154 - O comando CREATE VIEW falhou porquê a definição da VIEW contém um UNION ou um
36
DB2
UNION ALL.
-156 - O comando ALTER TABLE, DROP TABLE, LOCK TABLE, ou CREATE INDEX referencia-se a
uma VIEW.
-158 - O numero de colunas especificadas para a VIEW não é o mesmo especificado pela cláusula
SELECT.
-159 - O nome especificado em um DROP VIEW é um nome de tabela.
-160 - A opção WITH CHECK não pode ser utilizada pela VIEW especificada.
-161 - O INSERT ou UPDATE não é permitido porquê a linha resultante não satisfaz a definição da
VIEW.
-164 - auth_id1 Não possui privilégio para criar VIEW com qualificação auth_id1
-170 - O número de argumentos especificados para function_name é inválido.
-171 - O tipo de dado, tamanho ou valor do argumento nn de function_name é inválido.
-172 - não é um nome de função válido.
-180 - A STRING de representação de um valor DATETIME está com sintaxe inválida.
-181 - A STRING de representação de um valor DATETIME possuí valor inválido.
-182 - Uma expressão aritmética com valor DATETIME inválido.
-183 - Uma expressão aritmética em uma DATA ou TIMESTAMP possuí um resultado inválido para o
range de datas.
-184 - Uma expressão aritmética com valore DATETIME contém um PARAMETER MAKER.
-185 - A opção formato local está sendo usada com uma data ou hora e a saída NO LOCAL está
sendo instalada.
-186 - O tamanho da data/hora local está sendo aumentado e executando um programa que ajusta o
tamanho antigo.
-198 - O operando de preparo ou comando imediato de EXECUTE está branco ou vazio.
-199 - Uso ilegal de palavra-chave. TOKEN token-list é esperado.
-203 - Referencia ambígua a uma coluna column_name
-204 - nome É um nome indefinido
-206 - nome-de-coluna Não é uma coluna da tabela nome-de-tabela.
-207 - a cláusula ORDER BY está inválida porque nela está incluso um nome de coluna que não faz
parte do resultado do UNION ou UNION ALL
-208 - a cláusula ORDER BY está inválida porque o nome da coluna não faz parte da Tabela.

37
DB2
-219 - a tabela desejada não existe.
-220 - a coluna column-name na tabela table-name não foi definida apropriadamente.
-301 - o valor da variável HOST não pode ser utilizado como especificado devido ao tipo de dado.
-302 - o valor de uma variável de entrada é muito grande para o tipo de coluna definida.
-303 - um valor não pode ser assinalado para uma variável HOST porque os tipos de dados não são
compatíveis.
-304 - o valor não pode ser armazenado na variável HOST devido a ultrapassar o valor máximo
permitido. Alterar o formato da HOST de smallint para integer ou decimal.
-305 - valor null não pode ser armazenado na HOST devido a falta de variável indicadora.
-309 - o predicado é inválido pois a variável HOST referenciada contém valor nulo
-310 - variável HOST no formato decimal e valor resultante é não decimal
-311 - o tamanho definido para a variável HOST é negativo
-312 - variável HOST não definida ou não utilizada
-313 - o número de variáveis HOST assinaladas no INTO difere das colunas assinaladas no SELECT.
-401 - tipos de dados na comparação são incompatíveis ( ex.: comparação de numérico =alfa)
-402 - uma função ou operador aritmético está sendo utilizado para um campo CHAR ou DATETIME
-404 - o comando UPDATE ou INSERT possui uma STRING de tamanho muito grande.
-405 - a literal numérica não pode ser utilizada adequadamente pôr estar fora do range ou seja, a
variável é smallint e o valor ultrapassa o máximo permitido para esta configuração.
-406 - um valor calculado ou derivado numérico está fora do range permitido para a coluna ( vide -
405).
-407 - o valor de um UPDATE ou INSERT é nulo, mas a coluna não aceita nulo.
-408 - o valor de um UPDATE ou INSERT não é compatível com o tipo de dado da coluna.
-409 - operando inválido em uma função COUNT.
-410 - a literal de ponto flutuante contém mais de 30 caracteres.
-411 - a DATETIME corrente ou chave do usuário não pode ser utilizada como especificado.
-412 - a clausula SELECT de uma subquerie especifica múltiplas colunas.
-413 - durante a conversão de um dado ocorreu overflow.

38
DB2
-414 - a coluna especificada no predicado LIKE é numérica ou DATETIME.
-415 - as colunas referenciadas em um UNION ou UNION ALL não são compatíveis com as
descrições.
-416 - o operando de um UNION contém uma coluna LONG STRING
-417 - a string construída inclui marcadores de parâmetros como operandos do mesmo operador (PS:
não entendi nada)
-418 - a string construída inclui marcadores de parâmetros inválidos
-419 - a operação de divisão decimal é inválida pois o resultado poderá ser em escala negativa.
-421 - os operandos de um UNION ou UNION ALL não possuem o mesmo número de colunas
-501 - o Cursor identificado em um comando FETCH ou CLOSE não foi aberto.
-502 - o Cursor identificado em um comando OPEN já está aberto.
-503 - uma coluna não pôde ser alterada pois não está identificada na clausula SELECT do comando
CURSOR.
-504 - o nome do CURSOR não foi identificado, verifique.
-507 - o CURSOR identificado no comando UPDATE ou DELETE não foi aberto
-508 - o CURSOR identificado no comando UPDATE OU DELETE não está posicionado em uma
linha.
-509 - A tabela identificada no comando DELETE ou UPDATE não é a mesma que consta do
comando CURSOR, verifique.
-510 - A tabela identificada no comando DELETE ou UPDATE não é pode ser alterada.
-511 - A clausula UPDATE não pôde ser especificada pois a tabela referenciada não permite
alterações.
-512 - O comando de referência a objeto remoto está inválido.
-513 - O ALIAS não deve estar definido em outro local ou ALIAS remoto.
-514 - O CURSOR não está preparado
-516 - O comando descrito não foi previamente preparado
-517 - O CURSOR não pode ser usado pois o nome do comando não foi identificado
-518 - O comando EXECUTE não foi identificado previamente
-519 - O comando PREPARE identifica o comando SELECT do CURSOR aberto
-530 - O valor do INSERT ou UPDATE de chave estrangeira (FOREIGN KEY) é inválido.

39
DB2
-531 - A chave primária em uma linha paterna (parent row) não pode ser alterado pois possui uma ou
mais linhas dependentes (dependent rows) em um relacionamento.
-532 - O relacionamento restringe a deleção da linha com RID X´nd-number´.
-533 - INSERT de linhas múltiplas inválido.
-534 - A chave primária não pode ser alterada pôr causa de multiple-rows UPDATE
-535 - UPDATE ou DELETE inválido com WHERE CURRENT OF
-536 - O comando DELETE está inválido pois a tabela pode ser afetada pela operação.
-537 - A chave primária ou estrangeira foi identificada na cláusula mais de uma vez
-538 - A chave estrangeira não está conforme a descrição da chave primária da tabela
-539 - A tabela não possui chave primária
-540 - A definição da tabela está incompleta porque não possui um índice primário.
-541 - A chave estrangeira está inválida porque ela é duplicate referential constraint
-542 - A coluna não pode ser chave primária porque pode conter nulos.
-551 - O usuário não possui privilégio para efetuar a operação. (falta de GRANT)
-552 - O usuário não possui privilégio para efetuar a operação
-553 - O usuário não é um dos IDS autorizados.
-554 - Usuário não pode conceder GRANT para si mesmo
-555 - O usuário não pode revogar um GRANT para ele próprio.
-556 - O privilégio não pode ser revogado porque o usuário não possui autoridade para revogá-lo.
-557 - O GRANT ou REVOKE com chave inconsistente. Verifique as chaves permitidas
-558 - Clausula ou combinação inválida em um GRANT ou REVOKE
-559 - Todas as funções de autorização estão desabilitadas.
-571 - O comando poderá alterar diversos linhas, confirme.
-601 - O nome do objeto a ser criado é idêntico a de um tipo de objeto.
-602 - Excesso de colunas especificadas em uma criação de índice.
-603 - O índice único não pode ser criado pois nele está incluso colunas com valores duplicados.
-604 - A definição da coluna possui tamanho ou atributo inválidos.
-607 - Operação não definida pelo sistema de tabelas

40
DB2
-612 - Nome da coluna duplicado
-613 - A chave primária é muito grande ou contem excesso de colunas
-614 - O índice não pode ser criado porque a soma do tamanho interno das colunas é maior que o
máximo permitido.
-616 - Objeto não pode ser dropado (apagado) porque é referenciado pôr outro objeto.
-618 - A operação não é permitida pelo sistema de base de dados.
-619 - Operação desabilitada porque o arquivo de trabalho do banco de dados está operante.
-620 - chave keyword IN strn type1 comando não é permitido para um tablespace no workfile data
base
-621 - Duplicate dbid foi detectado e previamente assinalado para database-name.
-623 - Um índice de agrupamento já existe na tabela
-624 - Tabela já possui chave primária.
-625 - Tabela não tem obrigatoriedade de paridade no índice para a chave primária.
-626 - O comando ALTER não é executado porque o pageset não foi parado.
-627 - O comando ALTER está inválido porque o pageset esta user-managed data sets
-628 - Um table-space segmentado não pode ser dividido (partitioned)
-629 - O valor nulo não pode ser setado pois a chave estrangeira não pode conter valor nulo
-631 - Nome da chave estrangeira muito grande ou tem muitas colunas
-632 - A tabela não pode ser definida como dependente de outra pôr causa das regras de restrições
de DELETE.
-633 - A regra de DELETE deverá ser xxxxx
-634 - A regra de DELETE não pode ser em cascata
-635 - As regras de DELETE não podem ser diferentes ou nula
-636 - As chaves de compartilhamento não estão ordenadas ascendentes ou descendentes.
-637 - Chave duplicada
-638 - Tabela não pode ser criada porque está faltando definição da coluna
-639 - Uma coluna de uma chave estrangeira que permite valores nulos com uma regra de DELETE
de SET NULL não pode ser uma coluna de chave de um índice particionado.
-644 - Valor inválido especificado para a chave no comando.
-646 - A tabela não pode ser criada em um tablespace particionada/default porque ele já contém uma
41
DB2
tabela
-647 - O bufferpool não pôde ser especificado porque não havia sido ativado.
-652 - Violação de uma regra de edição ou procedimento de validação.
-653 - A tabela no tablespace particionado não está disponível porque o índice particionado não havia
sido criado.
-660 - Índice não pode ser criado ou partilhado porque chaves limites não foram especificadas.
-661 - Índice não pode ser criado ou partilhado porque o número de partes especificadas não é igual
ao número de partições.
-662 - Índice particionado não pode ser criado em uma tablespace não particionada.
-663 - O nr. de chave limite de valores é zero ou maior que o nr de colunas da chave índice.
-664 - O tamanho interno da chave-limite de campos para o indice particionado excede o tamanho
imposto pelo gerenciador de índices.
-665 - A cláusula PART de um comando ALTER está omitida ou inválida.
-666 - stmt-verb object NÃO PODE SER EXECUTADA PORQUE function ESTÁ SENDO
EXECUTADA.
-667 - O índice CLUSTERING para um tablespace particionada não pode ser EXPLICIT DROPPED
-668 - A coluna não pode ser adicionada a tabela porque a tabela possui um EDIT PROCEDURE
-669 - A tabela em um tablespace particionado não pode ser EXPLICITY DROPPED.
-670 - O tamanho do registro da tabela excede o tamanho limite da página.
-671 - O atributo BUFFERPOOL da tablespace não pode ser alterado como foi especificado porque
isso poderia afetar o tamanho de página da tablespace.
-676 - Uma página de 32k BUFFERPOOL não pode ser utilizada ou indexada.
-677 - Insuficiente VIRTUAL STORAGE para expansão do BUFFERPOOL.
-678 - A literal xxx especificada como chave limite de índice deve estar de acordo com o tipo de dado
xxx para a coluna correspondente xxxxx
-679 - O objeto xxx não pode ser criado pois há um DROP pendente para ele.
-680 - Muita colunas especificadas para uma tabela
-681 - Column column-name in violation of installation defined field procedure. RT: return-code, RS:
reason-code, MSG: message-tokes
-682 - O campo procedure procedure-name não pode se carregado
-683 - Tipo de coluna inválida para opção FIELDPROC, column-name

42
DB2
-684 - O tamanho da literal iniciante da lista string é muito grande
-685 - Tipo de campo inválido, column-name
-686 - A coluna definida com um campo procedure não pode ser comparada com outra coluna de
campo procedure diferente.
-687 - Tipos de campos incomparáveis.
-688 - Dado incorreto retornado de um campo procedure, column-name
-802 - Exception-error exception-type ocorreu durante operation-type operação em data-type Dado

position-number
-803 - O valor de uma ou mais linhas estão inválidos pois a coluna objeto não permite duplicidade.
(chave única).
-804 - Um erro foi encontrado no parametro de entrada do programa de aplicação para o comando sql
-805 - O nome do programa program-name não foi encontrado no plano plan-name
-811 - O resultado de um comando select embedded é uma tabela de mais de uma linha, ou o
resultado da de um predicado basico da subquery possui mais de um valor
-815 - Uma clausula group by ou having está implicitamente ou explicitamente especificada em um

comando embedded select ou de um predicado basico da subquery
-817 - O insert , update, delete, DDL ou autorização não pode ser executada porque a transação
IMS/VS é somente inquiry
-818 - O precompiler-generated timestamp x in the load module é diferente do bind timestamp y built
from the dbrm
-819 - A view não pode ser recriada porque ela referencia a uma view que não pode ser recriada.
-820 - O comando SQL nào pode ser processado porque catalog-table contém um valor que não é
válido nesta versão.
-821 - A view view-creator.view-name está sendo dropado durante a migração. Criador synonym-
creator de sinônimo synonym-name não pode ser resolvido.
-822 - O SQLDA contém um endereço de dado ou variável indicadora inválido
-840 - Muitos itens retornados em uma lista de select ou insert .This help file was created with
HelpScribble.
-901 - Execução mal sucedida causada por um erro de sistema que não impede a execução com
sucesso dos comandos SQL seguintes.
-902 - Execução mal sucedida causada por um erro de sistema que impede a execução com sucesso
dos comandos SQL seguintes
-904 - Cancelamento causado por um recurso indisponivel reason-code, tipo de recurso resource-
type, e nome do recurso resource-name.

43
DB2
-906 - O comando SQL não pode ser executado porque esta função está desabilitada por um erro
anterior.
-909 - O objeto foi deletado
-910 - O comando SQL não pode ser acessar um objeto pois há um comando DROP ou ALTER
pendente
-911 - A unidade de trabalho corrente foi cancelada por DEADLOCK ou TIMEOUT.
-913 - Execução sem sucesso causada por DEADLOCK ou Timeout.
-922 - Autorização de conexão falhou : error_type ERROR
-923 - Conexão não estabelecida : DB2 condition REASON reason-code, TYPE resource-type, NAME
resource-name
-924 - Erro interno de conexão DB2, function-code, return-code, reason-code
-925 - COMMIT não válido no ambiente IMS/VS ou CICS/OS/VS

44
DB2
APÊNDICE B – PROGRAMAS EXEMPLOS

Exemplo: Select
ID DIVISION.
PROGRAM-ID. DB2SELE.
SPECIAL-NAMES. DECIMAL-POINT IS COMMA.
DATA DIVISION.
77 ASTERISCOS PIC X(40) VALUE ALL '*'.
77 WS-SALARIO PIC ZZ.ZZZ.ZZ9,99.
77 WS-CARGO-DEPTO PIC ZZZ9.
01 WS-MATRICULA PIC 9(5).
EXEC SQL
INCLUDE MFUNCION
END-EXEC.
EXEC SQL
INCLUDE SQLCA
END-EXEC.
PROCEDURE DIVISION.
000-PRINCIPAL SECTION.
PERFORM 100-INICIO.
PERFORM 200-PROCESSAR UNTIL WS-MATRICULA = ZEROS.
PERFORM 300-FINAL.
STOP RUN.
000-FIM. EXIT.
100-INICIO SECTION.
ACCEPT WS-MATRICULA FROM SYSIN.
100-FIM. EXIT.
200-PROCESSAR SECTION.
MOVE WS-MATRICULA TO MATRICULA.
EXEC SQL
SELECT * INTO :DCLFUNCIONARIO FROM FUNCIONARIO
WHERE MATRICULA = :MATRICULA
END-EXEC.
IF SQLCODE = +100
DISPLAY 'MATRICULA: ' WS-MATRICULA
' FUNCIONARIO NAO EXISTE.'
DISPLAY ASTERISCOS
END-IF.
IF SQLCODE = ZEROS
DISPLAY 'MATRICULA: ' MATRICULA
DISPLAY 'NOME: ' NOME-TEXT
MOVE SALARIO TO WS-SALARIO
DISPLAY 'SALARIO: ' WS-SALARIO
MOVE COD-CARGO TO WS-CARGO-DEPTO
DISPLAY 'CODIGO DO CARGO: ' WS-CARGO-DEPTO
MOVE COD-DEPTO TO WS-CARGO-DEPTO
DISPLAY 'CODIGO DO DEPARTAMENTO: ' WS-CARGO-DEPTO
DISPLAY 'DATA DE ADMISSAO: ' DATA-ADMISSAO
DISPLAY ASTERISCOS
END-IF.
200-FIM. EXIT.
300-FINAL SECTION.
DISPLAY '********** FIM DO PROCESSAMENTO **********'.
300-FIM. EXIT.

45
DB2
Exemplo: Insert
ID DIVISION.
PROGRAM-ID. DB2INSER.
DATA DIVISION.
77 ASTERISCO PIC X(53) VALUE ALL '*'.
01 WS-LINHA.
03 WS-NOME PIC X(20).
03 WS-SALARIO PIC 9(5)V99.
03 WS-COD-CARGO PIC 99.
03 WS-COD-DEPTO PIC 99.
03 WS-DATA-ADMISSAO.
05 WS-DIA PIC XX.
05 WS-MES PIC XX.
05 WS-ANO PIC X(4).
01 WS-DATA.
03 WS-ANO PIC X(4).
03 FILLER PIC X VALUE '-'.
03 WS-MES PIC XX.
03 WS-DIA PIC XX.
EXEC SQL
INCLUDE MFUNCION
END-EXEC.
EXEC SQL
INCLUDE SQLCA
END-EXEC.
PROCEDURE DIVISION.
PERFORM 100-INICIO.
PERFORM 300-FINAL.
STOP RUN.
000-FIM. EXIT.
100-INICIO SECTION.
MOVE 30 TO NOME-LEN.
ACCEPT WS-LINHA FROM SYSIN.
100-FIM. EXIT.
MOVE WS-NOME TO NOME-TEXT.
MOVE WS-SALARIO TO SALARIO.
MOVE WS-COD-CARGO TO COD-CARGO.
MOVE WS-COD-DEPTO TO COD-DEPTO.
MOVE CORR WS-DATA-ADMISSAO TO WS-DATA.
MOVE WS-DATA TO DATA-ADMISSAO.
EXEC SQL
INSERT INTO FUNCIONARIO
(MATRICULA,NOME,SALARIO,COD_CARGO,COD_DEPTO,
DATA_ADMISSAO)
VALUES
(:MATRICULA,:NOME,:SALARIO,:COD-CARGO,:COD-DEPTO,
:DATA-ADMISSAO)
END-EXEC.
IF SQLCODE = -803
DISPLAY 'MATRICULA: ' WS-MATRICULA ' JA EXISTE.'
DISPLAY ASTERISCOS
END-IF.
IF SQLCODE = -530

46
DB2

' CODIGO CARGO: ' WS-COD-CARGO
DISPLAY ' OU CODIGO DEPARTAMENTO: '
WS-COD-DEPTO
' INEXISTENTE.'
DISPLAY ASTERISCOS
END-IF.
200-FIM. EXIT.
300-FINAL SECTION.
300-FIM. EXIT.

47
DB2
Exemplo: UPDATE
ID DIVISION.
PROGRAM-ID. DB2UPDA.
DATA DIVISION.
01 WS-LINHA.
03 WS-NOME PIC X(20).
03 WS-SALARIO PIC 9(5)V99.
03 WS-COD-CARGO PIC 99.
03 WS-COD-DEPTO PIC 99.
03 WS-DATA-ADMISSAO.
05 WS-DIA PIC XX.
05 WS-MÊS PIC XX.
05 WS-ANO PIC X(4).
01 WS-DATA.
03 WS-ANO PIC X(4).
03 WS-MES PIC XX.
03 WS-DIA PIC XX.
EXEC SQL
INCLUDE MFUNCION
END-EXEC.
EXEC SQL
INCLUDE SQLCA
END-EXEC.
PROCEDURE DIVISION.
PERFORM 100-INICIO.
PERFORM 300-FINAL.
STOP RUN.
000-FIM. EXIT.
100-INICIO SECTION.
MOVE 30 TO NOME-LEN.
100-FIM. EXIT.
MOVE WS-NOME TO NOME-TEXT.
MOVE WS-SALARIO TO SALARIO.
MOVE WS-COD-CARGO TO COD-CARGO.
MOVE WS-COD-DEPTO TO COD-DEPTO.
MOVE CORR WS-DATA-ADMISSAO TO WS-DATA.
MOVE WS-DATA TO DATA-ADMISSAO.
EXEC SQL
UPDATE FUNCIONARIO SET NOME=:NOME,SALARIO=:SALARIO,
COD_CARGO=:COD-CARGO,
COD_DEPTO=:COD-DEPTO,
DATA_ADMISSAO=:DATA-ADMISSAO
WHERE :MATRICULA = MATRICULA
END-EXEC.
IF SQLCODE = +100
DISPLAY 'FUNCIONARIO NAO CADASTRADO.'
DISPLAY ASTERISCOS
END-IF.
IF SQLCODE = -530
48
DB2

' CODIGO CARGO: ' WS-COD-CARGO
DISPLAY ' OU CODIGO DEPARTAMENTO: '
WS-COD-DEPTO
' INEXISTENTE.'
DISPLAY ASTERISCOS
END-IF.
200-FIM. EXIT.
300-FINAL SECTION.
300-FIM. EXIT.

49
DB2
Exemplo: DELETE
ID DIVISION.
PROGRAM-ID. DB2DELE.
DATA DIVISION.
EXEC SQL
INCLUDE MFUNCION
END-EXEC.
EXEC SQL
INCLUDE SQLCA
END-EXEC.
PROCEDURE DIVISION.
PERFORM 100-INICIO.
PERFORM 300-FINAL.
STOP RUN.
000-FIM. EXIT.
100-INICIO SECTION.
100-FIM. EXIT.
EXEC SQL
DELETE FROM FUNCIONARIO
WHERE MATRICULA =:MATRICULA
END-EXEC.
IF SQLCODE = +100
' FUNCIONARIO NAO EXISTE.'
DISPLAY ASTERISCOS
END-IF.
200-FIM. EXIT.
300-FINAL SECTION.
300-FIM. EXIT.

50
DB2
Exemplo: CURSOR e FECTH

ID DIVISION.
PROGRAM-ID. DB2CF.
DATA DIVISION.
77 WS-SALARIO PIC ZZ.ZZZ.ZZ9,99.
77 WS-CARGO-DEPTO PIC ZZZ9.
EXEC SQL
INCLUDE MFUNCION
END-EXEC.
EXEC SQL
INCLUDE SQLCA
END-EXEC.
PROCEDURE DIVISION.
PERFORM 100-INICIO.
PERFORM 200-PROCESSAR UNTIL SQLCODE = 100.
PERFORM 300-FINAL.
STOP RUN.
000-FIM. EXIT.
100-INICIO SECTION.
EXEC SQL
DECLARE CONJ_RESULT CURSOR
FOR SELECT * FROM FUNCIONARIO
END-EXEC.
EXEC SQL
OPEN CONJ_RESULT
END-EXEC.
EXEC SQL
FETCH CONJ_RESULT INTO :DCLFUNCIONARIO
END-EXEC.
100-FIM. EXIT.
DISPLAY 'MATRICULA: ' MATRICULA.
DISPLAY 'NOME: ' NOME-TEXT.
MOVE SALARIO TO WS-SALARIO.
DISPLAY 'SALARIO: ' WS-SALARIO.
MOVE COD-CARGO TO WS-CARGO-DEPTO.
DISPLAY 'CODIGO DO CARGO: ' WS-CARGO-DEPTO.
MOVE COD-DEPTO TO WS-CARGO-DEPTO.
DISPLAY 'CODIGO DO DEPARTAMENTO: ' WS-CARGO-DEPTO.
DISPLAY 'DATA DE ADMISSAO: ' DATA-ADMISSAO.
DISPLAY ASTERISCOS.
MOVE SPACES TO NOME-TEXT.
EXEC SQL
FETCH CONJ_RESULT INTO :DCLFUNCIONARIO
END-EXEC.
200-FIM. EXIT.
300-FINAL SECTION.
EXEC SQL
CLOSE CONJ_RESULT
END-EXEC.
300-FIM. EXIT.

51
DB2

52

Formação Programador Mainframe

Enviado por

Dados do documento

Descrição original:

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

Formação Programador Mainframe

Enviado por

Direitos autorais:

Formatos disponíveis

Formação Programador Mainframe

Sistema Operacional e Mainframe

IBM 370 – DÉCADA DE 70, a segunda

IBM 3090 – ANOS 80 IBM MULTIPRISE – 1990

LINHA Z/SERIES – ANO 2000 a nova geração da IBM

Direitos Autorais – Escola de Programadores 2

COMPILADORES Cobol Natural Easytrev Pl/I

Direitos Autorais – Escola de Programadores 3

Sistema Operacional - z/OS

Veja o quadro abaixo:

Direitos Autorais – Escola de Programadores 4

Sistema Operacional - z/OS

Um sistema operacional possui as seguintes funções:

COMPONENTES DO SISTEMA OPERACIONAL

VISÃO LÓGICA DO z/OS

Direitos Autorais – Escola de Programadores 5

Sistema Operacional - z/OS

Direitos Autorais – Escola de Programadores 6

DEFINIÇÕES SOBRE SISTEMA

Sistema é um conjunto de programas, softwares, aplicativos e utilitários que se relacionam dentro

COMO MONTAR UM SISTEMA

Imaginemos um sistema em fase de implantação. O Analista obviamente saberá a ordem em que os

Direitos Autorais – Escola de Programadores 7

1) Se o PROG001 não processar ok, nenhum outro programa poderá processar.

Direitos Autorais – Escola de Programadores 8

3) O PROG022 depende do fim ok de dois outros programas.

Repare nas sequências:

COMPONENTES DO SISTEMA OPERACIONAL

CATÁLOGO DO SISTEMA OPERACIONAL x VTOC

Catálogo do hotel ---> catálogo do sistema operacional.

Direitos Autorais – Escola de Programadores 9

Sistema Operacional - z/OS

CATÁLOGO DO SISTEMA OPERACIONAL x VTOC

Catálogo : Lista de endereço

Direitos Autorais – Escola de Programadores 10

ARQUIVOS DO SISTEMA OPERACIONAL

ARQUIVO: Conjunto de registros aglomerados sequencialmente em um meio físico.

Disco: Unidade de armazenamento, composta de cilindros. Um disco é um conjunto de cilindros,

Cilindro: A idéia do cilindro é que se os dados de um arquivo estão gravados em trilhas

Direitos Autorais – Escola de Programadores 11

O sistema operacional z/OS, possui 3 tipos de arquivos distintos:

Arquivo Sequencial: É o tipo de arquivo utilizado, para armazenar informações em uma

Arquivo Indexado: É o tipo de arquivo utilizado, para armazenar informações através de

Direitos Autorais – Escola de Programadores 12

Formato e blocagem dos registros

V – Variável Desblocado- Significa que todos os blocos físicos do arquivo possuem

Registros Lógicos e Físicos

Direitos Autorais – Escola de Programadores 13

Nomenclatura para nomes de arquivos

O DSName para designar um arquivo particionado segue as mesmas regras quanto a

Direitos Autorais – Escola de Programadores 14

 Para interagir com o TSO é necessário um dispositivo de exibição de um terminal 3270 ou

Direitos Autorais – ISP Consultoria e Treinamentos em Tecnologia Ltda 1

PF – Teclas de funções pré-programadas:

Direitos Autorais – ISP Consultoria e Treinamentos em Tecnologia Ltda 2

Tela inicial do Sistema Operacional

Direitos Autorais – ISP Consultoria e Treinamentos em Tecnologia Ltda 3

 A instalação pode ter vários processos de LOGON.

 Após digitar uma das opções, apertar a tecla Enter

Direitos Autorais – ISP Consultoria e Treinamentos em Tecnologia Ltda 4

 Após digitar seu usuário, apertar a tecla Enter

 Após digitar sua password, apertar a tecla Enter