Formação Programador Mainframe

Transcrição

1

2 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.

3 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 360 LANÇADO EM 1964 O primeiro mainframe IBM 370 DÉCADA DE 70, a segunda geração. IBM 3090 ANOS 80 Refrigerado a água. IBM MULTIPRISE 1990 Modelo compacto usado muito em backup site LINHA 9000 ANOS 90, o modelo mais utilizado hoje no mercado. LINHA Z/SERIES ANO 2000 a nova geração da IBM Direitos Autorais Escola de Programadores 2

4 Escola de Programadores ZOS 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 Direitos Autorais Escola de Programadores 3

5 Escola de Programadores ZOS 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: PORTE PLATAFORMA SISTEMA OPERACIONAL FABRICANTE BAIXA PC S WINDOWS LINUX MAC MICROSOFT (OPEN SOURCE) APPLE MÉDIO UNIX HP-UX RISC-AIX SOLARIS HP IBM SUN GRANDE MAINFRAME (MVS) OS/390 (Z/OS) IBM Direitos Autorais Escola de Programadores 4

6 Escola de Programadores ZOS Sistema Operacional - 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 Direitos Autorais Escola de Programadores 5

7 Escola de Programadores ZOS Sistema Operacional - z/os ARQUITETURA Direitos Autorais Escola de Programadores 6

8 Escola de Programadores ZOS DEFINIÇÕES SOBRE SISTEMA CONSIDERAÇÕES Sistema é um conjunto de programas, softwares, aplicativos e utilitários que se relacionam dentro de um mesmo assunto. Ex.: Programas de folha de ponto, imposto de renda, seguros, férias, 13 o. 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, Direitos Autorais Escola de Programadores 7

9 Escola de Programadores ZOS 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. Com base no 1 O. 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. Direitos Autorais Escola de Programadores 8

10 Escola de Programadores ZOS 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 Você se encaminha e ao tocar a campainha você cumpriu seu roteiro. Catálogo do hotel Elevador Numeração dos apartamentos Campainha ---> catálogo do sistema operacional. ---> canal ---> VTOC ---> 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. Direitos Autorais Escola de Programadores 9

11 Escola de Programadores ZOS Sistema Operacional - z/os 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. Direitos Autorais Escola de Programadores 10

12 Escola de Programadores ZOS 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. Direitos Autorais Escola de Programadores 11

13 Escola de Programadores ZOS 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). Direitos Autorais Escola de Programadores 12

14 Escola de Programadores ZOS 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. Direitos Autorais Escola de Programadores 13

15 Escola de Programadores ZOS 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 #, $. 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. Direitos Autorais Escola de Programadores 14

16 ESCOLA DE PROGRAMADORES FORMAÇÃO MAINFRAME MÓDULO : TSO

17 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. e Treinamentos em Tecnologia Ltda 1

18 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: e Treinamentos em Tecnologia Ltda 2

19 TSO Tela inicial do Sistema Operacional e Treinamentos em Tecnologia Ltda 3

20 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 e Treinamentos em Tecnologia Ltda 4

21 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 e Treinamentos em Tecnologia Ltda 5

22 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 e Treinamentos em Tecnologia Ltda 6

23 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 e Treinamentos em Tecnologia Ltda 7

24 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. e Treinamentos em Tecnologia Ltda 8

25 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. e Treinamentos em Tecnologia Ltda 9

26 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) e Treinamentos em Tecnologia Ltda 10

27 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. e Treinamentos em Tecnologia Ltda 11

28 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. e Treinamentos em Tecnologia Ltda 12

29 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. e Treinamentos em Tecnologia Ltda 13

30 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. e Treinamentos em Tecnologia Ltda 14

31 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. e Treinamentos em Tecnologia Ltda 15

32 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? e Treinamentos em Tecnologia Ltda 16

33 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) e Treinamentos em Tecnologia Ltda 17

34 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>. e Treinamentos em Tecnologia Ltda 18

35 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. e Treinamentos em Tecnologia Ltda 19

36 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: e Treinamentos em Tecnologia Ltda 20

37 TSO e Treinamentos em Tecnologia Ltda 21

38 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. e Treinamentos em Tecnologia Ltda 22

39 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>. e Treinamentos em Tecnologia Ltda 23

40 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. e Treinamentos em Tecnologia Ltda 24

41 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 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) e Treinamentos em Tecnologia Ltda 25

42 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? e Treinamentos em Tecnologia Ltda 26

43 ESCOLA DE PROGRAMADORES FORMAÇÃO MAINFRAME MÓDULO : JCL

44 JCL SUMÁRIO JOB CONTROL LANGUAGE DEFINIÇÃO DESENHO DE UM JOB ESTRUTURA DE UM JOB REGRAS PARA CONFECÇÃO DE UM JOB PARÂMETROS ESPECIAIS JOBCARD PARÂMETROS MAIS COMUNS JOBCARD PARÂMETROS MENOS USUAIS EXEC DD (DATA DEFINITION) JOBLIB STEPLIB DDNAME X DSN(DSNAME) DDNAME DSN (DSNAME) PARM JCL ERROR X ABEND X FLUSH JCL ERROR ABEND FLUSH CAPÍTULO 3 ABENDS SISTEMA OPERACIONAL Direitos Autorais GPTI Treinamento 1

45 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 Direitos Autorais GPTI Treinamento 2

46 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 COBXX ESTRUTURA DE UM JOB //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=* //SYSOUT DD SYSOUT=* //******************************************************************** //* STEP003 - UTILITARIO IDCAMS - DELECAO ARQUIVO ARQSERA * //******************************************************************** //STEP003 EXEC PGM=IDCAMS //SYSOUT DD SYSOUT=* //SYSPRINT DD SYSOUT=* //SYSIN DD * DELETE GR.ARQUIVO.ARQSERA //******************************************************************** //* STEP004 - PROGRAMA COBXX02 - GERACAO ARQUIVO ARQSERA * //******************************************************************** //STEP004 EXEC PGM=COBXX02 //STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR //ARQPGTO DD DSN=GR.GPYYXX.ARQPGTO,DISP=SHR //ARQSERA DD DSN=GR.GPYYXX.ARQSERA, // DISP=(NEW,CATLG,DELETE), // UNIT=3390, // SPACE=(TRK,(5,1),RLSE), // DCB=(RECFM=FB,LRECL=800,BLKSIZE=0) //SYSOUT DD SYSOUT=* Direitos Autorais GPTI Treinamento 3

47 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 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) 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 : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) 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. Direitos Autorais GPTI Treinamento 4

48 JCL Exemplo : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) JOB Todo JOB deve possuir a palavra reservada JOB. A palavra reservada JOB solicita ao Sistema Operacional a execução de JOBs. Exemplo : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) 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 : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) 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 : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) Direitos Autorais GPTI Treinamento 5

49 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 : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) 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=GPYYXX,TIME=(0,20) //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 : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) Onde : 0 = (Quantidade em Minutos) 20 = (Quantidade em Segundos) Exemplo : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(,20) Direitos Autorais GPTI Treinamento 6

50 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. DICA 2 - IMPORTANTE! 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. DICA 3 - IMPORTANTE! 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 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 Direitos Autorais GPTI Treinamento 7

51 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 Direitos Autorais GPTI Treinamento 8

52 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 //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,PRTY=0 //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,PRTY=8 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 DICA 1 - IMPORTANTE! Se informado REGION=0M ou REGION=0K, utiliza-se a maior memória disponível para execução do JOB. Direitos Autorais GPTI Treinamento 9

53 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=STEP 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 ) : //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) Execução de Utilitário : //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) Direitos Autorais GPTI Treinamento 10

54 JCL Execução de Programa : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) //******************************************************************** //* STEP001 - PROGRAMA COBXX01 - GERACAO RELATORIO PAGAMENTOS * //******************************************************************** //STEP001 EXEC PGM=COBXX01 //STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR //ARQPGTO DD DSN=GR.GPYYXX.ARQPGTO,DISP=SHR //RELATO DD SYSOUT=* //SYSOUT DD SYSOUT=* Execução de Procedure : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) //******************************************************************** //* 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 * //***************************************************************** //STEP001 EXEC PGM=COBXX01 //STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR //SYSOUT DD SYSOUT=* //SYSPRINT DD SYSOUT=* //***************************************************************** //* STEP002 EXECUTA PROGRAMA COBXX02 * //***************************************************************** //STEP002 EXEC PGM=COBXX02 //STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR //SYSOUT DD SYSOUT=* //SYSPRINT DD SYSOUT=* Direitos Autorais GPTI Treinamento 11

55 JCL 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 : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) //******************************************************************** //* STEP001 - PROGRAMA COBXX01 - GERACAO RELATORIO PAGAMENTOS * //******************************************************************** //STEP001 EXEC PGM=COBXX01 //STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR //ARQPGTO DD DSN=GR.GPYYXX.ARQPGTO,DISP=SHR //RELATO DD SYSOUT=* //SYSOUT DD SYSOUT=* * (ASTERICO) Referencia dados de entrada para o programa que está sendo executado. Exemplo : //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) Direitos Autorais GPTI Treinamento 12

56 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 : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) //******************************************************************** //* STEP001 - PROGRAMA COBXX01 - GERACAO RELATORIO PAGAMENTOS * //******************************************************************** //STEP001 EXEC PGM=COBXX01 //STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR //ARQPGTO DD DUMMY //RELATO DD SYSOUT=* //SYSOUT DD SYSOUT=* SYSOUT Gera para o Sistema Operacional um DataSet com as saídas geradas pelo programa. Exemplo : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) //******************************************************************** //* STEP001 - PROGRAMA COBXX01 - GERACAO RELATORIO PAGAMENTOS * //******************************************************************** //STEP001 EXEC PGM=COBXX01 //STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR //ARQPGTO DD DSN=GR.GPYYXX.ARQPGTO,DISP=SHR //RELATO DD SYSOUT=* //SYSOUT DD SYSOUT=* Direitos Autorais GPTI Treinamento 13

57 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) SHR OLD NEW MOD CATLG UNCATLG DELETE KEEP PASS DESCRIÇÃO Significa que o DataSet existe e pode ser lido por outro recurso simultâneamente. Significa que o DataSet existe e que o programa exige exclusividade na leitura. Criação de DataSet Modifica um DataSet sequencial. Acrescenta novos registros no final. 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. Descataloga o DataSet. Evite usar sempre. Delete o DataSet. Se precisar deletar o DataSet use sempre esta opção. Mantem o DataSet do jeito que estava antes. Passa o DataSet para o próximo STEP do JOB. VALORES PERMITIDOS POR PARÂMETRO PRIMEIRO PARÂMETRO (STATUS) SEGUNDO PARÂMETRO (TÉRMINO NORMAL) NEW CATLG CATLG OLD UNCATLG UNCATLG MOD DELETE DELETE SHR KEEP KEEP - PASS - TERCEIRO PARÂMETRO (TÉRMINO ANORMAL) Exemplo : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) //******************************************************************** //* STEP004 - PROGRAMA COBXX02 - GERACAO ARQUIVO ARQSERA * //******************************************************************** //STEP004 EXEC PGM=COBXX02 //STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR //ARQPGTO DD DSN=GR.GPYYXX.ARQPGTO,DISP=SHR //ARQSERA DD DSN=GR.GPYYXX.ARQSERA, // DISP=(NEW,CATLG,DELETE), // UNIT=3390, // SPACE=(TRK,(5,1),RLSE), // DCB=(RECFM=FB,LRECL=800,BLKSIZE=0) //SYSOUT DD SYSOUT=* Direitos Autorais GPTI Treinamento 14

58 JCL Exemplo Inválido : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) //******************************************************************** //* STEP001 - PROGRAMA COBXX02 - GERACAO ARQUIVO ARQSERA * //******************************************************************** //STEP001 EXEC PGM=COBXX02 //STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR //ARQPGTO DD DSN=GR.GPYYXX.ARQPGTO,DISP=SHR //ARQSERA DD DSN=GR.GPYYXX.ARQSERA, // DISP=(NEW,KEEP,DELETE), // UNIT=3390, // SPACE=(TRK,(5,1),RLSE), // DCB=(RECFM=FB,LRECL=800,BLKSIZE=0) //SYSOUT DD SYSOUT=* 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 : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) //******************************************************************** //* STEP001 - PROGRAMA COBXX02 - GERACAO ARQUIVO ARQSERA * //******************************************************************** //STEP001 EXEC PGM=COBXX02 //STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR //ARQPGTO DD DSN=GR.GPYYXX.ARQPGTO,DISP=SHR //ARQSERA DD DSN=GR.GPYYXX.ARQSERA, // DISP=(NEW,CATLG,DELETE), // UNIT=3390, // SPACE=(TRK,(5,1),RLSE), // DCB=(RECFM=FB,LRECL=800,BLKSIZE=0) //SYSOUT DD SYSOUT=* Direitos Autorais GPTI Treinamento 15

59 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 = 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 : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) //******************************************************************** //* STEP001 - PROGRAMA COBXX02 - GERACAO ARQUIVO ARQSERA * //******************************************************************** //STEP001 EXEC PGM=COBXX02 //STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR //ARQPGTO DD DSN=GR.GPYYXX.ARQPGTO,DISP=SHR //ARQSERA DD DSN=GR.GPYYXX.ARQSERA, // DISP=(NEW,CATLG,DELETE), // UNIT=3390, // SPACE=(TRK,(5,1),RLSE), // DCB=(RECFM=FB,LRECL=800,BLKSIZE=0) //SYSOUT DD SYSOUT=* 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. Direitos Autorais GPTI Treinamento 16

60 JCL Exemplo : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) //******************************************************************** //* STEP001 - PROGRAMA COBXX02 - GERACAO ARQUIVO ARQSERA * //******************************************************************** //STEP001 EXEC PGM=COBXX02 //STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR //ARQPGTO DD DSN=GR.GPYYXX.ARQPGTO,DISP=SHR //ARQSERA DD DSN=GR.GPYYXX.ARQSERA, // DISP=(NEW,CATLG,DELETE), // UNIT=3390,VOL=SER=PR39X7, // SPACE=(TRK,(5,1),RLSE), // DCB=(RECFM=FB,LRECL=800,BLKSIZE=0) //SYSOUT DD SYSOUT=* 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 : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) //******************************************************************** //* STEP001 - PROGRAMA COBXX02 - GERACAO ARQUIVO ARQSERA * //******************************************************************** //STEP001 EXEC PGM=COBXX02 //STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR //ARQPGTO DD DSN=GR.GPYYXX.ARQPGTO,DISP=SHR //ARQSERA DD DSN=GR.GPYYXX.ARQSERA, // DISP=(NEW,CATLG,DELETE), // UNIT=3390, // SPACE=(TRK,(5,1),RLSE), // DCB=(RECFM=FB,LRECL=800,BLKSIZE=0) //SYSOUT DD SYSOUT=* 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 Direitos Autorais GPTI Treinamento 17

61 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 : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) //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 : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) //******************************************************************** //* 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=* //SYSOUT DD SYSOUT=* 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. Direitos Autorais GPTI Treinamento 18

62 JCL 1.7 DDNAME x DSN(DSNAME) 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 : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) //******************************************************************** //* STEP001 - PROGRAMA COBXX02 - GERACAO ARQUIVO ARQSERA * //******************************************************************** //STEP001 EXEC PGM=COBXX02 //STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR //ARQPGTO DD DSN=GR.GPYYXX.ARQPGTO,DISP=SHR //ARQSERA DD DSN=GR.GPYYXX.ARQSERA, // DISP=(NEW,CATLG,DELETE), // UNIT=3390, // SPACE=(TRK,(5,1),RLSE), // DCB=(RECFM=FB,LRECL=800,BLKSIZE=0) //SYSOUT DD SYSOUT=* DDNAMEs ARQPGTO e ARQSERA são os DDNAMES desse STEP. Sendo ARQPGTO (Entrada) e ARQSERA (Saída) DSN (DSNAME) DataSet Name. É o nome físico do arquivo. Utiliza a claúsula DSN. É onde os dados são armazenados fisicamente. Exemplo : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) //******************************************************************** //* STEP001 - PROGRAMA COBXX02 - GERACAO ARQUIVO ARQSERA * //******************************************************************** //STEP001 EXEC PGM=COBXX02 //STEPLIB DD DSN=GR.GERAL.LOADLIB,DISP=SHR //ARQPGTO DD DSN=GR.GPYYXX.ARQPGTO,DISP=SHR //ARQSERA DD DSN=GR.GPYYXX.ARQSERA, // DISP=(NEW,CATLG,DELETE), // UNIT=3390, // SPACE=(TRK,(5,1),RLSE), // DCB=(RECFM=FB,LRECL=800,BLKSIZE=0) //SYSOUT DD SYSOUT=* Direitos Autorais GPTI Treinamento 19

63 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 : //JOBXX01D JOB 'JOB-PRD',CLASS=C,MSGCLASS=X,NOTIFY=GPYYXX,TIME=(0,20) //******************************************************************** //* 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 JCL ERROR x ABEND x FLUSH 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 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 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. Direitos Autorais GPTI Treinamento 20

64 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 ERRO NA 'DCB'. VERIFICAR 'DCB' COM 'LABEL' '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). Direitos Autorais GPTI Treinamento 21

65 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. Direitos Autorais GPTI Treinamento 22

66 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 Direitos Autorais GPTI Treinamento 23

67 JCL MACRO 'ENQ'. S137 - ERRO NO FIM DE VOLUME EM FITA C ERRO DE POSICIONAMENTO, LEITURA OU GRAVA- CAO EM FIM DE VOLUME REPROCESSAR COM BACKUP - 1C - 'TRAILER LABEL' INVALIDO '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 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 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 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'. Direitos Autorais GPTI Treinamento 24

68 JCL S406 - O PROGRAMA PRODUZIDO PELO 'LINK-EDITOR' CONTEM 'OL' NO CARTAO EXEC. S413 - ERRO DE OPEN PARA ARQUIVO DE FITA OU DISCO C 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 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'. Direitos Autorais GPTI Treinamento 25

69 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'. Direitos Autorais GPTI Treinamento 26

70 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 FALTA DE CARTAO CONTROLE (FB) EXCEDEU A CAPACIDADE DO SORT - AUMENTAR SORTWORKS ERRO NO CONTROL FIELD PARAMETRO - ACERTAR SE FOR POSSIVEL ERRO NO PROGRAMA GENERICO - SUSPENDER AUMENTAR REGION ERRO NO CARTAO DO SORT - TIRAR O CARTAO SYSOUT AUMENTAR REGION EXCEDEU A CAPACIDADE DO SORT - AUMENTAR SORTWORKS SORT OU SORTOUT NAO DEFINIDO DCB OU I/O ERROR DEVICE ERRO NO CARTAO SORT - COLOCAR /* SORTIN. - SE EXISTIR SORTWORKS, COLOCAR O CARTAO SYSOUT E SORTLIB DCB FORA DE SEQUENCIA, REGISTROS FORA DE SEQUENCIA (NO MERGE). - TIRAR LABEL DOS ARQUIVOS E COLOCAR OS DE MAIOR DCB ANTES AUMENTAR A REGION ACCT EM LOCAL INADEQUADO QUANDO NO OPEN INICIAL. - DCB INCOMPATIVEL ACCT - HOUVE CONDICAO DE ERRO PERMANENTE EM UM DOS ARQUIVOS. - BLKSIZE NAO E' MULTIPLO DO LRECL OU DIFERE DO PROGRAMA FALTA DD GO.DDCHECK PROBLEMA COM FW-I/O ERROR LEITURA OU PARM XX INVALIDO ABEND DO LIBRARIAN - QUANDO NAO DEPENDER DE INF. EXTRA ACERTAR ABEND FORCADO PELO PROGRAMA - SEM DUMP ABEND FORCADO PELO PROGRAMA - COM DUMP. 914I - ERRO NO MEMBRO ALOCADO. Direitos Autorais GPTI Treinamento 27

71 ESCOLA DE PROGRAMADORES FORMAÇÃO MAINFRAME MÓDULO : COBOL

72 COBOL INDICE 1 INTRODUÇÃO À LINGUAGEM COBOL INTERPRETAÇÃO DOS FORMATOS NA APOSTILA INDENTAÇÃO FORMATO DO FONTE COBOL DIVISÕES DO COBOL IDENTIFICATION DIVISION ENVIRONMENT DIVISION CONFIGURATION SECTION INPUT-OUTPUT SECTION DATA DIVISION ESPECIFICAÇÃO PARA DADOS OU VÁRIAVEIS COMANDOS ACCEPT RECEBENDO DADOS DO SISTEMA DISPLAY STOP RUN COMANDOS ARITMÉTICOS Opção ROUNDED Opção ON SIZE ERROR Opção END- (Delimitador de escopo) ADD SUBTRACT DIVIDE MULTIPLY COMPUTE ESTRUTURA LÓGICA - DECISÃO Comandos de Decisão Operadores Relacionais Operadores Lógicos CONTINUE OU NEXT SENTENCE EVALUATE ESTRUTURA LÓGICA REPETIÇÃO PERFORM PERFORM parágrafo [THRU parágrafo-fim] PERFORM parágrafo [THRU parágrafo-fim] N TIMES PERFORM parágrafo [THRU parágrafo-fim] UNTIL condição PERFORM parágrafo [THRU parágrafo-fim] VARYING campo FROM n BY m UNTIL condição

73 COBOL 9 LÓGICA ESTRUTURADA ARQUIVOS SEQÜENCIAIS Conceitos Básicos COMANDOS PARA PROCESSAMENTO DE ARQUIVOS SEQUENCIAIS ENVIRONMENT DIVISION - INPUT-OUTPUT SECTION DATA DIVISION - FILE SECTION FLUXOGRAMA ABERTURA DE ARQUIVOS MOVIMENTAÇÃO DE CAMPOS GRAVAÇÃO DE REGISTROS FECHAMENTOS DE ARQUIVOS LEITURA DE ARQUIVOS SEQÜENCIAIS INICIALIZAÇÃO DE CAMPOS E CONJUNTO DE VARIÁVEIS ENCERRAMENTO DE PARÁGRAFOS RELATÓRIOS COMANDOS PARA PROCESSAMENTO DE RELATÓRIOS Totalização e Quebra de Relatórios LÓGICA BALANCEADA TABELAS DE MEMÓRIA CLÁUSULA OCCURS NÍVEIS DE TABELAS CHAMANDO UM SUB-PROGRAMA COMPILAÇÃO E LINKEDIÇÃO DE PROGRAMAS FILE STATUS

74 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

75 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 2 0 ), em seguida o segundo algarismo da direita ( o que vai ser multiplicado por 2 1 ) 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

76 COBOL Para saber o resultado em binário, basta verificar os restos das divisões de baixo para cima. Exemplo: Decimal Binário 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

77 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

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

79 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: Coluna 7: Colunas de 8 a 11: Colunas de 12 a 72: Colunas de 73 a 80: Área de numeração seqüencial de linhas do editor Área de indicação de comentários ou continuação Área A ou Nível A para codificação das palavras da linguagem Área B ou Nível B para codificação dos comandos da linguagem Não utilizadas na programação 8

80 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

81 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

82 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

83 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

84 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

85 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

86 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

87 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, utilizandose 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

88 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

89 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

90 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 END-IF CASADO DISPLAY 2 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

91 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: 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: 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 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

92 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é 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, , , , , , , ,00 ZZ.ZZ9, ,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

93 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 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

94 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

95 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 DAY Formato implícito PIC 9(05) Formato YYDDD- data Juliana 04/07/1981 será expresso como 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

96 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

97 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

98 COBOL 6.3 Opção END- (Delimitador de escopo) Utilizado como delimitador em todas as instruções aritméticas do COBOL ADD ADD VALOR-1 TO VALOR-3 ON SIZE ERROR DISPLAY ESTOUROU O CAMPO DE RESULTADO MOVE S TO WS-ESTOURO END-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. ADD Efetua: WS-AC-TOTAL1 = WS-AC-TOTAL1 + WS-VALOR. Efetua: WS-AC-TOTAL2 = WS-AC-TOTAL2 + WS-VALOR. 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

99 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 resultado No Formato 2, o identificador de resultado1, armazenará o resultado de identificador-2 constante-2 subtraídos de identificador-1... constante 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

100 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 {identificador-2 constante-2} 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

101 COBOL MULTIPLY Efetua a multiplicação entre variáveis. Formato: MULTIPLY {identificador-1 constante-1} BY {identificador-2 constante-2} [ [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

102 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

103 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 PROGRAM-ID. DIVISION. 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 N4 PIC 9(02) VALUE MEDIA PIC 9(03) VALUE ZEROS. PROCEDURE DIVISION. ACCEPT N1 FROM SYSIN. ACCEPT N2 FROM SYSIN. ACCEPT N3 FROM SYSIN. ACCEPT N4 FROM SYSIN. COMPUTE MEDIA = (N1 + N2 + N3 + N4) / 4. DISPLAY ' '. DISPLAY 'MEDIA => ' MEDIA. DISPLAY ' '. STOP RUN. 32

104 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

105 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 Not And Or DESCRIÇÃO "NÃO": NOT <condição VERDADEIRO> é igual a FALSO e NOT <condição FALSO> é igual a VERDADEIRO. "E": Condições associadas com AND resultam VERDADEIRO quando todas forem VERDADEIRO. "OU": Condições associadas com OR resultam VERDADEIRO bastando apenas uma delas ser VERDADEIRO. Categorias Teste de sinal Teste de classe Notação alternativa IS POSITIVE IS NEGATIVE IS NUMERIC IS ALPHABETIC 34

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

107 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: IF A > B { CONTINUE NEXT SENTENCE } ELSE DISPLAY A MENOR OU = B END-IF. DISPLAY COMPARAÇÃO EFETUADA. Exemplo 1: (IF SEM ELSE) IF WS-CAMPO1 EQUAL WS-CAMPO-2 PERFORM PESQUISA END-IF. Exemplo 2: (IF COM ELSE) IF WS-CAMPO1 < WS-CAMPO-2 ADD 1 TO WAC-CAMPO3 ELSE COMPUTE WS-TOTAL = WS-VALOR1 + WS-VALOR2 END-IF. Exemplo 3: (IF COM NEXT SENTENCE) IF WS-CAMPO1 > WS-CAMPO-2 NEXT SENTENCE ELSE 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 SITUAÇÃO1 END-IF IF WS-CAMPO5 > WS-CAMPO6 PERFORM SITUAÇÃO2 ELSE IF WS-CAMPO7 EQUAL H CONTINUE END-IF END-IF ELSE PERFORM SITUAÇÃO3 END-IF. 36

108 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: Usando EVALUATE para o mesmo propósito: Usando EVALUATE com a cláusula THRU: 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. 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. EVALUATE WS-SALDO WHEN ZEROS THRU DISPLAY CLIENTE COMUM WHEN THRU DISPLAY CLIENTE ESPECIAL WHEN > DISPLAY CLIENTE SUPER-ESPECIAL END-EVALUATE. 37

109 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 viceversa, 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

110 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 CALCULA-TOTAL. MOVE ZEROS TO WS-TOTAL PERFORM CALCULO 3 TIMES EXIT. EXIT. 39

111 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 MAIN-LINE. MOVE N TO WS-FIM. PERFORM INICIALIZAR. PERFORM LER-ARQUIVO. PERFORM PROCESSAR UNTIL WS-FIM = S. PERFORM FINALIZAR EXIT. EXIT. Exemplo 2: PERFORM com opção UNTIL (IN-LINE) PERFORM UNTIL WS-FIM = S IF WS-LIN > 50 PERFORM CABECALHO END-IF PERFORM ROT-DETALHE PERFORM 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 PROCESSAR. PERFORM ROT-CABECALHO. PERFORM ROT-DETALHE VARYING WS-LIN FROM 1 BY 1 UNTIL WS-LIN = ROT-DETALHE. PERFORM IMPRIMIR-DETALHE. PERFORM LER-ARQUIVO. 40

112 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

113 COBOL Exemplo: * PROGRAMA - MAIOR E MENOR NUMERO IDENTIFICATION DIVISION. PROGRAM-ID. ALUNO01. AUTHOR. ALUNO. * DATA DIVISION. WORKING-STORAGE SECTION. 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

114 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 MARIA DAS GRAÇAS RUA DAS DORES, 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

115 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

116 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

117 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

118 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 ENTRAD A ARQUIVO CLIENTE PROGRAMA PROGRAMA ARQUIVO DE SAÍDA RELATÓRIO 47

119 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. DECIMAL-POINT IS COMMA. 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 BLOCK CONTAINS 0 RECORDS RECORD CONTAINS 150 CHARACTERS LABEL RECORD IS STANDARD RECORDING MODE IS F. 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). *============================================================= WORKING-STORAGE SECTION. 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

120 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 ' FILE STATUS = ' WS-FS-ARQENT DISPLAY '=======================================' STOP RUN. ADD 1 TO WS-CONT-LIDOS. LER-FIM. EXIT. 49

121 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. IF WS-FS-ARQSAI NOT EQUAL ZEROS DISPLAY '=======================================' DISPLAY ' ERRO NA GRAVACAO DO ARQSAI ' DISPLAY ' FILE STATUS = ' WS-FS-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. IF WS-FS-ARQENT NOT EQUAL ZEROS DISPLAY '=======================================' DISPLAY ' ERRO NO CLOSE DO ARQUIVO ARQENT ' DISPLAY ' FILE STATUS = ' WS-FS-ARQENT DISPLAY '=======================================' STOP RUN. CLOSE ARQSAI. IF WS-FS-ARQSAI NOT EQUAL ZEROS DISPLAY '=======================================' DISPLAY ' ERRO NO CLOSE DO ARQUIVO ARQSAI ' DISPLAY ' FILE STATUS = ' WS-FS-ARQSAI DISPLAY '=======================================' STOP RUN. 50

122 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

123 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. 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. 52

124 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 Comando Campo emissor (constante figurativa) Campo receptor formato: MOVE ZERO TO TOTSAL ZERO PIC 9(7) COMP C Conteúdo do campo receptor após o MOVE (expresso em hexa) MOVE ZEROS TO TOTSAL ZEROS PIC 9(7) COMP C MOVE ZEROES TO TOTSAL ZEROES PIC 9(7) COMP C MOVE ZERO TO TOTSAL ZERO PIC 9(5) F0.F0.F0.F0.F0 MOVE ZEROS TO TOTSAL ZEROS PIC 9(5) F0.F0.F0.F0.F0 MOVE ZEROES TO TOTSAL ZEROES PIC 9(5) F0.F0.F0.F0.F0 MOVE SPACE TO SIGLA SPACE PIC X(02) MOVE SPACES TO SIGLA SPACES PIC X(02) MOVE HIGH-VALUES TO CHAVE-ARQUIVO HIGH-VALUES PIC X(03) FF.FF.FF MOVE LOW-VALUES TO CHAVE-ARQUIVO LOW-VALUES MOVE ALL * TO WS-MSG ALL * MOVE ALL *A TO WS_MSG ALL *A PIC X(03) PIC X(05) PIC X(05) C.5C.5C.5C.5C 5C.C1.5C.C1.5C 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

125 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: *============================================================= * 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. 54

126 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. IF WS-FS-ARQSAI NOT EQUAL ZEROS DISPLAY '=======================================' DISPLAY ' ERRO NA GRAVACAO DO ARQSAI ' DISPLAY ' FILE STATUS = ' WS-FS-ARQSAI DISPLAY '=======================================' STOP RUN. ADD 1 TO WS-CONT-GRAVA. GRAVA-SAIDA-FIM. EXIT. 55

127 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. IF WS-FS-ARQENT NOT EQUAL ZEROS DISPLAY '=======================================' DISPLAY ' ERRO NO CLOSE DO ARQUIVO ARQENT ' DISPLAY ' FILE STATUS = ' WS-FS-ARQENT DISPLAY '=======================================' STOP RUN. CLOSE ARQSAI. IF WS-FS-ARQSAI NOT EQUAL ZEROS DISPLAY '=======================================' DISPLAY ' ERRO NO CLOSE DO ARQUIVO ARQSAI ' DISPLAY ' FILE STATUS = ' WS-FS-ARQSAI DISPLAY '=======================================' STOP RUN. 56

128 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 ' FILE STATUS = ' WS-FS-ARQENT DISPLAY '=======================================' STOP RUN. ADD 1 TO WS-CONT-LIDOS. 57

129 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 alfanumérica ou alfabética, ela será inicializada com espaços. Formato: INITIALIZE variável ou Nível 01 do registro. Exemplos: *============================================================= * 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. 58

130 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

131 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. * * ENVIRONMENT DIVISION. CONFIGURATION SECTION. SPECIAL-NAMES. DECIMAL-POINT IS COMMA. * * INPUT-OUTPUT SECTION. 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)V ESTOQUE PIC 9(007). * * FD RELATORIO RECORDING MODE F. 01 REG-RELATO PIC X(132). 60

132 COBOL * * WORKING-STORAGE SECTION. * * 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(20) VALUE SPACES. 02 FILLER PIC X(18) VALUE "RELATORIO DE PECAS". 02 FILLER PIC X(20) VALUE SPACES. 02 FILLER PIC X(5) VALUE "PAG. ". 02 NPAG-LIN1 PIC Z9 VALUE SPACES. * * 01 LIN2. 02 FILLER PIC X(33) VALUE " CODIGO NOME ". 02 FILLER PIC X(22) VALUE " DESCRICAO". 02 FILLER PIC X(02) VALUE SPACES. 02 FILLER PIC X(13) VALUE " PRECO ". 02 FILLER PIC X(9) VALUE " ESTOQUE". * * 01 DETALHE. 02 FILLER PIC X(5) VALUE SPACES. 02 CODIGO-DET PIC ZZ.ZZ9 VALUE SPACES. 02 FILLER PIC X(2) VALUE SPACES. 02 NOME-DET PIC X(20) VALUE SPACES. 02 FILLER PIC X(2) VALUE SPACES. 02 DESC-DET PIC X(20) VALUE SPACES. 02 FILLER PIC X(2) VALUE SPACES. 02 PRECO-DET PIC ZZ.ZZZ.ZZ9,99 VALUE SPACES. 02 FILLER PIC X(2) VALUE SPACES. 02 EST-DET PIC Z.ZZZ.99 VALUE SPACES. * * 01 LINTOT1. 02 FILLER PIC X(21) VALUE " TOTAL DE ITENS: ". 02 TOTALITENS PIC Z99 VALUE SPACES. * * 01 LINTOT2. 02 FILLER PIC X(22) VALUE " VALOR DOS ITENS: ". 02 TOTALVALOR PIC $ZZ.ZZ9,99 VALUE SPACES. * * 61

133 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 MOVE CORR DATA-ACCEPT READ PECAS AT END MOVE "S" END-READ. FROM DATE. TO DATA-LIN1. TO WS-FIM 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 ADD 1 ADD PRECO READ PECAS AT END MOVE "S" END-READ. FIM-PROCESSAR. EXIT. TO NLINHAS-WS. TO NITENS-WS. TO NVALOR-WS. TO WS-FIM 62

134 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. MOVE 5 TO NLINHAS-WS. FIM-CABECALHO. EXIT 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

135 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. MOVE 5 TO NLINHAS-WS. FIM-CABECALHO. EXIT. 64

136 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

137 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: IDENTIFICATION DIVISION. PROGRAM-ID. EXEMPLO3. AUTHOR. ALUNO. *OBJETIVO: BALANCE LINE ENTRE O ARQUIVO CCANT E MOV. *=============================================================== ENVIRONMENT DIVISION. CONFIGURATION SECTION. SPECIAL-NAMES. DECIMAL-POINT IS COMMA. INPUT-OUTPUT SECTION. 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 BLOCK CONTAINS 0 RECORDS RECORD CONTAINS 30 CHARACTERS LABEL RECORD IS STANDARD RECORDING MODE IS F. 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 BLOCK CONTAINS 0 RECORDS RECORD CONTAINS 10 CHARACTERS LABEL RECORD IS STANDARD RECORDING MODE IS F. 01 REG-MOV. 03 MOV-CONTA PIC X(3). 03 MOV-SALDO PIC S9(5)V9(2). FD ATUA BLOCK CONTAINS 0 RECORDS RECORD CONTAINS 30 CHARACTERS 66

138 COBOL LABEL RECORD IS STANDARD RECORDING MODE IS F. 01 REG-ATUA. 03 ATUA-CONTA PIC X(3). 03 ATUA-NOME PIC X(20). 03 ATUA-SALDO PIC S9(5)V9(2). WORKING-STORAGE SECTION. 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 MOVE 99 TO RETURN-CODE STOP RUN. OPEN OUTPUT ATUA. IF WS-FS-ATUA NOT EQUAL ZEROS DISPLAY 'ERRO NO OPEN DO ATUA = ' WS-FS-ATUA MOVE 99 TO RETURN-CODE STOP RUN. PERFORM LER-CCANT. PERFORM LER-MOV. 67

139 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. MOVE 99 TO RETURN-CODE 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 MOVE 99 TO RETURN-CODE 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 MOVE 99 TO RETURN-CODE STOP RUN ELSE IF WS-FS-MOV EQUAL 10 MOVE HIGH-VALUES TO MOV-CONTA END-IF END-IF. 68

140 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)V TOTAL-02 PIC 9(8)V TOTAL-12 PIC 9(8)V99. PROCEDURE DIVISION. IF MES = 01 ELSE IF MES = 02 ELSE... IF MES = 12 ADD VENDAS TO TOTAL-01 ADD VENDAS TO TOTAL-02 ADD VENDAS TO TOTAL-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

141 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 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

142 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

143 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: Parâmetros: CALL NOME-DO-SUBPROGRAMA USING WS-AREA 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 subprograma, 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

144 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

145 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 '00' '02' '04' '05' '07' '10' '14' '20' '21' '22' '23' '24' '30' '34' '35' '37' '38' '39' '41' '42' '43' '44' '46' '47' '48' '49' '90' '91' '92' '93' '94' '95' '96' '97' OTHER DESCRIÇÃO 'SUCCESSFUL COMPLETION' 'DUPLICATE KEY, NON UNIQ. ALT INDX' 'READ, WRONG LENGTH RECORD' 'OPEN, FILE NOT PRESENT' 'CLOSE OPTION INCOMPAT FILE DEVICE OPEN IMPLIES TAPE; TAPE NOT USED' 'END OF FILE' 'RRN > RELATIVE KEY DATA' 'INVALID KEY VSAM KSDS OR RRDS' 'SEQUENCE ERROR, ON WRITE OR CHANGING KEY ON REWRITE' 'DUPLICATE KEY' 'RECORD OR FILE NOT FOUND' 'BOUNDARY VIOLATION. WRITE PAST END OF KSDS RECORD. COBOL 370: REL: REC# TOO BIG. OUT OF SPACE ON KSDS/RRDS FILE' 'PERMANENT DATA ERROR. DATA CHECK, PARITY CHK, HARDW' 'BOUNDARY VIOLATION. WRITE PAST END OF ESDS RECORD OR NO SPACE TO ADD KSDS/RRDS RECORD. OUT OF SPACE ON SEQUENTIAL FILE' '35' 'OPEN, FILE NOT PRESENT' 'OPEN MODE INCOMPAT WITH DEVICE' 'OPENING FILE CLOSED WITH LOCK' 'OPEN, FILE ATTRIB CONFLICTING' 'OPEN, FILE IS OPEN' 'CLOSE, FILE IS CLOSED' 'DELETE OR REWRITE & NO GOOD READ FIRST' 'BOUNDARY VIOLATION/REWRITE REC TOO BIG' 'SEQUENTIAL READ WITHOUT POSITIONING' 'READING FILE NOT OPEN AS INPUT/IO/EXTEND' 'WRITE WITHOUT OPEN IO' 'DELETE OR REWRITE WITHOUT OPEN IO' 'UNKNOWN' 'VSAM - PASSWORD FAILURE' 'LOGIC ERROR/OPENING AN OPEN FILE OR READING OUTPUT FILE OR WRITE INPUT FILE OR DEL/REW BUT NO PRIOR READ ' 'VSAM - VIRTSTOR. RESOURCE NOT AVAILABLE' 'VSAM - SEQUENTIAL READ AFTER END OF FILE OR NO CURRENT REC POINTER FOR SEQ' 'VSAM - INVALID FILE INFORMATION OR OPEN OUTPUT (LOAD) WITH FILE THAT NEVER CONTAINED DATA' 'VSAM - MISSING DD STATEMENT IN JCL' 'VSAM - OPEN OK, FILE INTEGRITY VERIFIED FILE SHOULD BE OK' 'UNKNOWN REASON' 74

146 ESCOLA DE PROGRAMADORES FORMAÇÃO MAINFRAME MÓDULO : DB2

147 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. COMO FUNCIONA O DB2? Conjunto de tabelas, índices e tablespaces agrupados DATABASE ÍNDICE Conjunto de Data Sets VSAM que contém uma ou mais tabelas TABLESPACE TABELA Forma Alternativa de enxergar uma tabela a fim de garantir segurança VIEW Agiliza a leitura de dados para garantir a UNICIDADE de dados Conjunto de Atributos reunidas segundo uma Regra de Negócio O MODELO RELACIONAL. Dos conceitos do modelo relacional retiramos as seguintes definições: Banco de Dados Relacionamentos Pesquisa (Query) É 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. O relacionamento entre as TABELAS é representado pelos VALORES contidos nestas TABELAS. 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

148 DB ELEMENTOS DO DB TABELAS. São estruturas lógicas mantidas pelo DB2 para representar uma entidade COLUNAS. É cada uma das informações que compõem uma tabela 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 Christiane D Karina R Júlio S Linhas Ingrid P Juan P Colunas 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: 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

149 DB 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 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) 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 Primária Chave Estrangeira Matr Nome Depto EMPR 419 Maria A Carlos Z13 DeptoCod DeptoNome DEPT Z13 A00 Reserva Vendas 3

150 DB 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

151 DB TIPOS DE DADOS. Os formatos dos dados nas colunas de uma tabela DB2 se dividem em 4 grandes grupos: STRING NUMERIC DATETIME ROWID 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é 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é (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é (2GB) bytes. Nome-da-coluna BLOB(tamanho-maximo) FORMATOS NUMERICOS INTEGER - Define colunas para conter números inteiros usando 31 bits mais sinal. Uma coluna INTEGER pode conter valores na faixa de até Sintaxe para definir uma coluna INTEGER: Nome-da-coluna INTEGER Exemplo: 5

152 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 até 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 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

153 DB2 Nome-da-coluna Exemplo: DATA-NASCIMENTO DATE 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 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 CONSTANTES. No DB2 as constantes alfanuméricas devem ser colocadas entre aspas simples. Ex.: JOSE 7

154 DB2 As constantes numéricas são escritas sem as aspas. As constantes com decimais devem usar o ponto para separar as decimais. Ex.: As constantes de DATA e HORA devem ser escritas no formato do exemplo abaixo: 14/02/ : 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 CURRENT TIME CURRENT TIMESTAMP USER DATA DO SISTEMA OPERACIONAL NO FORMATO DATE AAMMDD HORA DO SISTEMA OPERACIONAL NO FORMATO TIME - HHMMSS DATA E HORA DO SISTEMA OPERACIONAL NO FORMATO TIMESTAMP CHAR(26) USUÁRIO DO SISTEMA NO FORMATO CHAR(8) 8

155 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 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 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

156 DB2 STRUCTURED QUERY LANGUAGE SELECT INSERT UPDATE DELETE CREATE ALTER DROP GRANT REVOKE COMMIT ROLLBACK DML DDL CONTROL 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

157 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) 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 EXCLUINDO TABELAS. O comando para excluir uma tabela do DB2 é o DROP TABLE. Exemplo: DROP TABLE PRODUTO 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. SELECT INSERT UPDATE DELETE 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

158 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 =!= <> >!> >= <!< <= BETWEEN IN LIKE Descrição Igual Não igual Diferente Maior Não maior Maior ou igual Menor Não menor Menor ou igual O valor deve estar entre os dois limites Ex.: IDADE BETWEEN 1 AND 9 O valor deve ser um dos fornecidos na lista Ex.: IDADE IN (1, 3, 5, 7, 9) 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

159 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 >

160 DB 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 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 FROM FUNCIONARIOS ORDER BY NOME SELECT CARGO, SUM(SALARIO) FROM FUNCIONARIOS GROUP BY CARGO HAVING SUM(SALARIO) > Lista os nomes dos funcionários em ordem alfabética. Lista os cargos e respectiva soma de salários da tabela de funcionários somente para os cargos cuja soma de salários é superior a N$10000, 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

161 DB2 SELECT SQRT(25) FROM SYSIBM.SYSDUMMY1 A lista de funções é extensa e as principais estão na tabela seguinte: AVG(DISTINCT colunas-ouexpressões) COUNT(DISTINCT colunas-ouexpressões) MAX(colunas-ou-expressões) MIN(colunas-ou-expressões) SUM(DISTINCT colunas-ouexpressões) ABS(expressão) ABSVAL(expressão) CHAR(expressão) CHAR(date,formato) VALUE(expressão,expressão) COALESCE(expressão,expressão) CONCAT(expressão,expressão) DAYOFYEAR(expressão) DATE(expressão-ou-coluna) DAY(expressão) DAYOFMONTH(expressão) DAYOFWEEK(expressão) DAYOFWEEK_ISO(expressão) DAYS(expressão) DECIMAL(expressão,n1,n2) DEC(expressão,n1,n2) Obtém a media aritmética dos valores das colunas ou expressões. Se DISTINCT for usado, os valores repetidos serão desprezados. Obtém a quantidade de linhas selecionadas. Se DISTINCT for usado, as linhas repetidas não serão contadas. Obtém o maior valor contido nas colunas ou expressões selecionadas. Obtém o menor valor contido nas colunas ou expressões selecionadas. Obtém a soma dos valores das colunas ou expressões selecionadas. Se DISTINCT for usado, os valores repetidos não serão somados. Obtém o valor absoluto de uma 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 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. Retorna o valor da primeira expressão cujo valor não for NULL. Retorna um STRING formado pela união das duas expressões Devolve o dia do ano (numero entre 1 e 366) contido na expressão que deve ser do tipo DATE. Devolve um valor DATE contido na expressão ou coluna 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. Devolve o dia do mês (entre 1 e 31) retirado da expressão, que deve ser do tipo DATE Devolve o dia da semana contido na expressão que deve 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 Devolve um numero inteiro representando o numero de dias transcorridos entre o valor DATE da expressão e o dia 01/01/0001. Transforma o valor de expressão em valor no formato DECIMAL, contendo um total de n1 algarismos e n2 15

162 DB2 DIGITS(expressão) DOUBLE(expressão) FLOAT(expressão) HEX(expressão) HOUR(expressão) INSERT(string1,inicio,tamanho,string2) INTEGER(expressão) INT(expressão) LCASE(string) LOWER(string) LEFT(string1,tamanho) LENGTH(expressão) LOCATE(string1,string2,inicio) LTRIM(string1) MICROSECOND(expressão) MINUTE(expressão) MOD(expressão1,expressão2) MONTH(expressão) POWER(expressão1,expressão2) REPEAT(string1,quantidade) REPLACE(string1,string2,string3) RIGHT(string,tamanho) RTRIM(string) SECOND(expressão) SMALLINT(expressão) SPACE(expressão) SQRT(expressão) SUBSTR(string1,inicio,tamanho) TIME(expressão) decimais. 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. Retorna o valor da expressão ou coluna no formato DOUBLE. Retorna um STRING de dígitos hexadecimais com o valor da expressão. Retorna o valor da HORA contido na expressão. Expressão deve ter formato TIME ou TIMESTAMP. Insere STRING2 em STRING1 a partir da posição INICIO apagando TAMANHO bytes de STRING1. Retorna o valor da expressão no formato INTEGER Converte os caracteres de STRING para minúsculos. Retorna um STRING com o comprimento TAMANHO retirado do inicio de STRING1 Retorna o numero de caracteres do valor da expressão (ou coluna) Pesquisa a posição de STRING1 dentro de STRING2. INICIO é opcional e especifica a posição do caracter em STRING2 onde a pesquisa inicia. Remove SPACES do inicio de STRING1 Devolve o valor dos MICROSSEGUNDOS contidos na expressão. Expressão precisa ter formato TIME ou TIMESTAMP. Devolve o valor dos MINUTOS contidos na expressão. Expressão deve ter formato TIME ou TIMESTAMP Esta função devolve o resto da divisão de EXPRESSÃO1 por EXPRESSÃO2 Devolve o valor do MES contido na expressão. Expressão deve ter formato DATE ou TIMESTAMP Calcula o valor de EXPRESSÃO1 elevada a potencia indicada em EXPRESSÃO2. Devolve um STRING formado pela repetição de STRING1 vezes QUANTIDADE. Substitui todas as ocorrências de STRING2 por STRING3 dentro de STRING1 Devolve os últimos TAMANHO caracteres de STRING Remove os espaços do fim de STRING. Devolve o valor dos SEGUNDOS contidos na expressão. Expressão deve ter formato TIME ou TIMESTAMP Retorna o valor da expressão no formato SMALLINT Produz um STRING no formato VARCHAR contendo espaços com o comprimento dado pelo valor de EXPRESSÃO. Devolve a raiz quadrada do valor de EXPRESSÃO. O resultado tem formato DOUBLE. 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. Converte EXPRESSÃO para o formato TIME. 16

163 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) > 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

164 DB 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 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

165 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: ALL IN ANY SOME EXISTS A condição do WHERE deve ser satisfeita para TODAS as linhas da SUB-QUERY. A condição do WHERE deve ser satisfeita pelo menos por UMA linha da SUB-QUERY O WHERE é verdadeiro se a SUB-QUERY tiver pelo menos UMA linha. Exemplos:. Indique o resultado destas QUERIES: SELECT NOME SALARIO FROM FUNCIONARIOS WHERE CODDEPTO = `P1` AND SALARIO > ALL ( SELECT SALARIO FROM FUNCIONARIOS WHERE CODDEPTO = `P2`) SELECT NOME SALARIO FROM FUNCIONARIOS WHERE CODDEPTO = `P1` AND SALARIO > ANY ( SELECT SALARIO FROM FUNCIONARIOS WHERE CODDEPTO = `P2`) SELECT NOME SALARIO FROM FUNCIONARIOS WHERE CODDEPTO = P1 AND EXISTS( SELECT CODPROJ FROM FUNCIONARIOS WHERE CODEPTO = `P1`) INSERT O comando INSERT é usado para incluir novas linhas em uma tabela. Sua sintaxe : INSERT INTO nome-tabela (coluna, coluna...) VALUES(valor, valor...) 19

166 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, ) 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

167 DB2 Exemplo: UPDATE EMPREGADOS SET(SALARIO, BONUS, COMISSAO) = (SALARIO * 1.10, NULL, 10.00) WHERE CODDEPTO = `P10` 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

168 DB2 3 - PROGRAMANDO EM COBOL INTRODUÇÃO 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 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

169 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

170 DB 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 INDSTRUCT(1) INDSTRUCT(2) INDSTRUCT(3) INDSTRUCT(4) COLUNA CODIGO NOME QUANTIDADE PRUNIT TESTE DE ERRO NOS COMANDOS 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 SQLCODE < 0 SQLCODE > 0 Execução sem erro. Comando não foi executado. O codigo do erro é o valor do SQLCODE. 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

171 DB2 Alguns valores importantes do SQLCODE: SQLCODE = 100 SQLCODE = -803 Linha pesquisada não existe Linha com esta PRIMARY KEY já existe * Lista completa dos SQLCODES no apêndice A 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: Ou EXEC SQL WHENEVER condição GO TO paragrafo END-EXEC EXEC SQL WHENEVER condição CONTINUE END-EXEC 25

172 DB2 Exemplo: EXEC SQL WHENEVER NOT FOUND GO TO NÃO-EXISTE END-EXEC 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 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 INDICATOR = -2 INDICATOR = 0 INDICATOR > 0 Coluna contem NULL Erro na conversão de valores Coluna contem valores normais 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

173 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 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: WORKING-STORAGE SECTION 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 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

174 DB2 Exemplo: MOVE `000001` TO CODIGO. EXEC SQL SELECT NOMEEMP, SALARIO INTO :NOME, :SALARIO WHERE CODEMP > :CODIGO FETCH FIRST ROW ONLY END-EXEC 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

175 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 WHERE CODDEPTO = `P10` 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 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 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

176 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 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 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

177 DB2 EXEC SQL DECLARE nome-do-cursor CURSOR FOR 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 DECLARE nome-do-cursor CURSOR FOR 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

178 DB2 Exemplo: EXEC SQL DELETE FROM PRODUTO WHERE CODIGO = :CODIGO END-EXEC 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 DECLARE nome-do-cursor CURSOR FOR 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

179 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

180 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

181 DB2 APÊNDICE A SQL CODES DB2 - SQLCode EXECUÇÃO EFETUADA COM SUCESSO Linha não encontrada para FETCH, UPDATE, DELETE ou o resultado de uma QUERY é uma tabela vazia 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 GRANT foi ignorado porquê já está com GRANT PUBLIC GRANT foi ignorado para alteração Comando contém caracter inválido STRING iniciada e não terminada Especificação inválida Comando SQL inaceitável O comando é muito longo ou muito complexo O tamanho da constante na STRING é maior que 254 caracteres ou 124 caracteres gráficos literal é uma literal numérica inválida Comando contém caracter inválido STRING inválida O nome name é muito longo. Tamanho máximo permitido é size clause cláusula não permitida Literal hexadecimal iniciando STRING inválida Uma função de coluna não incluiu o nome de uma das colunas O operando de uma função de coluna é outra função de coluna ou DISTINCT seguido de uma expressão Caracter inválido encontrado em um nome: name 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 A quantidade de valores em um INSERT não corresponde ao número de colunas objetos. 35

182 DB A tabela objeto ou VIEW de um comando INSERT, DELETE, ou UPDATE está também identificado na clausula FROM Uma coluna citada em uma cláusula HAVING não foi inclusa na cláusula GROUP BY Uma cláusula WHERE ou SET inclui uma função de coluna ou a cláusula WHERE referenciase a uma coluna que deriva de uma função de coluna de uma VIEW definida O nome da coluna foi citado mais de uma vez no comando INSERT ou UPDATE 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 Um integrante da cláusula ORDER BY não identifica o resultado de uma coluna O comando SELECT contém uma cláusula UPDATE e uma cláusula ORDER BY ao mesmo tempo DISTINCT está especificado mais que uma vez em um subselect Uso inválido de NULL em um predicado O comando contém nomes de tabelas em excesso O comando com predicado LIKE possui tipos de dados incompatíveis Um predicado LIKE está inválido porquê o primeiro operando não é uma coluna ou o segundo operando não é um STRING 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 Uso impróprio de uma coluna STRING muito grande nome_de_coluna ou uma variável HOST com tamanho máximo maior que SORT não pode ser executado porquê o tamanho da chave do SORT possui mais que 4000 bytes Resultado de uma concatenação é muito grande O segundo ou terceiro argumento de uma função SUBSTR está fora do limite (RANGE) O objeto de um comando INSERT, DELETE, ou UPDATE é uma VIEW que não permite esse comandos solicitados 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 O comando CREATE VIEW não inclui uma lista de colunas solicitadas O comando CREATE VIEW falhou porquê a definição da VIEW contém um UNION ou um 36

183 DB2 UNION ALL O comando ALTER TABLE, DROP TABLE, LOCK TABLE, ou CREATE INDEX referencia-se a uma VIEW O numero de colunas especificadas para a VIEW não é o mesmo especificado pela cláusula SELECT O nome especificado em um DROP VIEW é um nome de tabela A opção WITH CHECK não pode ser utilizada pela VIEW especificada O INSERT ou UPDATE não é permitido porquê a linha resultante não satisfaz a definição da VIEW auth_id1 Não possui privilégio para criar VIEW com qualificação auth_id O número de argumentos especificados para function_name é inválido O tipo de dado, tamanho ou valor do argumento nn de function_name é inválido não é um nome de função válido A STRING de representação de um valor DATETIME está com sintaxe inválida A STRING de representação de um valor DATETIME possuí valor inválido Uma expressão aritmética com valor DATETIME inválido Uma expressão aritmética em uma DATA ou TIMESTAMP possuí um resultado inválido para o range de datas Uma expressão aritmética com valore DATETIME contém um PARAMETER MAKER A opção formato local está sendo usada com uma data ou hora e a saída NO LOCAL está sendo instalada O tamanho da data/hora local está sendo aumentado e executando um programa que ajusta o tamanho antigo O operando de preparo ou comando imediato de EXECUTE está branco ou vazio Uso ilegal de palavra-chave. TOKEN token-list é esperado Referencia ambígua a uma coluna column_name nome É um nome indefinido nome-de-coluna Não é uma coluna da tabela nome-de-tabela 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 a cláusula ORDER BY está inválida porque o nome da coluna não faz parte da Tabela. 37

184 DB a tabela desejada não existe a coluna column-name na tabela table-name não foi definida apropriadamente o valor da variável HOST não pode ser utilizado como especificado devido ao tipo de dado o valor de uma variável de entrada é muito grande para o tipo de coluna definida um valor não pode ser assinalado para uma variável HOST porque os tipos de dados não são compatíveis 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 valor null não pode ser armazenado na HOST devido a falta de variável indicadora o predicado é inválido pois a variável HOST referenciada contém valor nulo variável HOST no formato decimal e valor resultante é não decimal o tamanho definido para a variável HOST é negativo variável HOST não definida ou não utilizada o número de variáveis HOST assinaladas no INTO difere das colunas assinaladas no SELECT tipos de dados na comparação são incompatíveis ( ex.: comparação de numérico =alfa) uma função ou operador aritmético está sendo utilizado para um campo CHAR ou DATETIME o comando UPDATE ou INSERT possui uma STRING de tamanho muito grande 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 um valor calculado ou derivado numérico está fora do range permitido para a coluna ( vide - 405) o valor de um UPDATE ou INSERT é nulo, mas a coluna não aceita nulo o valor de um UPDATE ou INSERT não é compatível com o tipo de dado da coluna operando inválido em uma função COUNT a literal de ponto flutuante contém mais de 30 caracteres a DATETIME corrente ou chave do usuário não pode ser utilizada como especificado a clausula SELECT de uma subquerie especifica múltiplas colunas durante a conversão de um dado ocorreu overflow. 38

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

186 DB 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 O relacionamento restringe a deleção da linha com RID X nd-number INSERT de linhas múltiplas inválido A chave primária não pode ser alterada pôr causa de multiple-rows UPDATE UPDATE ou DELETE inválido com WHERE CURRENT OF O comando DELETE está inválido pois a tabela pode ser afetada pela operação A chave primária ou estrangeira foi identificada na cláusula mais de uma vez A chave estrangeira não está conforme a descrição da chave primária da tabela A tabela não possui chave primária A definição da tabela está incompleta porque não possui um índice primário A chave estrangeira está inválida porque ela é duplicate referential constraint A coluna não pode ser chave primária porque pode conter nulos O usuário não possui privilégio para efetuar a operação. (falta de GRANT) O usuário não possui privilégio para efetuar a operação O usuário não é um dos IDS autorizados Usuário não pode conceder GRANT para si mesmo O usuário não pode revogar um GRANT para ele próprio O privilégio não pode ser revogado porque o usuário não possui autoridade para revogá-lo O GRANT ou REVOKE com chave inconsistente. Verifique as chaves permitidas Clausula ou combinação inválida em um GRANT ou REVOKE Todas as funções de autorização estão desabilitadas O comando poderá alterar diversos linhas, confirme O nome do objeto a ser criado é idêntico a de um tipo de objeto Excesso de colunas especificadas em uma criação de índice O índice único não pode ser criado pois nele está incluso colunas com valores duplicados A definição da coluna possui tamanho ou atributo inválidos Operação não definida pelo sistema de tabelas 40

187 DB Nome da coluna duplicado A chave primária é muito grande ou contem excesso de colunas O índice não pode ser criado porque a soma do tamanho interno das colunas é maior que o máximo permitido Objeto não pode ser dropado (apagado) porque é referenciado pôr outro objeto A operação não é permitida pelo sistema de base de dados Operação desabilitada porque o arquivo de trabalho do banco de dados está operante chave keyword IN strn type1 comando não é permitido para um tablespace no workfile data base Duplicate dbid foi detectado e previamente assinalado para database-name Um índice de agrupamento já existe na tabela Tabela já possui chave primária Tabela não tem obrigatoriedade de paridade no índice para a chave primária O comando ALTER não é executado porque o pageset não foi parado O comando ALTER está inválido porque o pageset esta user-managed data sets Um table-space segmentado não pode ser dividido (partitioned) O valor nulo não pode ser setado pois a chave estrangeira não pode conter valor nulo Nome da chave estrangeira muito grande ou tem muitas colunas A tabela não pode ser definida como dependente de outra pôr causa das regras de restrições de DELETE A regra de DELETE deverá ser xxxxx A regra de DELETE não pode ser em cascata As regras de DELETE não podem ser diferentes ou nula As chaves de compartilhamento não estão ordenadas ascendentes ou descendentes Chave duplicada Tabela não pode ser criada porque está faltando definição da coluna 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 Valor inválido especificado para a chave no comando A tabela não pode ser criada em um tablespace particionada/default porque ele já contém uma 41

188 DB2 tabela O bufferpool não pôde ser especificado porque não havia sido ativado Violação de uma regra de edição ou procedimento de validação A tabela no tablespace particionado não está disponível porque o índice particionado não havia sido criado Índice não pode ser criado ou partilhado porque chaves limites não foram especificadas Índice não pode ser criado ou partilhado porque o número de partes especificadas não é igual ao número de partições Índice particionado não pode ser criado em uma tablespace não particionada O nr. de chave limite de valores é zero ou maior que o nr de colunas da chave índice O tamanho interno da chave-limite de campos para o indice particionado excede o tamanho imposto pelo gerenciador de índices A cláusula PART de um comando ALTER está omitida ou inválida stmt-verb object NÃO PODE SER EXECUTADA PORQUE function ESTÁ SENDO EXECUTADA O índice CLUSTERING para um tablespace particionada não pode ser EXPLICIT DROPPED A coluna não pode ser adicionada a tabela porque a tabela possui um EDIT PROCEDURE A tabela em um tablespace particionado não pode ser EXPLICITY DROPPED O tamanho do registro da tabela excede o tamanho limite da página O atributo BUFFERPOOL da tablespace não pode ser alterado como foi especificado porque isso poderia afetar o tamanho de página da tablespace Uma página de 32k BUFFERPOOL não pode ser utilizada ou indexada Insuficiente VIRTUAL STORAGE para expansão do BUFFERPOOL A literal xxx especificada como chave limite de índice deve estar de acordo com o tipo de dado xxx para a coluna correspondente xxxxx O objeto xxx não pode ser criado pois há um DROP pendente para ele Muita colunas especificadas para uma tabela Column column-name in violation of installation defined field procedure. RT: return-code, RS: reason-code, MSG: message-tokes O campo procedure procedure-name não pode se carregado Tipo de coluna inválida para opção FIELDPROC, column-name 42

189 DB O tamanho da literal iniciante da lista string é muito grande Tipo de campo inválido, column-name A coluna definida com um campo procedure não pode ser comparada com outra coluna de campo procedure diferente Tipos de campos incomparáveis Dado incorreto retornado de um campo procedure, column-name Exception-error exception-type ocorreu durante operation-type operação em data-type Dado position-number O valor de uma ou mais linhas estão inválidos pois a coluna objeto não permite duplicidade. (chave única) Um erro foi encontrado no parametro de entrada do programa de aplicação para o comando sql O nome do programa program-name não foi encontrado no plano plan-name 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 Uma clausula group by ou having está implicitamente ou explicitamente especificada em um comando embedded select ou de um predicado basico da subquery O insert, update, delete, DDL ou autorização não pode ser executada porque a transação IMS/VS é somente inquiry O precompiler-generated timestamp x in the load module é diferente do bind timestamp y built from the dbrm A view não pode ser recriada porque ela referencia a uma view que não pode ser recriada O comando SQL nào pode ser processado porque catalog-table contém um valor que não é válido nesta versão A view view-creator.view-name está sendo dropado durante a migração. Criador synonymcreator de sinônimo synonym-name não pode ser resolvido O SQLDA contém um endereço de dado ou variável indicadora inválido Muitos itens retornados em uma lista de select ou insert.this help file was created with HelpScribble Execução mal sucedida causada por um erro de sistema que não impede a execução com sucesso dos comandos SQL seguintes Execução mal sucedida causada por um erro de sistema que impede a execução com sucesso dos comandos SQL seguintes Cancelamento causado por um recurso indisponivel reason-code, tipo de recurso resourcetype, e nome do recurso resource-name. 43

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

191 DB2 APÊNDICE B PROGRAMAS EXEMPLOS Exemplo: Select ID DIVISION. PROGRAM-ID. DB2SELE. ENVIRONMENT DIVISION. CONFIGURATION SECTION. SPECIAL-NAMES. DECIMAL-POINT IS COMMA. DATA DIVISION. WORKING-STORAGE SECTION. 77 ASTERISCOS PIC X(40) VALUE ALL '*'. 77 WS-SALARIO PIC ZZ.ZZZ.ZZ9, 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. ACCEPT WS-MATRICULA FROM SYSIN. 200-FIM. EXIT. 300-FINAL SECTION. DISPLAY '********** FIM DO PROCESSAMENTO **********'. 300-FIM. EXIT. 45

192 DB2 Exemplo: Insert ID DIVISION. PROGRAM-ID. DB2INSER. ENVIRONMENT DIVISION. CONFIGURATION SECTION. SPECIAL-NAMES. DECIMAL-POINT IS COMMA. DATA DIVISION. WORKING-STORAGE SECTION. 77 ASTERISCO PIC X(53) VALUE ALL '*'. 01 WS-LINHA. 03 WS-MATRICULA PIC 9(5). 03 WS-NOME PIC X(20). 03 WS-SALARIO PIC 9(5)V WS-COD-CARGO PIC WS-COD-DEPTO PIC 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 FILLER PIC X VALUE '-'. 03 WS-DIA PIC XX. 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. MOVE 30 TO NOME-LEN. ACCEPT WS-LINHA FROM SYSIN. 100-FIM. EXIT. 200-PROCESSAR SECTION. MOVE WS-MATRICULA TO MATRICULA. 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 =

193 DB2 DISPLAY 'MATRICULA: ' WS-MATRICULA ' CODIGO CARGO: ' WS-COD-CARGO DISPLAY ' OU CODIGO DEPARTAMENTO: ' WS-COD-DEPTO ' INEXISTENTE.' DISPLAY ASTERISCOS END-IF. ACCEPT WS-LINHA FROM SYSIN. 200-FIM. EXIT. 300-FINAL SECTION. DISPLAY '********** FIM DO PROCESSAMENTO **********'. 300-FIM. EXIT. 47

194 DB2 Exemplo: UPDATE ID DIVISION. PROGRAM-ID. DB2UPDA. ENVIRONMENT DIVISION. CONFIGURATION SECTION. SPECIAL-NAMES. DECIMAL-POINT IS COMMA. DATA DIVISION. WORKING-STORAGE SECTION. 77 ASTERISCOS PIC X(53) VALUE ALL '*'. 01 WS-LINHA. 03 WS-MATRICULA PIC 9(5). 03 WS-NOME PIC X(20). 03 WS-SALARIO PIC 9(5)V WS-COD-CARGO PIC WS-COD-DEPTO PIC 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 FILLER PIC X VALUE '-'. 03 WS-MES PIC XX. 03 FILLER PIC X VALUE '-'. 03 WS-DIA PIC XX. 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. MOVE 30 TO NOME-LEN. ACCEPT WS-LINHA FROM SYSIN. 100-FIM. EXIT. 200-PROCESSAR SECTION. MOVE WS-MATRICULA TO MATRICULA. 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 'MATRICULA: ' WS-MATRICULA DISPLAY 'FUNCIONARIO NAO CADASTRADO.' DISPLAY ASTERISCOS END-IF. IF SQLCODE =

195 DB2 DISPLAY 'MATRICULA: ' WS-MATRICULA ' CODIGO CARGO: ' WS-COD-CARGO DISPLAY ' OU CODIGO DEPARTAMENTO: ' WS-COD-DEPTO ' INEXISTENTE.' DISPLAY ASTERISCOS END-IF. ACCEPT WS-LINHA FROM SYSIN. 200-FIM. EXIT. 300-FINAL SECTION. DISPLAY '********** FIM DO PROCESSAMENTO **********'. 300-FIM. EXIT. 49

196 DB2 Exemplo: DELETE ID DIVISION. PROGRAM-ID. DB2DELE. ENVIRONMENT DIVISION. CONFIGURATION SECTION. SPECIAL-NAMES. DECIMAL-POINT IS COMMA. DATA DIVISION. WORKING-STORAGE SECTION. 77 ASTERISCOS PIC X(40) VALUE ALL '*'. 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 DELETE FROM FUNCIONARIO WHERE MATRICULA =:MATRICULA END-EXEC. IF SQLCODE = +100 DISPLAY 'MATRICULA: ' WS-MATRICULA ' FUNCIONARIO NAO EXISTE.' DISPLAY ASTERISCOS END-IF. ACCEPT WS-MATRICULA FROM SYSIN. 200-FIM. EXIT. 300-FINAL SECTION. DISPLAY '********** FIM DO PROCESSAMENTO **********'. 300-FIM. EXIT. 50

197 DB2 Exemplo: CURSOR e FECTH ID DIVISION. PROGRAM-ID. DB2CF. ENVIRONMENT DIVISION. CONFIGURATION SECTION. SPECIAL-NAMES. DECIMAL-POINT IS COMMA. DATA DIVISION. WORKING-STORAGE SECTION. 77 ASTERISCOS PIC X(40) VALUE ALL '*'. 77 WS-SALARIO PIC ZZ.ZZZ.ZZ9, WS-CARGO-DEPTO PIC ZZZ9. EXEC SQL INCLUDE MFUNCION END-EXEC. EXEC SQL INCLUDE SQLCA END-EXEC. PROCEDURE DIVISION. 000-PRINCIPAL SECTION. 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. 200-PROCESSAR SECTION. 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. DISPLAY '********** FIM DO PROCESSAMENTO **********'. 300-FIM. EXIT. 51

198 DB2 52