COBOL - Guia rápido
Introdução ao COBOL
COBOL é uma linguagem de alto nível. É preciso entender como funciona o COBOL. Os computadores só entendem código de máquina, um fluxo binário de 0s e 1s. O código COBOL deve ser convertido em código de máquina usando umcompiler. Execute o código-fonte do programa por meio de um compilador. O compilador primeiro verifica se há erros de sintaxe e depois os converte em linguagem de máquina. O compilador cria um arquivo de saída que é conhecido comoload module. Este arquivo de saída contém código executável na forma de 0s e 1s.
Evolução do COBOL
Durante a década de 1950, quando as empresas estavam crescendo na parte ocidental do mundo, houve a necessidade de automatizar vários processos para facilitar a operação e isso deu origem a uma linguagem de programação de alto nível destinada ao processamento de dados de negócios.
Em 1959, o COBOL foi desenvolvido pela CODASYL (Conference on Data Systems Language).
A próxima versão, COBOL-61, foi lançada em 1961 com algumas revisões.
Em 1968, o COBOL foi aprovado pela ANSI como uma linguagem padrão para uso comercial (COBOL-68).
Foi novamente revisado em 1974 e 1985 para desenvolver versões subsequentes denominadas COBOL-74 e COBOL-85, respectivamente.
Em 2002, o COBOL Orientado a Objetos foi lançado, podendo usar objetos encapsulados como uma parte normal da programação COBOL.
Importância do COBOL
COBOL foi a primeira linguagem de programação de alto nível amplamente usada. É uma língua semelhante ao inglês, de fácil utilização. Todas as instruções podem ser codificadas em palavras simples em inglês.
COBOL também é usado como linguagem de autodocumentação.
COBOL pode lidar com enorme processamento de dados.
COBOL é compatível com suas versões anteriores.
O COBOL tem mensagens de erro eficazes e, portanto, a resolução de bugs é mais fácil.
Características do COBOL
Linguagem padrão
COBOL é uma linguagem padrão que pode ser compilada e executada em máquinas como IBM AS / 400, computadores pessoais, etc.
Orientado à Negócios
O COBOL foi projetado para aplicativos orientados a negócios relacionados ao domínio financeiro, domínio de defesa, etc. Ele pode lidar com grandes volumes de dados devido aos seus recursos avançados de gerenciamento de arquivos.
Linguagem robusta
COBOL é uma linguagem robusta, pois suas inúmeras ferramentas de depuração e teste estão disponíveis para quase todas as plataformas de computador.
Linguagem Estruturada
Estruturas de controle lógico estão disponíveis em COBOL, o que torna mais fácil de ler e modificar. O COBOL tem diferentes divisões, por isso é fácil de depurar.
Instalando COBOL no Windows / Linux
Existem muitos emuladores de mainframe gratuitos disponíveis para Windows que podem ser usados para escrever e aprender programas COBOL simples.
Um desses emuladores é o Hercules, que pode ser facilmente instalado no Windows seguindo alguns passos simples, conforme mostrado abaixo -
Baixe e instale o emulador Hercules, que está disponível no site da Hercules: www.hercules-390.eu
Depois de instalar o pacote na máquina Windows, ele criará uma pasta como C:/hercules/mvs/cobol.
Execute o Prompt de Comando (CMD) e acesse o diretório C: / hercules / mvs / cobol no CMD.
O guia completo sobre vários comandos para escrever e executar programas JCL e COBOL pode ser encontrado em:
www.jaymoseley.com/hercules/installmvs/instmvs2.htm
Hercules é uma implementação de software de código aberto das arquiteturas mainframe System / 370 e ESA / 390, além da arquitetura z / de 64 bits mais recente. Hercules é executado em Linux, Windows, Solaris, FreeBSD e Mac OS X.
Um usuário pode se conectar a um servidor mainframe de várias maneiras, como thin client, terminal fictício, Virtual Client System (VCS) ou Virtual Desktop System (VDS). Cada usuário válido recebe um ID de login para entrar na interface Z / OS (TSO / E ou ISPF).
Compilando programas COBOL
Para executar um programa COBOL em modo batch usando JCL, o programa precisa ser compilado e um módulo de carregamento é criado com todos os subprogramas. O JCL usa o módulo de carregamento e não o programa real no momento da execução. As bibliotecas de carga são concatenadas e fornecidas ao JCL no momento da execução usandoJCLLIB ou STEPLIB.
Existem muitos utilitários de compilador de mainframe disponíveis para compilar um programa COBOL. Algumas empresas corporativas usam ferramentas de gerenciamento de mudanças, comoEndevor, que compila e armazena todas as versões do programa. Isso é útil para rastrear as alterações feitas no programa.
//COMPILE JOB ,CLASS = 6,MSGCLASS = X,NOTIFY = &SYSUID
//*
//STEP1 EXEC IGYCRCTL,PARM = RMODE,DYNAM,SSRANGE
//SYSIN DD DSN = MYDATA.URMI.SOURCES(MYCOBB),DISP = SHR
//SYSLIB DD DSN = MYDATA.URMI.COPYBOOK(MYCOPY),DISP = SHR
//SYSLMOD DD DSN = MYDATA.URMI.LOAD(MYCOBB),DISP = SHR
//SYSPRINT DD SYSOUT=*
//*IGYCRCTL é um utilitário compilador IBM COBOL. As opções do compilador são passadas usando o parâmetro PARM. No exemplo acima, RMODE instrui o compilador a usar o modo de endereçamento relativo no programa. O programa COBOL é passado usando o parâmetro SYSIN. Copybook é a biblioteca usada pelo programa em SYSLIB.
Executando Programas COBOL
A seguir, é fornecido um exemplo de JCL onde o programa MYPROG é executado usando o arquivo de entrada MYDATA.URMI.INPUT e produz dois arquivos de saída gravados no spool.
//COBBSTEP JOB CLASS = 6,NOTIFY = &SYSUID
//
//STEP10 EXEC PGM = MYPROG,PARM = ACCT5000
//STEPLIB DD DSN = MYDATA.URMI.LOADLIB,DISP = SHR
//INPUT1 DD DSN = MYDATA.URMI.INPUT,DISP = SHR
//OUT1 DD SYSOUT=*
//OUT2 DD SYSOUT=*
//SYSIN DD *
//CUST1 1000
//CUST2 1001
/*O módulo de carregamento de MYPROG está localizado em MYDATA.URMI.LOADLIB. É importante observar que o JCL acima pode ser usado apenas para um módulo COBOL não DB2.
Executando programas COBOL-DB2
Para executar um programa COBOL-DB2, um utilitário IBM especializado é usado no JCL e no programa; A região do DB2 e os parâmetros necessários são passados como entrada para o utilitário.
As etapas seguidas na execução de um programa COBOL-DB2 são as seguintes -
Quando um programa COBOL-DB2 é compilado, um DBRM (Módulo de Solicitação de Banco de Dados) é criado junto com o módulo de carregamento. O DBRM contém as instruções SQL dos programas COBOL com sua sintaxe verificada para estar correta.
O DBRM está vinculado à região do DB2 (ambiente) na qual o COBOL será executado. Isso pode ser feito usando o utilitário IKJEFT01 em um JCL.
Após a etapa de ligação, o programa COBOL-DB2 é executado usando IKJEFT01 (novamente) com a biblioteca de carregamento e a biblioteca DBRM como a entrada para o JCL.
//STEP001 EXEC PGM = IKJEFT01
//*
//STEPLIB DD DSN = MYDATA.URMI.DBRMLIB,DISP = SHR
//*
//input files
//output files
//SYSPRINT DD SYSOUT=*
//SYSABOUT DD SYSOUT=*
//SYSDBOUT DD SYSOUT=*
//SYSUDUMP DD SYSOUT=*
//DISPLAY DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSTSPRT DD SYSOUT=*
//SYSTSIN DD *
DSN SYSTEM(SSID)
RUN PROGRAM(MYCOBB) PLAN(PLANNAME) PARM(parameters to cobol program) -
LIB('MYDATA.URMI.LOADLIB')
END
/*No exemplo acima, MYCOBB é o programa COBOL-DB2 executado usando IKJEFT01. Observe que o nome do programa, o ID do subsistema do DB2 (SSID) e o nome do plano do DB2 são transmitidos na instrução SYSTSIN DD. A biblioteca DBRM é especificada no STEPLIB.
A estrutura de um programa COBOL consiste em divisões, conforme mostrado na imagem a seguir -
Uma breve introdução dessas divisões é fornecida abaixo -
Sectionssão a subdivisão lógica da lógica do programa. Uma seção é uma coleção de parágrafos.
Paragraphssão a subdivisão de uma seção ou divisão. É um nome definido pelo usuário ou predefinido seguido por um ponto e consiste em zero ou mais sentenças / entradas.
Sentencessão a combinação de uma ou mais declarações. As sentenças aparecem apenas na divisão Procedimento. Uma frase deve terminar com um ponto final.
Statements são instruções COBOL significativas que executam algum processamento.
Characters são os mais baixos na hierarquia e não podem ser divisíveis.
Você pode co-relacionar os termos mencionados acima com o programa COBOL no seguinte exemplo -
PROCEDURE DIVISION.
A0000-FIRST-PARA SECTION.
FIRST-PARAGRAPH.
ACCEPT WS-ID - Statement-1 -----|
MOVE '10' TO WS-ID - Statement-2 |-- Sentence - 1
DISPLAY WS-ID - Statement-3 -----|
.Divisões
Um programa COBOL consiste em quatro divisões.
Divisão de Identificação
É a primeira e única divisão obrigatória de todo programa COBOL. O programador e o compilador usam essa divisão para identificar o programa. Nesta divisão, PROGRAM-ID é o único parágrafo obrigatório. PROGRAM-ID especifica o nome do programa que pode consistir de 1 a 30 caracteres.
Experimente o seguinte exemplo usando o Live Demo opção online.
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
PROCEDURE DIVISION.
DISPLAY 'Welcome to Tutorialspoint'.
STOP RUN.Dado abaixo é o JCL para executar o programa COBOL acima.
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
Welcome to TutorialspointDivisão de Meio Ambiente
A divisão de ambiente é usada para especificar arquivos de entrada e saída para o programa. Consiste em duas seções -
Configuration sectionfornece informações sobre o sistema no qual o programa é escrito e executado. Consiste em dois parágrafos -
Computador de origem - Sistema usado para compilar o programa.
Computador objeto - Sistema usado para executar o programa.
Input-Output sectionfornece informações sobre os arquivos a serem usados no programa. Consiste em dois parágrafos -
Controle de arquivo - fornece informações de conjuntos de dados externos usados no programa.
Controle IO - Fornece informações sobre os arquivos usados no programa.
ENVIRONMENT DIVISION.
CONFIGURATION SECTION.
SOURCE-COMPUTER. XXX-ZOS.
OBJECT-COMPUTER. XXX-ZOS.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT FILEN ASSIGN TO DDNAME
ORGANIZATION IS SEQUENTIAL.Divisão de Dados
A divisão de dados é usada para definir as variáveis usadas no programa. Consiste em quatro seções -
File section é usado para definir a estrutura de registro do arquivo.
Working-Storage section é usado para declarar variáveis temporárias e estruturas de arquivo que são usadas no programa.
Local-Storage sectioné semelhante à seção Working-Storage. A única diferença é que as variáveis serão alocadas e inicializadas toda vez que um programa iniciar a execução.
Linkage section é usado para descrever os nomes de dados que são recebidos de um programa externo.
COBOL Program
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT FILEN ASSIGN TO INPUT.
ORGANIZATION IS SEQUENTIAL.
ACCESS IS SEQUENTIAL.
DATA DIVISION.
FILE SECTION.
FD FILEN
01 NAME PIC A(25).
WORKING-STORAGE SECTION.
01 WS-STUDENT PIC A(30).
01 WS-ID PIC 9(5).
LOCAL-STORAGE SECTION.
01 LS-CLASS PIC 9(3).
LINKAGE SECTION.
01 LS-ID PIC 9(5).
PROCEDURE DIVISION.
DISPLAY 'Executing COBOL program using JCL'.
STOP RUN.o JCL para executar o programa COBOL acima é o seguinte -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//INPUT DD DSN = ABC.EFG.XYZ,DISP = SHRQuando você compila e executa o programa acima, ele produz o seguinte resultado -
Executing COBOL program using JCLDivisão de Procedimento
A divisão de procedimento é usada para incluir a lógica do programa. Consiste em instruções executáveis usando variáveis definidas na divisão de dados. Nesta divisão, os nomes dos parágrafos e das seções são definidos pelo usuário.
Deve haver pelo menos uma instrução na divisão do procedimento. A última declaração para encerrar a execução nesta divisão éSTOP RUN que é usado nos programas de chamada ou EXIT PROGRAM que é usado nos programas chamados.
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NAME PIC A(30).
01 WS-ID PIC 9(5) VALUE 12345.
PROCEDURE DIVISION.
A000-FIRST-PARA.
DISPLAY 'Hello World'.
MOVE 'TutorialsPoint' TO WS-NAME.
DISPLAY "My name is : "WS-NAME.
DISPLAY "My ID is : "WS-ID.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
Hello World
My name is : TutorialsPoint
My ID is : 12345Conjunto de caracteres
'Personagens' são os mais baixos na hierarquia e não podem ser mais divididos. O conjunto de caracteres COBOL inclui 78 caracteres que são mostrados abaixo -
| Sr. Não. | Descrição do personagem |
|---|---|
| 1 | A-Z Alfabetos (maiúsculas) |
| 2 | a-z Alfabetos (minúsculas) |
| 3 | 0-9 Numérico |
| 4 |
Espaço |
| 5 | + Sinal de mais |
| 6 | - Sinal de menos ou hífen |
| 7 | * Asterisco |
| 8 | / Barra para frente |
| 9 | $ Sinal de moeda |
| 10 | , Vírgula |
| 11 | ; Ponto e vírgula |
| 12 | . Ponto decimal ou período |
| 13 | " Aspas |
| 14 | ( Parêntese Esquerdo |
| 15 | ) Parêntese direito |
| 16 | > Maior que |
| 17 | < Menor que |
| 18 | : Cólon |
| 19 | ' Apóstrofo |
| 20 | = Sinal de igual |
Folha de Codificação
O programa de origem do COBOL deve ser escrito em um formato aceitável para os compiladores. Os programas COBOL são escritos em folhas de codificação COBOL. Existem 80 posições de caracteres em cada linha de uma folha de codificação.
As posições dos personagens são agrupadas nos seguintes cinco campos -
| Posições | Campo | Descrição |
|---|---|---|
| 1-6 | Números de coluna | Reservado para números de linha. |
| 7 | Indicador | Pode ter um asterisco (*) indicando comentários, hífen (-) indicando continuação e barra (/) indicando avanço de formulário. |
| 8-11 | Área A | Todas as divisões COBOL, seções, parágrafos e algumas entradas especiais devem começar na Área A. |
| 12-72 | Área B | Todas as instruções COBOL devem começar na área B. |
| 73-80 | Área de Identificação | Ele pode ser usado conforme necessário pelo programador. |
Exemplo
O exemplo a seguir mostra uma folha de codificação COBOL -
000100 IDENTIFICATION DIVISION. 000100
000200 PROGRAM-ID. HELLO. 000101
000250* THIS IS A COMMENT LINE 000102
000300 PROCEDURE DIVISION. 000103
000350 A000-FIRST-PARA. 000104
000400 DISPLAY “Coding Sheet”. 000105
000500 STOP RUN. 000106JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
Coding SheetStrings de personagem
As cadeias de caracteres são formadas pela combinação de caracteres individuais. Uma sequência de caracteres pode ser um
- Comment,
- Literal, ou
- Palavra COBOL.
Todas as cadeias de caracteres devem terminar com separators. Um separador é usado para separar cadeias de caracteres.
Separadores usados com frequência - Espaço, Vírgula, Ponto, Apóstrofo, Parêntese Esquerdo / Direito e Aspas.
Comente
Um comentário é uma cadeia de caracteres que não afeta a execução de um programa. Pode ser qualquer combinação de caracteres.
Existem dois tipos de comentários -
Linha de Comentário
Uma linha de comentário pode ser escrita em qualquer coluna. O compilador não verifica a sintaxe de uma linha de comentário e a trata para documentação.
Entrada de Comentário
As entradas de comentários são aquelas incluídas nos parágrafos opcionais de uma Divisão de Identificação. Eles são escritos na Área B e os programadores os usam como referência.
O texto destacado em Bold são as entradas comentadas no exemplo a seguir -
000100 IDENTIFICATION DIVISION. 000100
000150 PROGRAM-ID. HELLO. 000101
000200 AUTHOR. TUTORIALSPOINT. 000102
000250* THIS IS A COMMENT LINE 000103
000300 PROCEDURE DIVISION. 000104
000350 A000-FIRST-PARA. 000105
000360/ First Para Begins - Documentation Purpose 000106
000400 DISPLAY “Comment line”. 000107
000500 STOP RUN. 000108JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
Comment LineLiteral
Literal é uma constante codificada diretamente em um programa. No exemplo a seguir, "Hello World" é um literal.
PROCEDURE DIVISION.
DISPLAY 'Hello World'.Existem dois tipos de literais, conforme discutido abaixo -
Literal alfanumérico
Literais alfanuméricos são colocados entre aspas ou apóstrofos. O comprimento pode ter até 160 caracteres. Um apóstrofo ou uma citação pode fazer parte de um literal apenas se estiver emparelhado. O início e o fim do literal devem ser iguais, apóstrofo ou citação.
Example
O exemplo a seguir mostra literais alfanuméricos válidos e inválidos -
Valid:
‘This is valid’
"This is valid"
‘This isn’’t invalid’
Invalid:
‘This is invalid”
‘This isn’t valid’Literal Numérico
Um literal numérico é uma combinação de dígitos de 0 a 9, +, - ou ponto decimal. O comprimento pode ter até 18 caracteres. O sinal não pode ser o personagem mais à direita. O ponto decimal não deve aparecer no final.
Example
O exemplo a seguir mostra literais numéricos válidos e inválidos -
Valid:
100
+10.9
-1.9
Invalid:
1,00
10.
10.9-COBOL Word
COBOL Word é uma sequência de caracteres que pode ser uma palavra reservada ou uma palavra definida pelo usuário. O comprimento pode ter até 30 caracteres.
Usuário definido
Palavras definidas pelo usuário são usadas para nomear arquivos, dados, registros, nomes de parágrafos e seções. Alfabetos, dígitos e hifens são permitidos durante a formação de palavras definidas pelo usuário. Você não pode usar palavras reservadas COBOL.
Palavras reservadas
Palavras reservadas são palavras predefinidas em COBOL. Os diferentes tipos de palavras reservadas que usamos com frequência são as seguintes -
Keywords como ADICIONAR, ACEITAR, MOVER, etc.
Special characters palavras como +, -, *, <, <=, etc
Figurative constants são valores constantes como ZERO, ESPAÇOS, etc. Todos os valores constantes de constantes figurativas são mencionados na tabela a seguir.
Constantes Figurativas
| Sr. Não. | Constantes Figurativas e Descrição |
|---|---|
| 1 | HIGH-VALUES Um ou mais caracteres que estarão na posição mais alta em ordem decrescente. |
| 2 | LOW-VALUES Um ou mais caracteres têm zeros na representação binária. |
| 3 | ZERO/ZEROES Um ou mais zero dependendo do tamanho da variável. |
| 4 | SPACES Um ou mais espaços. |
| 5 | QUOTES Aspas simples ou duplas. |
| 6 | ALL literal Preenche o item de dados com Literal. |
A Divisão de Dados é usada para definir as variáveis usadas em um programa. Para descrever dados em COBOL, deve-se entender os seguintes termos -
- Nome de Dados
- Número do Nível
- Cláusula de imagem
- Cláusula de Valor
01 TOTAL-STUDENTS PIC9(5) VALUE '125'.
| | | |
| | | |
| | | |
Level Number Data Name Picture Clause Value ClauseNome de Dados
Os nomes dos dados devem ser definidos na Divisão de Dados antes de usá-los na Divisão de Procedimentos. Eles devem ter um nome definido pelo usuário; palavras reservadas não podem ser usadas. Os nomes dos dados referem-se aos locais da memória onde os dados reais são armazenados. Eles podem ser do tipo elementar ou de grupo.
Exemplo
O exemplo a seguir mostra nomes de dados válidos e inválidos -
Valid:
WS-NAME
TOTAL-STUDENTS
A100
100B
Invalid:
MOVE (Reserved Words)
COMPUTE (Reserved Words)
100 (No Alphabet)
100+B (+ is not allowed)Número do Nível
O número do nível é usado para especificar o nível de dados em um registro. Eles são usados para diferenciar entre itens elementares e itens de grupo. Os itens elementares podem ser agrupados para criar itens de grupo.
| Sr. Não. | Número e descrição do nível |
|---|---|
| 1 | 01 Entrada de descrição de registro |
| 2 | 02 to 49 Itens de grupo e elementares |
| 3 | 66 Renomear itens da cláusula |
| 4 | 77 Itens que não podem ser subdivididos |
| 5 | 88 Entrada de nome de condição |
Elementary itemsnão pode ser dividido mais. Número de nível, nome de dados, cláusula de imagem e cláusula de valor (opcional) são usados para descrever um item elementar.
Group itemsconsistem em um ou mais itens elementares. O número do nível, o nome dos dados e a cláusula Value (opcional) são usados para descrever um item do grupo. O número do nível do grupo é sempre 01.
Exemplo
O exemplo a seguir mostra itens de grupo e elementares -
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NAME PIC X(25). ---> ELEMENTARY ITEM
01 WS-CLASS PIC 9(2) VALUE '10'. ---> ELEMENTARY ITEM
01 WS-ADDRESS. ---> GROUP ITEM
05 WS-HOUSE-NUMBER PIC 9(3). ---> ELEMENTARY ITEM
05 WS-STREET PIC X(15). ---> ELEMENTARY ITEM
05 WS-CITY PIC X(15). ---> ELEMENTARY ITEM
05 WS-COUNTRY PIC X(15) VALUE 'INDIA'. ---> ELEMENTARY ITEMCláusula de imagem
A cláusula de imagem é usada para definir os seguintes itens -
Data typepode ser numérico, alfabético ou alfanumérico. O tipo numérico consiste apenas em dígitos de 0 a 9. O tipo alfabético consiste em letras de A a Z e espaços. O tipo alfanumérico consiste em dígitos, letras e caracteres especiais.
Signpode ser usado com dados numéricos. Pode ser + ou -.
Decimal point positionpode ser usado com dados numéricos. A posição assumida é a posição da casa decimal e não incluída nos dados.
Length define o número de bytes usados pelo item de dados.
Símbolos usados em uma cláusula de imagem -
| Sr. Não. | Símbolo e Descrição |
|---|---|
| 1 | 9 Numérico |
| 2 | A Alfabético |
| 3 | X Alfanumérico |
| 4 | V Decimal Implícito |
| 5 | S Placa |
| 6 | P Decimal presumido |
Exemplo
O exemplo a seguir mostra o uso da cláusula PIC -
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUM1 PIC S9(3)V9(2).
01 WS-NUM2 PIC PPP999.
01 WS-NUM3 PIC S9(3)V9(2) VALUE -123.45.
01 WS-NAME PIC A(6) VALUE 'ABCDEF'.
01 WS-ID PIC X(5) VALUE 'A121$'.
PROCEDURE DIVISION.
DISPLAY "WS-NUM1 : "WS-NUM1.
DISPLAY "WS-NUM2 : "WS-NUM2.
DISPLAY "WS-NUM3 : "WS-NUM3.
DISPLAY "WS-NAME : "WS-NAME.
DISPLAY "WS-ID : "WS-ID.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-NUM1 : +000.00
WS-NUM2 : .000000
WS-NUM3 : -123.45
WS-NAME : ABCDEF
WS-ID : A121$Cláusula de Valor
A cláusula Value é uma cláusula opcional que é usada para inicializar os itens de dados. Os valores podem ser literais numéricos, literais alfanuméricos ou constantes figurativas. Pode ser usado com itens de grupo e elementares.
Exemplo
O exemplo a seguir mostra o uso da cláusula VALUE -
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUM1 PIC 99V9 VALUE IS 3.5.
01 WS-NAME PIC A(6) VALUE 'ABCD'.
01 WS-ID PIC 99 VALUE ZERO.
PROCEDURE DIVISION.
DISPLAY "WS-NUM1 : "WS-NUM1.
DISPLAY "WS-NAME : "WS-NAME.
DISPLAY "WS-ID : "WS-ID.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-NUM1 : 03.5
WS-NAME : ABCD
WS-ID : 00Os verbos COBOL são usados na divisão do procedimento para processamento de dados. Uma instrução sempre começa com um verbo COBOL. Existem vários verbos COBOL com diferentes tipos de ações.
Verbos de entrada / saída
Os verbos de entrada / saída são usados para obter dados do usuário e exibir a saída de programas COBOL. Os dois verbos a seguir são usados para este processo -
Aceitar Verbo
Aceitar verbo é usado para obter dados como data, hora e dia do sistema operacional ou diretamente do usuário. Se um programa está aceitando dados do usuário, ele precisa ser transmitido por meio do JCL. Ao obter dados do sistema operacional, a opção FROM é incluída conforme mostrado no exemplo a seguir -
ACCEPT WS-STUDENT-NAME.
ACCEPT WS-DATE FROM SYSTEM-DATE.Exibir Verbo
Exibir verbo é usado para exibir a saída de um programa COBOL.
DISPLAY WS-STUDENT-NAME.
DISPLAY "System date is : " WS-DATE.COBOL PROGRAM
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-STUDENT-NAME PIC X(25).
01 WS-DATE PIC X(10).
PROCEDURE DIVISION.
ACCEPT WS-STUDENT-NAME.
ACCEPT WS-DATE FROM DATE.
DISPLAY "Name : " WS-STUDENT-NAME.
DISPLAY "Date : " WS-DATE.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//INPUT DD DSN=PROGRAM.DIRECTORY,DISP=SHR
//SYSIN DD *
TutorialsPoint
/*Quando você compila e executa o programa acima, ele produz o seguinte resultado -
Name : TutorialsPoint
Date : 200623Inicializar Verbo
Inicializar verbo é usado para inicializar um item de grupo ou um item elementar. Nomes de dados com cláusula RENAME não podem ser inicializados. Os itens de dados numéricos são substituídos por ZEROES. Itens de dados alfanuméricos ou alfabéticos são substituídos por ESPAÇOS. Se incluirmos o termo REPLACING, os itens de dados podem ser inicializados com o valor de substituição fornecido, conforme mostrado no exemplo a seguir -
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NAME PIC A(30) VALUE 'ABCDEF'.
01 WS-ID PIC 9(5).
01 WS-ADDRESS.
05 WS-HOUSE-NUMBER PIC 9(3).
05 WS-COUNTRY PIC X(15).
05 WS-PINCODE PIC 9(6) VALUE 123456.
PROCEDURE DIVISION.
A000-FIRST-PARA.
INITIALIZE WS-NAME, WS-ADDRESS.
INITIALIZE WS-ID REPLACING NUMERIC DATA BY 12345.
DISPLAY "My name is : "WS-NAME.
DISPLAY "My ID is : "WS-ID.
DISPLAY "Address : "WS-ADDRESS.
DISPLAY "House Number : "WS-HOUSE-NUMBER.
DISPLAY "Country : "WS-COUNTRY.
DISPLAY "Pincode : "WS-PINCODE.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
My name is :
My ID is : 12345
Address : 000 000000
House Number : 000
Country :
Pincode : 000000Mover Verbo
Mover verbo é usado para copiar dados de dados de origem para dados de destino. Ele pode ser usado em itens de dados elementares e de grupo. Para itens de dados de grupo, MOVE CORRESPONDING / CORR é usado. Na opção de teste, o MOVE CORR não está funcionando; mas em um servidor mainframe, funcionará.
Para mover dados de uma string, MOVE (x: l) é usado onde x é a posição inicial e l é o comprimento. Os dados serão truncados se a cláusula PIC do item de dados de destino for menor que a cláusula PIC do item de dados de origem. Se a cláusula PIC do item de dados de destino for maior do que a cláusula PIC do item de dados de origem, ZEROS ou SPACES serão adicionados aos bytes extras. O exemplo a seguir deixa isso claro.
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUM1 PIC 9(9).
01 WS-NUM2 PIC 9(9).
01 WS-NUM3 PIC 9(5).
01 WS-NUM4 PIC 9(6).
01 WS-ADDRESS.
05 WS-HOUSE-NUMBER PIC 9(3).
05 WS-COUNTRY PIC X(5).
05 WS-PINCODE PIC 9(6).
01 WS-ADDRESS1.
05 WS-HOUSE-NUMBER1 PIC 9(3).
05 WS-COUNTRY1 PIC X(5).
05 WS-PINCODE1 PIC 9(6).
PROCEDURE DIVISION.
A000-FIRST-PARA.
MOVE 123456789 TO WS-NUM1.
MOVE WS-NUM1 TO WS-NUM2 WS-NUM3.
MOVE WS-NUM1(3:6) TO WS-NUM4.
MOVE 123 TO WS-HOUSE-NUMBER.
MOVE 'INDIA' TO WS-COUNTRY.
MOVE 112233 TO WS-PINCODE.
MOVE WS-ADDRESS TO WS-ADDRESS1.
DISPLAY "WS-NUM1 : " WS-NUM1
DISPLAY "WS-NUM2 : " WS-NUM2
DISPLAY "WS-NUM3 : " WS-NUM3
DISPLAY "WS-NUM4 : " WS-NUM4
DISPLAY "WS-ADDRESS : " WS-ADDRESS
DISPLAY "WS-ADDRESS1 : " WS-ADDRESS1
STOP RUN.JCL para executar o programa COBOL acima.
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-NUM1 : 123456789
WS-NUM2 : 123456789
WS-NUM3 : 56789
WS-NUM4 : 345678
WS-ADDRESS : 123INDIA112233
WS-ADDRESS1 : 123INDIA112233Movimentos legais
A tabela a seguir fornece informações sobre os movimentos legais -
| Alfabético | Alfanumérico | Numérico | |
|---|---|---|---|
| Alfabético | Possível | Possível | Não é possivel |
| Alfanumérico | Possível | Possível | Possível |
| Numérico | Não é possivel | Possível | Possível |
Adicionar Verbo
Adicionar verbo é usado para adicionar dois ou mais números e armazenar o resultado no operando de destino.
Sintaxe
A seguir está a sintaxe para adicionar dois ou mais números -
ADD A B TO C D
ADD A B C TO D GIVING E
ADD CORR WS-GROUP1 TO WS-GROUP2Na sintaxe-1, A, B, C são adicionados e o resultado é armazenado em C (C = A + B + C). A, B, D são adicionados e o resultado é armazenado em D (D = A + B + D).
Na sintaxe-2, A, B, C, D são adicionados e o resultado é armazenado em E (E = A + B + C + D).
Na sintaxe-3, itens de subgrupo dentro de WS-GROUP1 e WS-GROUP2 são incluídos e o resultado é armazenado em WS-GROUP2.
Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUM1 PIC 9(9) VALUE 10 .
01 WS-NUM2 PIC 9(9) VALUE 10.
01 WS-NUM3 PIC 9(9) VALUE 10.
01 WS-NUM4 PIC 9(9) VALUE 10.
01 WS-NUMA PIC 9(9) VALUE 10.
01 WS-NUMB PIC 9(9) VALUE 10.
01 WS-NUMC PIC 9(9) VALUE 10.
01 WS-NUMD PIC 9(9) VALUE 10.
01 WS-NUME PIC 9(9) VALUE 10.
PROCEDURE DIVISION.
ADD WS-NUM1 WS-NUM2 TO WS-NUM3 WS-NUM4.
ADD WS-NUMA WS-NUMB WS-NUMC TO WS-NUMD GIVING WS-NUME.
DISPLAY "WS-NUM1 : " WS-NUM1
DISPLAY "WS-NUM2 : " WS-NUM2
DISPLAY "WS-NUM3 : " WS-NUM3
DISPLAY "WS-NUM4 : " WS-NUM4
DISPLAY "WS-NUMA : " WS-NUMA
DISPLAY "WS-NUMB : " WS-NUMB
DISPLAY "WS-NUMC : " WS-NUMC
DISPLAY "WS-NUMD : " WS-NUMD
DISPLAY "WS-NUME : " WS-NUME
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-NUM1 : 000000010
WS-NUM2 : 000000010
WS-NUM3 : 000000030
WS-NUM4 : 000000030
WS-NUMA : 000000010
WS-NUMB : 000000010
WS-NUMC : 000000010
WS-NUMD : 000000010
WS-NUME : 000000040Subtrair Verbo
Subtrair verbo é usado para operações de subtração.
Sintaxe
A seguir está a sintaxe para operações de subtração -
SUBTRACT A B FROM C D
SUBTRACT A B C FROM D GIVING E
SUBTRACT CORR WS-GROUP1 TO WS-GROUP2Na sintaxe-1, A e B são adicionados e subtraídos de C. O resultado é armazenado em C (C = C- (A + B)). A e B são adicionados e subtraídos de D. O resultado é armazenado em D (D = D- (A + B)).
Na sintaxe-2, A, B, C são adicionados e subtraídos de D. O resultado é armazenado em E (E = D- (A + B + C))
Na sintaxe-3, os itens do subgrupo em WS-GROUP1 e WS-GROUP2 são subtraídos e o resultado é armazenado em WS-GROUP2.
Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUM1 PIC 9(9) VALUE 10 .
01 WS-NUM2 PIC 9(9) VALUE 10.
01 WS-NUM3 PIC 9(9) VALUE 100.
01 WS-NUM4 PIC 9(9) VALUE 100.
01 WS-NUMA PIC 9(9) VALUE 10.
01 WS-NUMB PIC 9(9) VALUE 10.
01 WS-NUMC PIC 9(9) VALUE 10.
01 WS-NUMD PIC 9(9) VALUE 100.
01 WS-NUME PIC 9(9) VALUE 10.
PROCEDURE DIVISION.
SUBTRACT WS-NUM1 WS-NUM2 FROM WS-NUM3 WS-NUM4.
SUBTRACT WS-NUMA WS-NUMB WS-NUMC FROM WS-NUMD GIVING WS-NUME.
DISPLAY "WS-NUM1 : " WS-NUM1
DISPLAY "WS-NUM2 : " WS-NUM2
DISPLAY "WS-NUM3 : " WS-NUM3
DISPLAY "WS-NUM4 : " WS-NUM4
DISPLAY "WS-NUMA : " WS-NUMA
DISPLAY "WS-NUMB : " WS-NUMB
DISPLAY "WS-NUMC : " WS-NUMC
DISPLAY "WS-NUMD : " WS-NUMD
DISPLAY "WS-NUME : " WS-NUME
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-NUM1 : 000000010
WS-NUM2 : 000000010
WS-NUM3 : 000000080
WS-NUM4 : 000000080
WS-NUMA : 000000010
WS-NUMB : 000000010
WS-NUMC : 000000010
WS-NUMD : 000000100
WS-NUME : 000000070Multiplicar Verbo
Multiplicar verbo é usado para operações de multiplicação.
Sintaxe
A seguir está a sintaxe para multiplicar dois ou mais números -
MULTIPLY A BY B C
MULTIPLY A BY B GIVING ENa sintaxe-1, A e B são multiplicados e o resultado é armazenado em B (B = A * B). A e C são multiplicados e o resultado é armazenado em C (C = A * C).
Na sintaxe-2, A e B são multiplicados e o resultado é armazenado em E (E = A * B).
Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUM1 PIC 9(9) VALUE 10 .
01 WS-NUM2 PIC 9(9) VALUE 10.
01 WS-NUM3 PIC 9(9) VALUE 10.
01 WS-NUMA PIC 9(9) VALUE 10.
01 WS-NUMB PIC 9(9) VALUE 10.
01 WS-NUMC PIC 9(9) VALUE 10.
PROCEDURE DIVISION.
MULTIPLY WS-NUM1 BY WS-NUM2 WS-NUM3.
MULTIPLY WS-NUMA BY WS-NUMB GIVING WS-NUMC.
DISPLAY "WS-NUM1 : " WS-NUM1
DISPLAY "WS-NUM2 : " WS-NUM2
DISPLAY "WS-NUM3 : " WS-NUM3
DISPLAY "WS-NUMA : " WS-NUMA
DISPLAY "WS-NUMB : " WS-NUMB
DISPLAY "WS-NUMC : " WS-NUMC
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-NUM1 : 000000010
WS-NUM2 : 000000100
WS-NUM3 : 000000100
WS-NUMA : 000000010
WS-NUMB : 000000010
WS-NUMC : 000000100Divide Verb
Divide verbo é usado para operações de divisão.
Sintaxe
A seguir está a sintaxe para operações de divisão -
DIVIDE A INTO B
DIVIDE A BY B GIVING C REMAINDER RNa sintaxe-1, B é dividido por A e o resultado é armazenado em B (B = B / A).
Na sintaxe-2, A é dividido por B e o resultado é armazenado em C (C = A / B) e o restante é armazenado em R.
Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUM1 PIC 9(9) VALUE 5.
01 WS-NUM2 PIC 9(9) VALUE 250.
01 WS-NUMA PIC 9(9) VALUE 100.
01 WS-NUMB PIC 9(9) VALUE 15.
01 WS-NUMC PIC 9(9).
01 WS-REM PIC 9(9).
PROCEDURE DIVISION.
DIVIDE WS-NUM1 INTO WS-NUM2.
DIVIDE WS-NUMA BY WS-NUMB GIVING WS-NUMC REMAINDER WS-REM.
DISPLAY "WS-NUM1 : " WS-NUM1
DISPLAY "WS-NUM2 : " WS-NUM2
DISPLAY "WS-NUMA : " WS-NUMA
DISPLAY "WS-NUMB : " WS-NUMB
DISPLAY "WS-NUMC : " WS-NUMC
DISPLAY "WS-REM : " WS-REM
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-NUM1 : 000000005
WS-NUM2 : 000000050
WS-NUMA : 000000100
WS-NUMB : 000000015
WS-NUMC : 000000006
WS-REM : 000000010Declaração de computação
A instrução de cálculo é usada para escrever expressões aritméticas em COBOL. Este é um substituto para Adicionar, Subtrair, Multiplicar e Dividir.
Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUM1 PIC 9(9) VALUE 10 .
01 WS-NUM2 PIC 9(9) VALUE 10.
01 WS-NUM3 PIC 9(9) VALUE 10.
01 WS-NUMA PIC 9(9) VALUE 50.
01 WS-NUMB PIC 9(9) VALUE 10.
01 WS-NUMC PIC 9(9).
PROCEDURE DIVISION.
COMPUTE WS-NUMC= (WS-NUM1 * WS-NUM2) - (WS-NUMA / WS-NUMB) + WS-NUM3.
DISPLAY "WS-NUM1 : " WS-NUM1
DISPLAY "WS-NUM2 : " WS-NUM2
DISPLAY "WS-NUM3 : " WS-NUM3
DISPLAY "WS-NUMA : " WS-NUMA
DISPLAY "WS-NUMB : " WS-NUMB
DISPLAY "WS-NUMC : " WS-NUMC
STOP RUN.JCL para executar o programa COBOL acima.
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-NUM1 : 000000010
WS-NUM2 : 000000010
WS-NUM3 : 000000010
WS-NUMA : 000000050
WS-NUMB : 000000010
WS-NUMC : 000000105Layout COBOL é a descrição de uso de cada campo e os valores presentes nele. A seguir estão as entradas de descrição de dados usadas em COBOL -
- Cláusula de redefinições
- Renomear cláusula
- Cláusula de Uso
- Copybooks
Cláusula de redefinições
A cláusula Redefines é usada para definir um armazenamento com diferentes descrições de dados. Se um ou mais itens de dados não forem usados simultaneamente, o mesmo armazenamento pode ser usado para outro item de dados. Portanto, o mesmo armazenamento pode ser referido com diferentes itens de dados.
Sintaxe
A seguir está a sintaxe para a cláusula Redefines -
01 WS-OLD PIC X(10).
01 WS-NEW1 REDEFINES WS-OLD PIC 9(8).
01 WS-NEW2 REDEFINES WS-OLD PIC A(10).A seguir estão os detalhes dos parâmetros usados -
- WS-OLD é um item redefinido
- WS-NEW1 e WS-NEW2 são itens de redefinição
Números de nível de item redefinido e item de redefinição devem ser iguais e não podem ser 66 ou 88 números de nível. Não use a cláusula VALUE com um item de redefinição. Na seção de arquivo, não use uma cláusula de redefinição com o número de 01 nível. A definição de redefinições deve ser a próxima descrição de dados que você deseja redefinir. Um item redefinido sempre terá o mesmo valor de um item redefinido.
Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-DESCRIPTION.
05 WS-DATE1 VALUE '20140831'.
10 WS-YEAR PIC X(4).
10 WS-MONTH PIC X(2).
10 WS-DATE PIC X(2).
05 WS-DATE2 REDEFINES WS-DATE1 PIC 9(8).
PROCEDURE DIVISION.
DISPLAY "WS-DATE1 : "WS-DATE1.
DISPLAY "WS-DATE2 : "WS-DATE2.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-DATE1 : 20140831
WS-DATE2 : 20140831Renomear cláusula
A cláusula Renames é usada para dar nomes diferentes aos itens de dados existentes. É usado para reagrupar os nomes dos dados e dar um novo nome a eles. Os novos nomes de dados podem ser renomeados em grupos ou itens elementares. O nível 66 é reservado para renomeações.
Syntax
A seguir está a sintaxe para a cláusula Renames -
01 WS-OLD.
10 WS-A PIC 9(12).
10 WS-B PIC X(20).
10 WS-C PIC A(25).
10 WS-D PIC X(12).
66 WS-NEW RENAMES WS-A THRU WS-C.Renomear só é possível no mesmo nível. No exemplo acima, WS-A, WS-B e WS-C estão no mesmo nível. A definição de renomeação deve ser a próxima descrição de dados que você deseja renomear. Não use Renomear com número de nível 01, 77 ou 66. Os nomes de dados usados para renomeações devem vir em seqüência. Itens de dados com cláusula ocorrer não podem ser renomeados.
Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-DESCRIPTION.
05 WS-NUM.
10 WS-NUM1 PIC 9(2) VALUE 20.
10 WS-NUM2 PIC 9(2) VALUE 56.
05 WS-CHAR.
10 WS-CHAR1 PIC X(2) VALUE 'AA'.
10 WS-CHAR2 PIC X(2) VALUE 'BB'.
66 WS-RENAME RENAMES WS-NUM2 THRU WS-CHAR2.
PROCEDURE DIVISION.
DISPLAY "WS-RENAME : " WS-RENAME.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-RENAME : 56AABBCláusula de Uso
A cláusula de uso especifica o sistema operacional no qual os dados de formato são armazenados. Não pode ser usado com os números de nível 66 ou 88. Se a cláusula de uso for especificada em um grupo, todos os itens elementares terão a mesma cláusula de uso. As diferentes opções disponíveis com a cláusula de uso são as seguintes -
Exibição
Os dados são armazenados no formato ASCII e cada caractere ocupará 1 byte. É o uso padrão.
O exemplo a seguir calcula o número de bytes necessários -
01 WS-NUM PIC S9(5)V9(3) USAGE IS DISPLAY.
It requires 8 bytes as sign and decimal doesn't require any byte.
01 WS-NUM PIC 9(5) USAGE IS DISPLAY.
It requires 5 bytes as sign.COMPUTACIONAL / COMP
O item de dados é armazenado em formato binário. Aqui, os itens de dados devem ser inteiros.
O exemplo a seguir calcula o número de bytes necessários -
01 WS-NUM PIC S9(n) USAGE IS COMP.
If 'n' = 1 to 4, it takes 2 bytes.
If 'n' = 5 to 9, it takes 4 bytes.
If 'n' = 10 to 18, it takes 8 bytes.COMP-1
O item de dados é semelhante a Real ou Float e é representado como um número de ponto flutuante de precisão única. Internamente, os dados são armazenados em formato hexadecimal. COMP-1 não aceita a cláusula PIC. Aqui, 1 palavra é igual a 4 bytes.
COMP-2
O item de dados é semelhante a Long ou Double e é representado como um número de ponto flutuante de precisão dupla. Internamente, os dados são armazenados em formato hexadecimal. COMP-2 não especifica a cláusula PIC. Aqui, 2 palavras são iguais a 8 bytes.
COMP-3
O item de dados é armazenado no formato decimal compactado. Cada dígito ocupa meio byte (1 nibble) e o sinal é armazenado no nibble mais à direita.
O exemplo a seguir calcula o número de bytes necessários -
01 WS-NUM PIC 9(n) USAGE IS COMP.
Number of bytes = n/2 (If n is even)
Number of bytes = n/2 + 1(If n is odd, consider only integer part)
01 WS-NUM PIC 9(4) USAGE IS COMP-3 VALUE 21.
It requires 2 bytes of storage as each digit occupies half a byte.
01 WS-NUM PIC 9(5) USAGE IS COMP-3 VALUE 21.
It requires 3 bytes of storage as each digit occupies half a byte.Cadernos
Um copybook COBOL é uma seleção de código que define estruturas de dados. Se uma determinada estrutura de dados for usada em muitos programas, em vez de escrever a mesma estrutura de dados novamente, podemos usar copybooks. Usamos a instrução COPY para incluir um copybook em um programa. A instrução COPY é usada na Seção WorkingStorage.
O exemplo a seguir inclui um copybook dentro de um programa COBOL -
DATA DIVISION.
WORKING-STORAGE SECTION.
COPY ABC.Aqui, ABC é o nome do caderno. Os seguintes itens de dados no copybook ABC podem ser usados dentro de um programa.
01 WS-DESCRIPTION.
05 WS-NUM.
10 WS-NUM1 PIC 9(2) VALUE 20.
10 WS-NUM2 PIC 9(2) VALUE 56.
05 WS-CHAR.
10 WS-CHAR1 PIC X(2) VALUE 'AA'.
10 WS-CHAR2 PIC X(2) VALUE 'BB'.As instruções condicionais são usadas para alterar o fluxo de execução dependendo de certas condições especificadas pelo programador. As declarações condicionais sempre serão avaliadas como verdadeiras ou falsas. As condições são usadas em declarações IF, Evaluate e Perform. Os diferentes tipos de condições são os seguintes -
- Declaração de condição IF
- Condição de Relação
- Condição de Sinal
- Condição de Classe
- Condição-Nome Condição
- Condição negada
- Condição Combinada
Declaração de condição IF
A instrução IF verifica as condições. Se uma condição for verdadeira, o bloco IF é executado; e se a condição for falsa, o bloco ELSE é executado.
END-IFé usado para encerrar o bloco IF. Para encerrar o bloco IF, um ponto final pode ser usado em vez de END-IF. Mas é sempre preferível usar END-IF para vários blocos IF.
Nested-IF- Blocos IF aparecendo dentro de outro bloco IF. Não há limite para a profundidade das instruções IF aninhadas.
Sintaxe
A seguir está a sintaxe das declarações de condição IF -
IF [condition] THEN
[COBOL statements]
ELSE
[COBOL statements]
END-IF.Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUM1 PIC 9(9).
01 WS-NUM2 PIC 9(9).
01 WS-NUM3 PIC 9(5).
01 WS-NUM4 PIC 9(6).
PROCEDURE DIVISION.
A000-FIRST-PARA.
MOVE 25 TO WS-NUM1 WS-NUM3.
MOVE 15 TO WS-NUM2 WS-NUM4.
IF WS-NUM1 > WS-NUM2 THEN
DISPLAY 'IN LOOP 1 - IF BLOCK'
IF WS-NUM3 = WS-NUM4 THEN
DISPLAY 'IN LOOP 2 - IF BLOCK'
ELSE
DISPLAY 'IN LOOP 2 - ELSE BLOCK'
END-IF
ELSE
DISPLAY 'IN LOOP 1 - ELSE BLOCK'
END-IF.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
IN LOOP 1 - IF BLOCK
IN LOOP 2 - ELSE BLOCKCondição de Relação
A condição de relação compara dois operandos, qualquer um dos quais pode ser um identificador, literal ou expressão aritmética. A comparação algébrica de campos numéricos é feita independentemente do tamanho e da cláusula de uso.
For non-numeric operands
Se dois operandos não numéricos de tamanho igual forem comparados, os caracteres serão comparados da esquerda com as posições correspondentes até que o final seja alcançado. O operando que contém o maior número de caracteres é declarado maior.
Se dois operandos não numéricos de tamanho desigual são comparados, então o item de dados mais curto é anexado com espaços no final até que o tamanho dos operandos se torne igual e então comparado de acordo com as regras mencionadas no ponto anterior.
Sintaxe
A seguir está a sintaxe das declarações de condição de relação -
[Data Name/Arithmetic Operation]
[IS] [NOT]
[Equal to (=),Greater than (>), Less than (<),
Greater than or Equal (>=), Less than or equal (<=) ]
[Data Name/Arithmetic Operation]Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUM1 PIC 9(9).
01 WS-NUM2 PIC 9(9).
PROCEDURE DIVISION.
A000-FIRST-PARA.
MOVE 25 TO WS-NUM1.
MOVE 15 TO WS-NUM2.
IF WS-NUM1 IS GREATER THAN OR EQUAL TO WS-NUM2 THEN
DISPLAY 'WS-NUM1 IS GREATER THAN WS-NUM2'
ELSE
DISPLAY 'WS-NUM1 IS LESS THAN WS-NUM2'
END-IF.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-NUM1 IS GREATER THAN WS-NUM2Condição de Sinal
A condição de sinal é usada para verificar o sinal de um operando numérico. Ele determina se um determinado valor numérico é maior, menor ou igual a ZERO.
Sintaxe
A seguir está a sintaxe das declarações de condição de sinal -
[Data Name/Arithmetic Operation]
[IS] [NOT]
[Positive, Negative or Zero]
[Data Name/Arithmetic Operation]Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUM1 PIC S9(9) VALUE -1234.
01 WS-NUM2 PIC S9(9) VALUE 123456.
PROCEDURE DIVISION.
A000-FIRST-PARA.
IF WS-NUM1 IS POSITIVE THEN
DISPLAY 'WS-NUM1 IS POSITIVE'.
IF WS-NUM1 IS NEGATIVE THEN
DISPLAY 'WS-NUM1 IS NEGATIVE'.
IF WS-NUM1 IS ZERO THEN
DISPLAY 'WS-NUM1 IS ZERO'.
IF WS-NUM2 IS POSITIVE THEN
DISPLAY 'WS-NUM2 IS POSITIVE'.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-NUM1 IS NEGATIVE
WS-NUM2 IS POSITIVECondição de Classe
A condição de classe é usada para verificar se um operando contém apenas alfabetos ou dados numéricos. Os espaços são considerados ALFABÉTICO, ALFABÉTICO INFERIOR e ALFABÉTICO SUPERIOR.
Sintaxe
A seguir está a sintaxe das declarações de condição de classe -
[Data Name/Arithmetic Operation>]
[IS] [NOT]
[NUMERIC, ALPHABETIC, ALPHABETIC-LOWER, ALPHABETIC-UPPER]
[Data Name/Arithmetic Operation]Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUM1 PIC X(9) VALUE 'ABCD '.
01 WS-NUM2 PIC 9(9) VALUE 123456789.
PROCEDURE DIVISION.
A000-FIRST-PARA.
IF WS-NUM1 IS ALPHABETIC THEN
DISPLAY 'WS-NUM1 IS ALPHABETIC'.
IF WS-NUM1 IS NUMERIC THEN
DISPLAY 'WS-NUM1 IS NUMERIC'.
IF WS-NUM2 IS NUMERIC THEN
DISPLAY 'WS-NUM2 IS NUMERIC'.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-NUM1 IS ALPHABETIC
WS-NUM2 IS NUMERICCondição-nome Condição
Um nome de condição é um nome definido pelo usuário. Ele contém um conjunto de valores especificados pelo usuário. Ele se comporta como variáveis booleanas. Eles são definidos com o nível de número 88. Não terá uma cláusula PIC.
Sintaxe
A seguir está a sintaxe das declarações de condição definidas pelo usuário -
88 [Condition-Name] VALUE [IS, ARE] [LITERAL] [THRU LITERAL].Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUM PIC 9(3).
88 PASS VALUES ARE 041 THRU 100.
88 FAIL VALUES ARE 000 THRU 40.
PROCEDURE DIVISION.
A000-FIRST-PARA.
MOVE 65 TO WS-NUM.
IF PASS
DISPLAY 'Passed with ' WS-NUM ' marks'.
IF FAIL
DISPLAY 'FAILED with ' WS-NUM 'marks'.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
Passed with 065 marksCondição negada
A condição negada é dada usando a palavra-chave NOT. Se uma condição for verdadeira e NÃO tivermos fornecido antes dela, seu valor final será falso.
Sintaxe
A seguir está a sintaxe das declarações de condição negadas -
IF NOT [CONDITION]
COBOL Statements
END-IF.Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUM1 PIC 9(2) VALUE 20.
01 WS-NUM2 PIC 9(9) VALUE 25.
PROCEDURE DIVISION.
A000-FIRST-PARA.
IF NOT WS-NUM1 IS LESS THAN WS-NUM2 THEN
DISPLAY 'IF-BLOCK'
ELSE
DISPLAY 'ELSE-BLOCK'
END-IF.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
ELSE-BLOCKCondição Combinada
Uma condição combinada contém duas ou mais condições conectadas usando operadores lógicos AND ou OR.
Sintaxe
A seguir está a sintaxe das declarações de condição combinadas -
IF [CONDITION] AND [CONDITION]
COBOL Statements
END-IF.Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-NUM1 PIC 9(2) VALUE 20.
01 WS-NUM2 PIC 9(2) VALUE 25.
01 WS-NUM3 PIC 9(2) VALUE 20.
PROCEDURE DIVISION.
A000-FIRST-PARA.
IF WS-NUM1 IS LESS THAN WS-NUM2 AND WS-NUM1=WS-NUM3 THEN
DISPLAY 'Both condition OK'
ELSE
DISPLAY 'Error'
END-IF.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
Both condition OKAvaliar Verbo
Avaliar verbo é uma substituição de uma série de instruções IF-ELSE. Ele pode ser usado para avaliar mais de uma condição. É semelhante à instrução SWITCH em programas C.
Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-A PIC 9 VALUE 0.
PROCEDURE DIVISION.
MOVE 3 TO WS-A.
EVALUATE TRUE
WHEN WS-A > 2
DISPLAY 'WS-A GREATER THAN 2'
WHEN WS-A < 0
DISPLAY 'WS-A LESS THAN 0'
WHEN OTHER
DISPLAY 'INVALID VALUE OF WS-A'
END-EVALUATE.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-A GREATER THAN 2Existem algumas tarefas que precisam ser realizadas repetidamente, como ler cada registro de um arquivo até o seu fim. As instruções de loop usadas em COBOL são -
- Perform Thru
- Executar até
- Perform Times
- Desempenho variável
Perform Thru
Perform Thru é usado para executar uma série de parágrafos, dando o nome do primeiro e do último parágrafo na seqüência. Depois de executar o último parágrafo, o controle é retornado.
Desempenho em linha
As instruções dentro do PERFORM serão executadas até que END-PERFORM seja alcançado.
Sintaxe
A seguir está a sintaxe do desempenho in-line -
PERFORM
DISPLAY 'HELLO WORLD'
END-PERFORM.Desempenho fora da linha
Aqui, uma instrução é executada em um parágrafo e, em seguida, o controle é transferido para outro parágrafo ou seção.
Sintaxe
A seguir está a sintaxe de execução fora de linha -
PERFORM PARAGRAPH1 THRU PARAGRAPH2Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
PROCEDURE DIVISION.
A-PARA.
PERFORM DISPLAY 'IN A-PARA'
END-PERFORM.
PERFORM C-PARA THRU E-PARA.
B-PARA.
DISPLAY 'IN B-PARA'.
STOP RUN.
C-PARA.
DISPLAY 'IN C-PARA'.
D-PARA.
DISPLAY 'IN D-PARA'.
E-PARA.
DISPLAY 'IN E-PARA'.JCL para executar o programa COBOL acima.
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
IN A-PARA
IN C-PARA
IN D-PARA
IN E-PARA
IN B-PARAExecutar até
Em 'executar até', um parágrafo é executado até que a condição dada se torne verdadeira. 'Com teste antes' é a condição padrão e indica que a condição é verificada antes da execução das instruções em um parágrafo.
Sintaxe
A seguir está a sintaxe de executar até -
PERFORM A-PARA UNTIL COUNT=5
PERFORM A-PARA WITH TEST BEFORE UNTIL COUNT=5
PERFORM A-PARA WITH TEST AFTER UNTIL COUNT=5Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-CNT PIC 9(1) VALUE 0.
PROCEDURE DIVISION.
A-PARA.
PERFORM B-PARA WITH TEST AFTER UNTIL WS-CNT>3.
STOP RUN.
B-PARA.
DISPLAY 'WS-CNT : 'WS-CNT.
ADD 1 TO WS-CNT.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-CNT : 0
WS-CNT : 1
WS-CNT : 2
WS-CNT : 3Perform Times
Em 'tempos de execução', um parágrafo será executado o número de vezes especificado.
Sintaxe
A seguir está a sintaxe dos tempos de execução -
PERFORM A-PARA 5 TIMES.Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
PROCEDURE DIVISION.
A-PARA.
PERFORM B-PARA 3 TIMES.
STOP RUN.
B-PARA.
DISPLAY 'IN B-PARA'.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
IN B-PARA
IN B-PARA
IN B-PARADesempenho variável
Ao executar a variação, um parágrafo será executado até que a condição na frase Até se torne verdadeira.
Sintaxe
A seguir está a sintaxe de performance variando -
PERFORM A-PARA VARYING A FROM 1 BY 1 UNTIL A = 5.Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-A PIC 9 VALUE 0.
PROCEDURE DIVISION.
A-PARA.
PERFORM B-PARA VARYING WS-A FROM 1 BY 1 UNTIL WS-A=5
STOP RUN.
B-PARA.
DISPLAY 'IN B-PARA ' WS-A.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
IN B-PARA 1
IN B-PARA 2
IN B-PARA 3
IN B-PARA 4Declaração IR PARA
A instrução GO TO é usada para alterar o fluxo de execução em um programa. Nas instruções GO TO, a transferência ocorre apenas na direção para frente. É usado para sair de um parágrafo. Os diferentes tipos de instruções GO TO usados são os seguintes -
INcondicional IR PARA
GO TO para-name.Condicional IR PARA
GO TO para-1 para-2 para-3 DEPENDING ON x.Se 'x' for igual a 1, o controle será transferido para o primeiro parágrafo; e se 'x' for igual a 2, o controle será transferido para o segundo parágrafo e assim por diante.
Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-A PIC 9 VALUE 2.
PROCEDURE DIVISION.
A-PARA.
DISPLAY 'IN A-PARA'
GO TO B-PARA.
B-PARA.
DISPLAY 'IN B-PARA '.
GO TO C-PARA D-PARA DEPENDING ON WS-A.
C-PARA.
DISPLAY 'IN C-PARA '.
D-PARA.
DISPLAY 'IN D-PARA '.
STOP RUN.JCL para executar o programa COBOL acima:
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado:
IN A-PARA
IN B-PARA
IN D-PARAAs instruções de manipulação de strings em COBOL são usadas para realizar várias operações funcionais em strings. A seguir estão as instruções de manipulação de string -
- Inspect
- String
- Unstring
Inspecionar
O verbo inspecionar é usado para contar ou substituir os caracteres em uma string. As operações de string podem ser realizadas em valores alfanuméricos, numéricos ou alfabéticos. As operações de inspeção são realizadas da esquerda para a direita. As opções usadas para as operações de string são as seguintes -
Tallying
A opção de contagem é usada para contar os caracteres da string.
Syntax
A seguir está a sintaxe da opção Tallying -
INSPECT input-string
TALLYING output-count FOR ALL CHARACTERSOs parâmetros usados são -
- string de entrada - a string cujos caracteres devem ser contados.
- output-count - Item de dados para conter a contagem de caracteres.
Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-CNT1 PIC 9(2) VALUE 0.
01 WS-CNT2 PIC 9(2) VALUE 0.
01 WS-STRING PIC X(15) VALUE 'ABCDACDADEAAAFF'.
PROCEDURE DIVISION.
INSPECT WS-STRING TALLYING WS-CNT1 FOR CHARACTER.
DISPLAY "WS-CNT1 : "WS-CNT1.
INSPECT WS-STRING TALLYING WS-CNT2 FOR ALL 'A'.
DISPLAY "WS-CNT2 : "WS-CNT2
STOP RUN.JCL para executar o programa COBOL acima.
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-CNT1 : 15
WS-CNT2 : 06Substituindo
A opção de substituição é usada para substituir os caracteres da string.
Syntax
A seguir está a sintaxe da opção Substituir -
INSPECT input-string REPLACING ALL char1 BY char2.O parâmetro usado é -
input-string - A string cujos caracteres devem ser substituídos de char1 para char2.
Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-STRING PIC X(15) VALUE 'ABCDACDADEAAAFF'.
PROCEDURE DIVISION.
DISPLAY "OLD STRING : "WS-STRING.
INSPECT WS-STRING REPLACING ALL 'A' BY 'X'.
DISPLAY "NEW STRING : "WS-STRING.
STOP RUN.JCL para executar o programa COBOL acima.
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
OLD STRING : ABCDACDADEAAAFF
NEW STRING : XBCDXCDXDEXXXFFCorda
O verbo da string é usado para concatenar as strings. Usando a instrução STRING, duas ou mais cadeias de caracteres podem ser combinadas para formar uma cadeia mais longa. A cláusula 'Delimitado por' é obrigatória.
Syntax
A seguir está a sintaxe do verbo String -
STRING ws-string1 DELIMITED BY SPACE
ws-string2 DELIMITED BY SIZE
INTO ws-destination-string
WITH POINTER ws-count
ON OVERFLOW DISPLAY message1
NOT ON OVERFLOW DISPLAY message2
END-STRING.A seguir estão os detalhes dos parâmetros usados -
- ws-string1 e ws-string2: strings de entrada a serem concatenadas
- ws-string: string de saída
- ws-count: usado para contar o comprimento da nova string concatenada
- Delimitado especifica o fim da string
- Ponteiro e estouro são opcionais
Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-STRING PIC A(30).
01 WS-STR1 PIC A(15) VALUE 'Tutorialspoint'.
01 WS-STR2 PIC A(7) VALUE 'Welcome'.
01 WS-STR3 PIC A(7) VALUE 'To AND'.
01 WS-COUNT PIC 99 VALUE 1.
PROCEDURE DIVISION.
STRING WS-STR2 DELIMITED BY SIZE
WS-STR3 DELIMITED BY SPACE
WS-STR1 DELIMITED BY SIZE
INTO WS-STRING
WITH POINTER WS-COUNT
ON OVERFLOW DISPLAY 'OVERFLOW!'
END-STRING.
DISPLAY 'WS-STRING : 'WS-STRING.
DISPLAY 'WS-COUNT : 'WS-COUNT.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-STRING : WelcomeToTutorialspoint
WS-COUNT : 25Desencordoar
O verbo unstring é usado para dividir uma string em várias sub-strings. Delimitado por cláusula é obrigatório.
Syntax
A seguir está a sintaxe do verbo Unstring -
UNSTRING ws-string DELIMITED BY SPACE
INTO ws-str1, ws-str2
WITH POINTER ws-count
ON OVERFLOW DISPLAY message
NOT ON OVERFLOW DISPLAY message
END-UNSTRING.Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-STRING PIC A(30) VALUE 'WELCOME TO TUTORIALSPOINT'.
01 WS-STR1 PIC A(7).
01 WS-STR2 PIC A(2).
01 WS-STR3 PIC A(15).
01 WS-COUNT PIC 99 VALUE 1.
PROCEDURE DIVISION.
UNSTRING WS-STRING DELIMITED BY SPACE
INTO WS-STR1, WS-STR2, WS-STR3
END-UNSTRING.
DISPLAY 'WS-STR1 : 'WS-STR1.
DISPLAY 'WS-STR2 : 'WS-STR2.
DISPLAY 'WS-STR3 : 'WS-STR3.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-STR1 : WELCOME
WS-STR2 : TO
WS-STR3 : TUTORIALSPOINTOs arrays em COBOL são conhecidos como tabelas. Uma matriz é uma estrutura de dados linear e é uma coleção de itens de dados individuais do mesmo tipo. Os itens de dados de uma tabela são classificados internamente.
Declaração de mesa
A tabela é declarada na Divisão de Dados. Occurscláusula é usada para definir uma tabela. A cláusula Occurs indica a repetição da definição do nome dos dados. Ele pode ser usado apenas com números de nível começando de 02 a 49. Não use a cláusula ocorre com Redefines. A descrição da tabela unidimensional e bidimensional é a seguinte -
Tabela unidimensional
Em uma tabela unidimensional, occurscláusula é usada apenas uma vez na declaração. WSTABLE é o item do grupo que contém a tabela. WS-B nomeia os elementos da tabela que ocorrem 10 vezes.
Syntax
A seguir está a sintaxe para definir uma tabela unidimensional -
01 WS-TABLE.
05 WS-A PIC A(10) OCCURS 10 TIMES.Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TABLE.
05 WS-A PIC A(10) VALUE 'TUTORIALS' OCCURS 5 TIMES.
PROCEDURE DIVISION.
DISPLAY "ONE-D TABLE : "WS-TABLE.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
ONE-D TABLE : TUTORIALS TUTORIALS TUTORIALS TUTORIALS TUTORIALSTabela bidimensional
Uma tabela bidimensional é criada com ambos os elementos de dados sendo de comprimento variável. Para referência, leia a sintaxe e tente analisar a tabela. A primeira matriz (WS-A) pode ocorrer de 1 a 10 vezes e a matriz interna (WS-C) pode ocorrer de 1 a 5 vezes. Para cada entrada do WS-A, haverá 5 entradas correspondentes do WS-C.
Syntax
A seguir está a sintaxe para definir uma tabela bidimensional -
01 WS-TABLE.
05 WS-A OCCURS 10 TIMES.
10 WS-B PIC A(10).
10 WS-C OCCURS 5 TIMES.
15 WS-D PIC X(6).Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TABLE.
05 WS-A OCCURS 2 TIMES.
10 WS-B PIC A(10) VALUE ' TUTORIALS'.
10 WS-C OCCURS 2 TIMES.
15 WS-D PIC X(6) VALUE ' POINT'.
PROCEDURE DIVISION.
DISPLAY "TWO-D TABLE : "WS-TABLE.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
TWO-D TABLE : TUTORIALS POINT POINT TUTORIALS POINT POINTSubscrito
Os elementos individuais da tabela podem ser acessados usando subscrito. Os valores subscritos podem variar de 1 ao número de vezes que a tabela ocorre. Um subscrito pode ser qualquer número positivo. Não requer nenhuma declaração na divisão de dados. Ele é criado automaticamente com a cláusula ocorre.
Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TABLE.
05 WS-A OCCURS 3 TIMES.
10 WS-B PIC A(2).
10 WS-C OCCURS 2 TIMES.
15 WS-D PIC X(3).
PROCEDURE DIVISION.
MOVE '12ABCDEF34GHIJKL56MNOPQR' TO WS-TABLE.
DISPLAY 'WS-TABLE : ' WS-TABLE.
DISPLAY 'WS-A(1) : ' WS-A(1).
DISPLAY 'WS-C(1,1) : ' WS-C(1,1).
DISPLAY 'WS-C(1,2) : ' WS-C(1,2).
DISPLAY 'WS-A(2) : ' WS-A(2).
DISPLAY 'WS-C(2,1) : ' WS-C(2,1).
DISPLAY 'WS-C(2,2) : ' WS-C(2,2).
DISPLAY 'WS-A(3) : ' WS-A(3).
DISPLAY 'WS-C(3,1) : ' WS-C(3,1).
DISPLAY 'WS-C(3,2) : ' WS-C(3,2).
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
WS-TABLE : 12ABCDEF34GHIJKL56MNOPQR
WS-A(1) : 12ABCDEF
WS-C(1,1) : ABC
WS-C(1,2) : DEF
WS-A(2) : 34GHIJKL
WS-C(2,1) : GHI
WS-C(2,2) : JKL
WS-A(3) : 56MNOPQR
WS-C(3,1) : MNO
WS-C(3,2) : PQRÍndice
Os elementos da tabela também podem ser acessados usando o índice. Um índice é um deslocamento de elemento do início da tabela. Um índice é declarado com a cláusula Occurs usando a cláusula INDEXED BY. O valor do índice pode ser alterado usando a instrução SET e a opção PERFORM Varying.
Syntax
A seguir está a sintaxe para definir o índice em uma tabela -
01 WS-TABLE.
05 WS-A PIC A(10) OCCURS 10 TIMES INDEXED BY I.Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TABLE.
05 WS-A OCCURS 3 TIMES INDEXED BY I.
10 WS-B PIC A(2).
10 WS-C OCCURS 2 TIMES INDEXED BY J.
15 WS-D PIC X(3).
PROCEDURE DIVISION.
MOVE '12ABCDEF34GHIJKL56MNOPQR' TO WS-TABLE.
PERFORM A-PARA VARYING I FROM 1 BY 1 UNTIL I >3
STOP RUN.
A-PARA.
PERFORM C-PARA VARYING J FROM 1 BY 1 UNTIL J>2.
C-PARA.
DISPLAY WS-C(I,J).JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
ABC
DEF
GHI
JKL
MNO
PQRDefinir declaração
A instrução Set é usada para alterar o valor do índice. Definir verbo é usado para inicializar, incrementar ou decrementar o valor do índice. É usado com Pesquisar e Pesquisar tudo para localizar elementos na tabela.
Syntax
A seguir está a sintaxe para usar uma instrução Set -
SET I J TO positive-number
SET I TO J
SET I TO 5
SET I J UP BY 1
SET J DOWN BY 5Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TABLE.
05 WS-A OCCURS 3 TIMES INDEXED BY I.
10 WS-B PIC A(2).
10 WS-C OCCURS 2 TIMES INDEXED BY J.
15 WS-D PIC X(3).
PROCEDURE DIVISION.
MOVE '12ABCDEF34GHIJKL56MNOPQR' TO WS-TABLE.
SET I J TO 1.
DISPLAY WS-C(I,J).
SET I J UP BY 1.
DISPLAY WS-C(I,J).
STOP RUN.JCL para executar o programa COBOL acima.
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
ABC
JKLPesquisa
A pesquisa é um método de pesquisa linear, usado para localizar elementos dentro da tabela. Pode ser executado em tabelas ordenadas ou não ordenadas. É usado apenas para tabelas declaradas por frase de índice. Ele começa com o valor inicial do índice. Se o elemento procurado não for encontrado, o índice é automaticamente incrementado em 1 e continua até o final da tabela.
Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TABLE.
05 WS-A PIC X(1) OCCURS 18 TIMES INDEXED BY I.
01 WS-SRCH PIC A(1) VALUE 'M'.
PROCEDURE DIVISION.
MOVE 'ABCDEFGHIJKLMNOPQR' TO WS-TABLE.
SET I TO 1.
SEARCH WS-A
AT END DISPLAY 'M NOT FOUND IN TABLE'
WHEN WS-A(I) = WS-SRCH
DISPLAY 'LETTER M FOUND IN TABLE'
END-SEARCH.
STOP RUN.JCL para executar o programa COBOL acima.
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
LETTER M FOUND IN TABLEPesquisar tudo
Pesquisar tudo é um método de pesquisa binária, usado para localizar elementos dentro da tabela. A tabela deve estar em ordem de classificação para a opção Pesquisar tudo. O índice não requer inicialização. Na busca binária, a tabela é dividida em duas metades e determina em qual metade o elemento procurado está presente. Este processo se repete até que o elemento seja encontrado ou o fim seja alcançado.
Example
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-TABLE.
05 WS-RECORD OCCURS 10 TIMES ASCENDING KEY IS WS-NUM INDEXED BY I.
10 WS-NUM PIC 9(2).
10 WS-NAME PIC A(3).
PROCEDURE DIVISION.
MOVE '12ABC56DEF34GHI78JKL93MNO11PQR' TO WS-TABLE.
SEARCH ALL WS-RECORD
AT END DISPLAY 'RECORD NOT FOUND'
WHEN WS-NUM(I) = 93
DISPLAY 'RECORD FOUND '
DISPLAY WS-NUM(I)
DISPLAY WS-NAME(I)
END-SEARCH.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLOQuando você compila e executa o programa acima, ele produz o seguinte resultado -
RECORD FOUND
93
MNOO conceito de arquivos em COBOL é diferente daquele em C / C ++. Ao aprender o básico de 'Arquivo' em COBOL, os conceitos de ambas as linguagens não devem ser correlacionados. Arquivos de texto simples não podem ser usados em COBOL, em vez dissoPS (Physical Sequential) e VSAMarquivos são usados. Os arquivos PS serão discutidos neste módulo.
Para entender o manuseio de arquivos em COBOL, é necessário conhecer os termos básicos. Esses termos servem apenas para entender os fundamentos do tratamento de arquivos. Uma terminologia mais aprofundada seria discutida no capítulo 'Verbos de tratamento de arquivos'. A seguir estão os termos básicos -
- Field
- Record
- Registro Físico
- Registro Lógico
- File
O exemplo a seguir ajuda a entender esses termos -
Campo
O campo é usado para indicar os dados armazenados sobre um elemento. Ele representa um único elemento, conforme mostrado no exemplo acima, como id do aluno, nome, notas, notas totais e porcentagem. O número de caracteres em qualquer campo é conhecido como tamanho do campo, por exemplo, o nome do aluno pode ter 10 caracteres. Os campos podem ter os seguintes atributos -
Primary keyssão os campos exclusivos de cada registro e usados para identificar um determinado registro. Por exemplo, no arquivo de marcas de alunos, cada aluno terá uma identificação de aluno exclusiva que forma a chave primária.
Secondary keyssão campos exclusivos ou não exclusivos usados para pesquisar dados relacionados. Por exemplo, no arquivo de marcas de alunos, o nome completo do aluno pode ser usado como chave secundária quando a identificação do aluno não é conhecida.
Descriptorscampos são usados para descrever uma entidade. Por exemplo, no arquivo de marcas de alunos, os campos de marcas e de porcentagem que adicionam significado ao registro são descritores conhecidos.
Registro
Registro é um conjunto de campos usado para descrever uma entidade. Um ou mais campos juntos formam um registro. Por exemplo, em arquivos de marcas de alunos, id do aluno, nome, notas, notas totais e porcentagem de um registro. O tamanho cumulativo de todos os campos em um registro é conhecido como tamanho do registro. Os registros presentes em um arquivo podem ser de comprimento fixo ou variável.
Registro Físico
O registro físico é a informação que existe no dispositivo externo. Também é conhecido como bloqueio.
Registro Lógico
O registro lógico é a informação usada pelo programa. Em programas COBOL, apenas um registro pode ser tratado em qualquer ponto do tempo e é chamado de registro lógico.
Arquivo
Arquivo é uma coleção de registros relacionados. Por exemplo, o arquivo de marcas de alunos consiste em registros de todos os alunos.
Organização de arquivos indica como os registros são organizados em um arquivo. Existem diferentes tipos de organizações de arquivos, de forma a aumentar a eficiência do acesso aos registros. A seguir estão os tipos de esquemas de organização de arquivos -
- Organização de arquivo sequencial
- Organização de arquivos sequenciais indexados
- Organização relativa de arquivos
As sintaxes neste módulo, mencionadas junto com seus respectivos termos, referem-se apenas ao seu uso no programa. Os programas completos usando essas sintaxes seriam discutidos no capítulo 'Manipulação de verbos de arquivos'.
Organização de arquivo sequencial
Um arquivo sequencial consiste em registros que são armazenados e acessados em ordem sequencial. A seguir estão os principais atributos da organização de arquivos sequenciais -
Os registros podem ser lidos em ordem sequencial. Para ler o 10 º registro, todos os 9 registros anteriores devem ser lidos.
Os registros são escritos em ordem sequencial. Um novo registro não pode ser inserido no meio. Um novo registro é sempre inserido no final do arquivo.
Depois de colocar um registro em um arquivo sequencial, não é possível excluir, encurtar ou alongar um registro.
A ordem dos registros, uma vez inseridos, nunca pode ser alterada.
A atualização do registro é possível. Um registro pode ser substituído, se a duração do novo registro for igual à duração do registro antigo.
Os arquivos de saída sequencial são uma boa opção para impressão.
Sintaxe
A seguir está a sintaxe da organização de arquivos sequenciais -
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT file-name ASSIGN TO dd-name-jcl
ORGANIZATION IS SEQUENTIALOrganização de arquivo sequencial indexado
Um arquivo sequencial indexado consiste em registros que podem ser acessados sequencialmente. O acesso direto também é possível. Consiste em duas partes -
Data File contém registros em esquema sequencial.
Index File contém a chave primária e seu endereço no arquivo de dados.
A seguir estão os principais atributos da organização de arquivos sequenciais -
Os registros podem ser lidos em ordem sequencial, assim como na organização de arquivos sequenciais.
Os registros podem ser acessados aleatoriamente se a chave primária for conhecida. O arquivo de índice é usado para obter o endereço de um registro e, em seguida, o registro é obtido do arquivo de dados.
O índice classificado é mantido neste sistema de arquivos, que relaciona o valor da chave à posição do registro no arquivo.
O índice alternativo também pode ser criado para buscar os registros.
Sintaxe
A seguir está a sintaxe da organização de arquivos sequenciais indexados -
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT file-name ASSIGN TO dd-name-jcl
ORGANIZATION IS INDEXED
RECORD KEY IS primary-key
ALTERNATE RECORD KEY IS rec-keyOrganização relativa de arquivos
Um arquivo relativo consiste em registros ordenados por seus relative address. A seguir estão os principais atributos da organização relativa de arquivos -
Os registros podem ser lidos em ordem sequencial, assim como na organização de arquivos sequenciais e indexados.
Os registros podem ser acessados usando a chave relativa. A chave relativa representa a localização do registro em relação ao endereço de início do arquivo.
Os registros podem ser inseridos usando a chave relativa. O endereço relativo é calculado usando a chave relativa.
O arquivo relativo fornece o acesso mais rápido aos registros.
A principal desvantagem desse sistema de arquivos é que, se alguns registros intermediários estiverem faltando, eles também ocuparão espaço.
Sintaxe
A seguir está a sintaxe da organização relativa do arquivo -
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT file-name ASSIGN TO dd-name-jcl
ORGANIZATION IS RELATIVE
RELATIVE KEY IS rec-keyAté agora, os esquemas de organização de arquivos foram discutidos. Para cada esquema de organização de arquivo, diferentes modos de acesso podem ser usados. A seguir estão os tipos de modos de acesso a arquivos -
- Acesso Sequencial
- Acesso aleatório
- Acesso Dinâmico
As sintaxes neste módulo, mencionadas junto com seus respectivos termos, referem-se apenas ao seu uso no programa. Os programas completos que usam essas sintaxes serão discutidos no próximo capítulo.
Acesso Sequencial
Quando o modo de acesso é sequencial, o método de recuperação de registro muda de acordo com a organização de arquivo selecionada.
Para sequential files, os registros são acessados na mesma ordem em que foram inseridos.
Para indexed files, o parâmetro usado para buscar os registros são os valores da chave do registro.
Para relative files, as chaves de registro relativas são usadas para recuperar os registros.
Sintaxe
A seguir está a sintaxe do modo de acesso sequencial -
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT file-name ASSIGN TO dd-name
ORGANIZATION IS SEQUENTIAL
ACCESS MODE IS SEQUENTIAL
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT file-name ASSIGN TO dd-name
ORGANIZATION IS INDEXED
ACCESS MODE IS SEQUENTIAL
RECORD KEY IS rec-key1
ALTERNATE RECORD KEY IS rec-key2
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT file-name ASSIGN TO dd-name
ORGANIZATION IS RELATIVE
ACCESS MODE IS SEQUENTIAL
RELATIVE KEY IS rec-key1Acesso aleatório
Quando o modo de acesso é RANDOM, o método de recuperação de registro muda de acordo com a organização de arquivo selecionada.
Para indexed files, os registros são acessados de acordo com o valor colocado em um campo-chave que pode ser uma chave primária ou alternativa. Pode haver um ou mais índices alternativos.
Para relative files , os registros são recuperados por meio de chaves de registro relativas.
Sintaxe
A seguir está a sintaxe do modo de acesso aleatório -
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT file-name ASSIGN TO dd-name
ORGANIZATION IS INDEXED
ACCESS MODE IS RANDOM
RECORD KEY IS rec-key1
ALTERNATE RECORD KEY IS rec-key2
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT file-name ASSIGN TO dd-name
ORGANIZATION IS RELATIVE
ACCESS MODE IS RANDOM
RELATIVE KEY IS rec-key1Acesso Dinâmico
O acesso dinâmico suporta acesso sequencial e aleatório no mesmo programa. Com o acesso dinâmico, uma definição de arquivo é usada para executar o processamento sequencial e aleatório, como acessar alguns registros em ordem sequencial e outros registros por suas chaves.
Com arquivos relativos e indexados, o modo de acesso dinâmico permite alternar entre o modo de acesso sequencial e o modo de acesso aleatório enquanto lê um arquivo usando a frase NEXT na instrução READ. As funcionalidades NEXT e READ serão discutidas no próximo capítulo.
Sintaxe
A seguir está a sintaxe do modo de acesso dinâmico -
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT file-name ASSIGN TO dd-name
ORGANIZATION IS SEQUENTIAL
ACCESS MODE IS DYNAMIC
RECORD KEY IS rec-key1
ALTERNATE RECORD KEY IS rec-key2
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT file-name ASSIGN TO dd-name
ORGANIZATION IS RELATIVE
ACCESS MODE IS DYNAMIC
RELATIVE KEY IS rec-key1Os verbos de manipulação de arquivos são usados para realizar várias operações em arquivos. A seguir estão os verbos de manipulação de arquivos -
- Open
- Read
- Write
- Rewrite
- Delete
- Start
- Close
Verbo aberto
Abrir é a primeira operação de arquivo que deve ser executada. Se a abertura for bem-sucedida, apenas outras operações serão possíveis em um arquivo. Somente após a abertura de um arquivo, as variáveis na estrutura do arquivo estão disponíveis para processamento.FILE STATUS variável é atualizada após cada operação de arquivo.
Sintaxe
OPEN "mode" file-name.Aqui, o nome do arquivo é uma string literal, que você usará para nomear o seu arquivo. Um arquivo pode ser aberto nos seguintes modos -
| Sr. Não. | Modo e descrição |
|---|---|
| 1 | Input O modo de entrada é usado para arquivos existentes. Neste modo, podemos apenas ler o arquivo, nenhuma outra operação é permitida no arquivo. |
| 2 | Output O modo de saída é usado para inserir registros em arquivos. Se umsequential fileé usado e o arquivo está mantendo alguns registros, então os registros existentes serão excluídos primeiro e, em seguida, novos registros serão inseridos no arquivo. Isso não vai acontecer no caso de umindexed file ou um relative file. |
| 3 | Extend O modo de extensão é usado para anexar registros em um sequential file. Neste modo, os registros são inseridos no final. Se o modo de acesso ao arquivo forRandom ou Dynamic, o modo estendido não pode ser usado. |
| 4 | I-O O modo de entrada-saída é usado para ler e reescrever os registros de um arquivo. |
Leia Verbo
Ler verbo é usado para ler os registros do arquivo. A função de leitura é buscar registros de um arquivo. A cada verbo lido, apenas um registro pode ser lido na estrutura do arquivo. Para realizar uma operação de leitura, abra o arquivo no modo INPUT ou IO. A cada instrução de leitura, o ponteiro do arquivo é incrementado e, portanto, os registros sucessivos são lidos.
Sintaxe
A seguir está a sintaxe para ler os registros quando o modo de acesso ao arquivo é sequencial -
READ file-name NEXT RECORD INTO ws-file-structure
AT END DISPLAY 'End of File'
NOT AT END DISPLAY 'Record Details:' ws-file-structure
END-READ.A seguir estão os parâmetros usados -
NEXT RECORD é opcional e é especificado quando um arquivo sequencial indexado está sendo lido sequencialmente.
A cláusula INTO é opcional. ws-file-structure é definida na WorkingStorage Section para obter os valores da instrução READ.
A condição AT END torna-se True quando o final do arquivo é atingido.
Example- O exemplo a seguir lê um arquivo existente usando a organização sequencial de linha. Este programa pode ser compilado e executado usandoLive Demo opção onde irá mostrar todos os registros presentes no arquivo.
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT STUDENT ASSIGN TO 'input.txt'
ORGANIZATION IS LINE SEQUENTIAL.
DATA DIVISION.
FILE SECTION.
FD STUDENT.
01 STUDENT-FILE.
05 STUDENT-ID PIC 9(5).
05 NAME PIC A(25).
WORKING-STORAGE SECTION.
01 WS-STUDENT.
05 WS-STUDENT-ID PIC 9(5).
05 WS-NAME PIC A(25).
01 WS-EOF PIC A(1).
PROCEDURE DIVISION.
OPEN INPUT STUDENT.
PERFORM UNTIL WS-EOF='Y'
READ STUDENT INTO WS-STUDENT
AT END MOVE 'Y' TO WS-EOF
NOT AT END DISPLAY WS-STUDENT
END-READ
END-PERFORM.
CLOSE STUDENT.
STOP RUN.Suponha que os dados do arquivo de entrada disponíveis no input.txt arquivo contém o seguinte -
20003 Mohtashim M.
20004 Nishant Malik
20005 Amitabh BachhanQuando você compila e executa o programa acima, ele produz o seguinte resultado -
20003 Mohtashim M.
20004 Nishant Malik
20005 Amitabh BachhanSintaxe
A seguir está a sintaxe para ler um registro quando o modo de acesso ao arquivo é aleatório -
READ file-name RECORD INTO ws-file-structure
KEY IS rec-key
INVALID KEY DISPLAY 'Invalid Key'
NOT INVALID KEY DISPLAY 'Record Details: ' ws-file-structure
END-READ.Example- O exemplo a seguir lê um arquivo existente usando organização indexada. Este programa pode ser compilado e executado usandoJCLem Mainframes onde exibirá todos os registros presentes no arquivo. No servidor Mainframes, não usamos arquivos de texto; em vez disso, usamos arquivos PS.
Vamos supor que o arquivo presente nos Mainframes tenha o mesmo conteúdo do arquivo input.txt no exemplo acima.
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT STUDENT ASSIGN TO IN1
ORGANIZATION IS INDEXED
ACCESS IS RANDOM
RECORD KEY IS STUDENT-ID
FILE STATUS IS FS.
DATA DIVISION.
FILE SECTION.
FD STUDENT.
01 STUDENT-FILE.
05 STUDENT-ID PIC 9(5).
05 NAME PIC A(25).
WORKING-STORAGE SECTION.
01 WS-STUDENT.
05 WS-STUDENT-ID PIC 9(5).
05 WS-NAME PIC A(25).
PROCEDURE DIVISION.
OPEN INPUT STUDENT.
MOVE 20005 TO STUDENT-ID.
READ STUDENT RECORD INTO WS-STUDENT-FILE
KEY IS STUDENT-ID
INVALID KEY DISPLAY 'Invalid Key'
NOT INVALID KEY DISPLAY WS-STUDENT-FILE
END-READ.
CLOSE STUDENT.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//IN1 DD DSN = STUDENT-FILE-NAME,DISP=SHRQuando você compila e executa o programa acima, ele produz o seguinte resultado -
20005 Amitabh BachhanEscreva Verbo
O verbo escrever é usado para inserir registros em um arquivo. Depois que o registro é gravado, ele não está mais disponível no buffer de registro. Antes de inserir registros no arquivo, mova os valores para o buffer de registro e execute o verbo de escrita.
A declaração de escrita pode ser usada com FROMopção de gravar diretamente os registros das variáveis de armazenamento de trabalho. From é uma cláusula opcional. Se o modo de acesso for sequencial, para gravar um registro, o arquivo deve ser aberto no modo Saída ou no modo Extend. Se o modo de acesso for aleatório ou dinâmico, para gravar um registro, o arquivo deve ser aberto no modo Saída ou modo E / S.
Sintaxe
A seguir está a sintaxe para ler um registro quando a organização do arquivo é sequencial -
WRITE record-buffer [FROM ws-file-structure]
END-WRITE.A seguir está a sintaxe para ler um registro quando a organização do arquivo é indexada ou relativa -
WRITE record-buffer [FROM ws-file-structure]
INVALID KEY DISPLAY 'Invalid Key'
NOT INVALID KEY DISPLAY 'Record Inserted'
END-WRITE.Example - O exemplo a seguir mostra como inserir um novo registro em um novo arquivo quando a organização é sequencial.
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT STUDENT ASSIGN TO OUT1
ORGANIZATION IS SEQUENTIAL
ACCESS IS SEQUENTIAL
FILE STATUS IS FS.
DATA DIVISION.
FILE SECTION.
FD STUDENT
01 STUDENT-FILE.
05 STUDENT-ID PIC 9(5).
05 NAME PIC A(25).
05 CLASS PIC X(3).
WORKING-STORAGE SECTION.
01 WS-STUDENT.
05 WS-STUDENT-ID PIC 9(5).
05 WS-NAME PIC A(25).
05 WS-CLASS PIC X(3).
PROCEDURE DIVISION.
OPEN EXTEND STUDENT.
MOVE 1000 TO STUDENT-ID.
MOVE 'Tim' TO NAME.
MOVE '10' TO CLASS.
WRITE STUDENT-FILE
END-WRITE.
CLOSE STUDENT.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//OUT1 DD DSN = OUTPUT-FILE-NAME,DISP = (NEW,CATALOG,DELETE)Quando você compila e executa o programa acima, ele adiciona um novo registro ao arquivo de saída.
1000 Tim 10Reescrever Verbo
O verbo reescrever é usado para atualizar os registros. O arquivo deve ser aberto no modo IO para operações de reescrita. Ele pode ser usado somente após uma operação de leitura bem-sucedida. O verbo reescrever substitui o último registro lido.
Sintaxe
A seguir está a sintaxe para ler um registro quando a organização do arquivo é sequencial -
REWRITE record-buffer [FROM ws-file-structure]
END-REWRITE.A seguir está a sintaxe para ler um registro quando a organização do arquivo é indexada ou relativa -
REWRITE record-buffer [FROM ws-file-structure]
INVALID KEY DISPLAY 'Invalid Key'
NOT INVALID KEY DISPLAY 'Record Updated'
END-REWRITE.Example - O exemplo a seguir mostra como atualizar um registro existente que inserimos na etapa de gravação anterior -
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT STUDENT ASSIGN TO IN1
ORGANIZATION IS INDEXED
ACCESS IS RANDOM
RECORD KEY IS STUDENT-ID
FILE STATUS IS FS.
DATA DIVISION.
FILE SECTION.
FD STUDENT
01 STUDENT-FILE.
05 STUDENT-ID PIC 9(4).
05 NAME PIC A(12).
05 CLASS PIC X(3).
WORKING-STORAGE SECTION.
01 WS-STUDENT.
05 WS-STUDENT-ID PIC 9(5).
05 WS-NAME PIC A(25).
05 WS-CLASS PIC X(3).
PROCEDURE DIVISION.
OPEN I-O STUDENT.
MOVE '1000' TO STUDENT-ID.
READ STUDENT
KEY IS STUDENT-ID
INVALID KEY DISPLAY ‘KEY IS NOT EXISTING’
END-READ.
MOVE 'Tim Dumais' TO NAME.
REWRITE STUDENT-FILE
END-REWRITE.
CLOSE STUDENT.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//IN1 DD DSN = OUTPUT-FILE-NAME,DISP = SHRQuando você compila e executa o programa acima, ele atualiza o registro -
1000 Tim Dumais 10Apagar Verbo
Excluir verbo pode ser executado apenas em arquivos indexados e relativos. O arquivo deve ser aberto no modo IO. Na organização de arquivos sequenciais, os registros não podem ser excluídos. O último registro lido pela instrução Read é excluído no caso do modo de acesso sequencial. No modo de acesso aleatório, especifique a chave de registro e execute a operação Excluir.
Sintaxe
A seguir está a sintaxe para excluir um registro -
DELETE file-name RECORD
INVALID KEY DISPLAY 'Invalid Key'
NOT INVALID KEY DISPLAY 'Record Deleted'
END-DELETE.Example - para excluir um registro existente -
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT STUDENT ASSIGN TO OUT1
ORGANIZATION IS INDEXED
ACCESS IS RANDOM
RECORD KEY IS STUDENT-ID
FILE STATUS IS FS.
DATA DIVISION.
FILE SECTION.
FD STUDENT
01 STUDENT-FILE.
05 STUDENT-ID PIC 9(4).
05 NAME PIC A(12).
05 CLASS PIC X(3).
WORKING-STORAGE SECTION.
01 WS-STUDENT.
05 WS-STUDENT-ID PIC 9(5).
05 WS-NAME PIC A(25).
05 WS-CLASS PIC X(3).
PROCEDURE DIVISION.
OPEN I-O STUDENT.
MOVE '1000' TO STUDENT-ID.
DELETE STUDENT RECORD
INVALID KEY DISPLAY 'Invalid Key'
NOT INVALID KEY DISPLAY 'Record Deleted'
END-DELETE.
CLOSE STUDENT.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//OUT1 DD DSN = OUTPUT-FILE-NAME,DISP = SHRQuando você compila e executa o programa acima, ele produz o seguinte resultado -
Record DeletedIniciar Verbo
Iniciar verbo pode ser executado apenas em arquivos indexados e relativos. É usado para colocar o ponteiro do arquivo em um registro específico. O modo de acesso deve ser sequencial ou dinâmico. O arquivo deve ser aberto no modo IO ou Entrada.
Sintaxe
A seguir está a sintaxe para colocar o ponteiro em um registro específico -
START file-name KEY IS [=, >, <, NOT, <= or >=] rec-key
INVALID KEY DISPLAY 'Invalid Key'
NOT INVALID KEY DISPLAY 'File Pointer Updated'
END-START.Fechar Verbo
O verbo Fechar é usado para fechar um arquivo. Após executar a operação Fechar, as variáveis na estrutura do arquivo não estarão disponíveis para processamento. O vínculo entre o programa e o arquivo foi perdido.
Sintaxe
A seguir está a sintaxe para fechar um arquivo -
CLOSE file-name.A sub-rotina Cobol é um programa que pode ser compilado independentemente, mas não pode ser executado independentemente. Existem dois tipos de sub-rotinas:internal subroutines gostar Perform declarações e external sub-rotinas como verbo CALL.
Call Verb
O verbo de chamada é usado para transferir o controle de um programa para outro. O programa que contém o verbo CALL é oCalling Program e o programa que está sendo chamado é conhecido como o Called Program. A execução do programa de chamada será interrompida até que o programa chamado termine a execução. A instrução Exit Program é usada no programa chamado para transferir o controle de volta.
Restrições do programa chamado
A seguir estão os chamados requisitos do programa -
Linkage sectiondeve ser definido no programa chamado. Consiste em elementos de dados passados no programa. Os itens de dados não devem ter cláusula Value. A cláusula PIC deve ser compatível com as variáveis passadas pelo programa de chamada.
Procedure division using tem uma lista de variáveis passadas do programa de chamada e a ordem deve ser a mesma mencionada no verbo Call.
Exit programinstrução é usada no programa chamado para transferir o controle de volta. Deve ser a última instrução do programa chamado.
Os parâmetros podem ser passados entre programas de duas maneiras -
- Por referência
- Por Conteúdo
Chamada por referência
Se os valores das variáveis no programa chamado forem modificados, seus novos valores serão refletidos no programa de chamada. E seBY cláusula não é especificada, então as variáveis são sempre passadas por referência.
Sintaxe
A seguir está a sintaxe para chamar a sub-rotina por referência -
CALL sub-prog-name USING variable-1, variable-2.Example
O exemplo a seguir é o programa de chamada MAIN e UTIL é o programa chamado -
IDENTIFICATION DIVISION.
PROGRAM-ID. MAIN.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-STUDENT-ID PIC 9(4) VALUE 1000.
01 WS-STUDENT-NAME PIC A(15) VALUE 'Tim'.
PROCEDURE DIVISION.
CALL 'UTIL' USING WS-STUDENT-ID, WS-STUDENT-NAME.
DISPLAY 'Student Id : ' WS-STUDENT-ID
DISPLAY 'Student Name : ' WS-STUDENT-NAME
STOP RUN.Programa Chamado
IDENTIFICATION DIVISION.
PROGRAM-ID. UTIL.
DATA DIVISION.
LINKAGE SECTION.
01 LS-STUDENT-ID PIC 9(4).
01 LS-STUDENT-NAME PIC A(15).
PROCEDURE DIVISION USING LS-STUDENT-ID, LS-STUDENT-NAME.
DISPLAY 'In Called Program'.
MOVE 1111 TO LS-STUDENT-ID.
EXIT PROGRAM.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = MAINQuando você compila e executa o programa acima, ele produz o seguinte resultado -
In Called Program
Student Id : 1111
Student Name : TimChamada por conteúdo
Se os valores das variáveis no programa chamado forem modificados, seus novos valores não serão refletidos no programa de chamada.
Sintaxe
A seguir está a sintaxe para chamar a sub-rotina por conteúdo -
CALL sub-prog-name USING
BY CONTENT variable-1, BY CONTENT variable-2.Example
O exemplo a seguir é o programa de chamada MAIN e UTIL é o programa chamado -
IDENTIFICATION DIVISION.
PROGRAM-ID. MAIN.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 WS-STUDENT-ID PIC 9(4) VALUE 1000.
01 WS-STUDENT-NAME PIC A(15) VALUE 'Tim'.
PROCEDURE DIVISION.
CALL 'UTIL' USING BY CONTENT WS-STUDENT-ID, BY CONTENT WS-STUDENT-NAME.
DISPLAY 'Student Id : ' WS-STUDENT-ID
DISPLAY 'Student Name : ' WS-STUDENT-NAME
STOP RUN.Programa Chamado
IDENTIFICATION DIVISION.
PROGRAM-ID. UTIL.
DATA DIVISION.
LINKAGE SECTION.
01 LS-STUDENT-ID PIC 9(4).
01 LS-STUDENT-NAME PIC A(15).
PROCEDURE DIVISION USING LS-STUDENT-ID, LS-STUDENT-NAME.
DISPLAY 'In Called Program'.
MOVE 1111 TO LS-STUDENT-ID.
EXIT PROGRAM.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = MAINQuando você compila e executa o programa acima, ele produz o seguinte resultado -
In Called Program
Student Id : 1000
Student Name : TimTipos de Chamada
Existem dois tipos de chamadas -
Static Callocorre quando um programa é compilado com a opção de compilador NODYNAM. Um programa chamado estático é carregado no armazenamento em tempo de compilação.
Dynamic Callocorre quando um programa é compilado com a opção de compilador DYNAM e NODLL. Um programa chamado dinâmico é carregado no armazenamento em tempo de execução.
A classificação de dados em um arquivo ou a fusão de dois ou mais arquivos é uma necessidade comum em quase todos os aplicativos de negócios. A classificação é usada para organizar os registros em ordem crescente ou decrescente, de modo que o processamento sequencial possa ser executado. Existem duas técnicas que são usadas para classificar arquivos em COBOL -
External sorté usado para classificar arquivos usando o utilitário SORT em JCL. Discutimos isso no capítulo JCL. A partir de agora, vamos nos concentrar na classificação interna.
Internal sort é usado para classificar arquivos em um programa COBOL. SORT verbo é usado para classificar um arquivo.
Classificar Verbo
Três arquivos são usados no processo de classificação em COBOL -
Input file é o arquivo que devemos classificar em ordem crescente ou decrescente.
Work fileé usado para manter registros enquanto o processo de classificação está em andamento. Os registros do arquivo de entrada são transferidos para o arquivo de trabalho para o processo de classificação. Este arquivo deve ser definido na seção Arquivo na entrada SD.
Output fileé o arquivo que obtemos após o processo de classificação. É a saída final do verbo Sort.
Sintaxe
A seguir está a sintaxe para classificar um arquivo -
SORT work-file ON ASCENDING KEY rec-key1
[ON DESCENDING KEY rec-key2]
USING input-file GIVING output-file.SORT executa as seguintes operações -
Abre o arquivo de trabalho no modo IO, o arquivo de entrada no modo INPUT e o arquivo de saída no modo OUTPUT.
Transfere os registros presentes no arquivo de entrada para o arquivo de trabalho.
Classifica o SORT-FILE em sequência crescente / decrescente pela tecla rec.
Transfere os registros classificados do arquivo de trabalho para o arquivo de saída.
Fecha o arquivo de entrada e o arquivo de saída e exclui o arquivo de trabalho.
Example
No exemplo a seguir, INPUT é o arquivo de entrada que precisa ser classificado em ordem crescente -
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT INPUT ASSIGN TO IN.
SELECT OUTPUT ASSIGN TO OUT.
SELECT WORK ASSIGN TO WRK.
DATA DIVISION.
FILE SECTION.
FD INPUT.
01 INPUT-STUDENT.
05 STUDENT-ID-I PIC 9(5).
05 STUDENT-NAME-I PIC A(25).
FD OUTPUT.
01 OUTPUT-STUDENT.
05 STUDENT-ID-O PIC 9(5).
05 STUDENT-NAME-O PIC A(25).
SD WORK.
01 WORK-STUDENT.
05 STUDENT-ID-W PIC 9(5).
05 STUDENT-NAME-W PIC A(25).
PROCEDURE DIVISION.
SORT WORK ON ASCENDING KEY STUDENT-ID-O
USING INPUT GIVING OUTPUT.
DISPLAY 'Sort Successful'.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//IN DD DSN = INPUT-FILE-NAME,DISP = SHR
//OUT DD DSN = OUTPUT-FILE-NAME,DISP = SHR
//WRK DD DSN = &&TEMPQuando você compila e executa o programa acima, ele produz o seguinte resultado -
Sort SuccessfulMerge Verb
Dois ou mais arquivos sequenciados de forma idêntica são combinados usando a instrução Merge. Arquivos usados no processo de fusão -
- Arquivos de entrada - entrada-1, entrada-2
- Arquivo de Trabalho
- Arquivo de saída
Sintaxe
A seguir está a sintaxe para mesclar dois ou mais arquivos -
MERGE work-file ON ASCENDING KEY rec-key1
[ON DESCENDING KEY rec-key2]
USING input-1, input-2 GIVING output-file.Merge executa as seguintes operações -
Abre o arquivo de trabalho no modo IO, os arquivos de entrada no modo INPUT e o arquivo de saída no modo OUTPUT.
Transfere os registros presentes nos arquivos de entrada para o arquivo de trabalho.
Classifica o SORT-FILE em sequência crescente / decrescente pela tecla rec.
Transfere os registros classificados do arquivo de trabalho para o arquivo de saída.
Fecha o arquivo de entrada e o arquivo de saída e exclui o arquivo de trabalho.
Example
No exemplo a seguir, INPUT1 e INPUT2 são os arquivos de entrada que devem ser mesclados em ordem crescente -
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT INPUT1 ASSIGN TO IN1.
SELECT INPUT2 ASSIGN TO IN2.
SELECT OUTPUT ASSIGN TO OUT.
SELECT WORK ASSIGN TO WRK.
DATA DIVISION.
FILE SECTION.
FD INPUT1.
01 INPUT1-STUDENT.
05 STUDENT-ID-I1 PIC 9(5).
05 STUDENT-NAME-I1 PIC A(25).
FD INPUT2.
01 INPUT2-STUDENT.
05 STUDENT-ID-I2 PIC 9(5).
05 STUDENT-NAME-I2 PIC A(25).
FD OUTPUT.
01 OUTPUT-STUDENT.
05 STUDENT-ID-O PIC 9(5).
05 STUDENT-NAME-O PIC A(25).
SD WORK.
01 WORK-STUDENT.
05 STUDENT-ID-W PIC 9(5).
05 STUDENT-NAME-W PIC A(25).
PROCEDURE DIVISION.
MERGE WORK ON ASCENDING KEY STUDENT-ID-O
USING INPUT1, INPUT2 GIVING OUTPUT.
DISPLAY 'Merge Successful'.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP1 EXEC PGM = HELLO
//IN1 DD DSN=INPUT1-FILE-NAME,DISP=SHR
//IN2 DD DSN=INPUT2-FILE-NAME,DISP=SHR
//OUT DD DSN = OUTPUT-FILE-NAME,DISP=SHR
//WRK DD DSN = &&TEMPQuando você compila e executa o programa acima, ele produz o seguinte resultado -
Merge SuccessfulA partir de agora, aprendemos a usar arquivos em COBOL. Agora, discutiremos como um programa COBOL interage com o DB2. Envolve os seguintes termos -
- SQL embutido
- DB2 Application Programming
- Variáveis Host
- SQLCA
- Consultas SQL
- Cursors
SQL embutido
As instruções SQL incorporadas são usadas em programas COBOL para executar operações SQL padrão. As instruções SQL incorporadas são pré-processadas pelo processador SQL antes da compilação do programa aplicativo. COBOL é conhecido como oHost Language. Aplicativos COBOL-DB2 são aqueles aplicativos que incluem COBOL e DB2.
As instruções SQL incorporadas funcionam como instruções SQL normais, com algumas pequenas alterações. Por exemplo, a saída de uma consulta é direcionada a um conjunto predefinido de variáveis que são referidas comoHost Variables. Uma cláusula INTO adicional é colocada na instrução SELECT.
DB2 Application Programming
A seguir estão as regras a serem seguidas durante a codificação de um programa COBOL-DB2 -
Todas as instruções SQL devem ser delimitadas entre EXEC SQL e ENDEXEC..
As instruções SQL devem ser codificadas na Área B.
Todas as tabelas que são usadas em um programa devem ser declaradas na Seção WorkingStorage. Isso é feito usando oINCLUDE declaração.
Todas as instruções SQL diferentes de INCLUDE e DECLARE TABLE devem aparecer na Divisão de Procedimento.
Variáveis Host
Variáveis de host são usadas para receber dados de uma tabela ou inserir dados em uma tabela. As variáveis do host devem ser declaradas para todos os valores que devem ser transmitidos entre o programa e o DB2. Eles são declarados na Seção de Trabalho-Armazenamento.
As variáveis do host não podem ser itens de grupo, mas podem ser agrupadas na estrutura do host. Eles não podem serRenamed ou Redefined. Usando variáveis de host com instruções SQL, prefixe-as com umcolon (:)..
Sintaxe
A seguir está a sintaxe para declarar variáveis de host e incluir tabelas na seção Working-Storage -
DATA DIVISION.
WORKING-STORAGE SECTION.
EXEC SQL
INCLUDE table-name
END-EXEC.
EXEC SQL BEGIN DECLARE SECTION
END-EXEC.
01 STUDENT-REC.
05 STUDENT-ID PIC 9(4).
05 STUDENT-NAME PIC X(25).
05 STUDENT-ADDRESS X(50).
EXEC SQL END DECLARE SECTION
END-EXEC.SQLCA
SQLCA é uma área de comunicação SQL por meio da qual o DB2 passa o feedback da execução de SQL para o programa. Diz ao programa se uma execução foi bem-sucedida ou não. Existem várias variáveis predefinidas no SQLCA, comoSQLCODEque contém o código de erro. O valor '000' em SQLCODE indica uma execução bem-sucedida.
Sintaxe
A seguir está a sintaxe para declarar um SQLCA na seção Working-Storage -
DATA DIVISION.
WORKING-STORAGE SECTION.
EXEC SQL
INCLUDE SQLCA
END-EXEC.Consultas SQL
Vamos supor que temos uma tabela chamada 'Aluno' que contém a Id do Aluno, o Nome do Aluno e o Endereço do Aluno.
A tabela STUDENT contém os seguintes dados -
Student Id Student Name Student Address
1001 Mohtashim M. Hyderabad
1002 Nishant Malik Delhi
1003 Amitabh Bachan Mumbai
1004 Chulbul Pandey LucknowO exemplo a seguir mostra o uso de SELECT consulta em um programa COBOL -
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
EXEC SQL
INCLUDE SQLCA
END-EXEC.
EXEC SQL
INCLUDE STUDENT
END-EXEC.
EXEC SQL BEGIN DECLARE SECTION
END-EXEC.
01 WS-STUDENT-REC.
05 WS-STUDENT-ID PIC 9(4).
05 WS-STUDENT-NAME PIC X(25).
05 WS-STUDENT-ADDRESS X(50).
EXEC SQL END DECLARE SECTION
END-EXEC.
PROCEDURE DIVISION.
EXEC SQL
SELECT STUDENT-ID, STUDENT-NAME, STUDENT-ADDRESS
INTO :WS-STUDENT-ID, :WS-STUDENT-NAME, WS-STUDENT-ADDRESS FROM STUDENT
WHERE STUDENT-ID=1004
END-EXEC.
IF SQLCODE = 0
DISPLAY WS-STUDENT-RECORD
ELSE DISPLAY 'Error'
END-IF.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP001 EXEC PGM = IKJEFT01
//STEPLIB DD DSN = MYDATA.URMI.DBRMLIB,DISP = SHR
//SYSPRINT DD SYSOUT=*
//SYSUDUMP DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSTSIN DD *
DSN SYSTEM(SSID)
RUN PROGRAM(HELLO) PLAN(PLANNAME) -
END
/*Quando você compila e executa o programa acima, ele produz o seguinte resultado -
1004 Chulbul Pandey LucknowO exemplo a seguir mostra o uso de INSERT consulta em um programa COBOL -
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
EXEC SQL
INCLUDE SQLCA
END-EXEC.
EXEC SQL
INCLUDE STUDENT
END-EXEC.
EXEC SQL BEGIN DECLARE SECTION
END-EXEC.
01 WS-STUDENT-REC.
05 WS-STUDENT-ID PIC 9(4).
05 WS-STUDENT-NAME PIC X(25).
05 WS-STUDENT-ADDRESS X(50).
EXEC SQL END DECLARE SECTION
END-EXEC.
PROCEDURE DIVISION.
MOVE 1005 TO WS-STUDENT-ID.
MOVE 'TutorialsPoint' TO WS-STUDENT-NAME.
MOVE 'Hyderabad' TO WS-STUDENT-ADDRESS.
EXEC SQL
INSERT INTO STUDENT(STUDENT-ID, STUDENT-NAME, STUDENT-ADDRESS)
VALUES (:WS-STUDENT-ID, :WS-STUDENT-NAME, WS-STUDENT-ADDRESS)
END-EXEC.
IF SQLCODE = 0
DISPLAY 'Record Inserted Successfully'
DISPLAY WS-STUDENT-REC
ELSE DISPLAY 'Error'
END-IF.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP001 EXEC PGM = IKJEFT01
//STEPLIB DD DSN = MYDATA.URMI.DBRMLIB,DISP=SHR
//SYSPRINT DD SYSOUT = *
//SYSUDUMP DD SYSOUT = *
//SYSOUT DD SYSOUT = *
//SYSTSIN DD *
DSN SYSTEM(SSID)
RUN PROGRAM(HELLO) PLAN(PLANNAME) -
END
/*Quando você compila e executa o programa acima, ele produz o seguinte resultado -
Record Inserted Successfully
1005 TutorialsPoint HyderabadO exemplo a seguir mostra o uso de UPDATE consulta em um programa COBOL -
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
EXEC SQL
INCLUDE SQLCA
END-EXEC.
EXEC SQL
INCLUDE STUDENT
END-EXEC.
EXEC SQL BEGIN DECLARE SECTION
END-EXEC.
01 WS-STUDENT-REC.
05 WS-STUDENT-ID PIC 9(4).
05 WS-STUDENT-NAME PIC X(25).
05 WS-STUDENT-ADDRESS X(50).
EXEC SQL END DECLARE SECTION
END-EXEC.
PROCEDURE DIVISION.
MOVE 'Bangalore' TO WS-STUDENT-ADDRESS.
EXEC SQL
UPDATE STUDENT SET STUDENT-ADDRESS=:WS-STUDENT-ADDRESS
WHERE STUDENT-ID = 1003
END-EXEC.
IF SQLCODE = 0
DISPLAY 'Record Updated Successfully'
ELSE DISPLAY 'Error'
END-IF.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP001 EXEC PGM = IKJEFT01
//STEPLIB DD DSN = MYDATA.URMI.DBRMLIB,DISP = SHR
//SYSPRINT DD SYSOUT = *
//SYSUDUMP DD SYSOUT = *
//SYSOUT DD SYSOUT = *
//SYSTSIN DD *
DSN SYSTEM(SSID)
RUN PROGRAM(HELLO) PLAN(PLANNAME) -
END
/*Quando você compila e executa o programa acima, ele produz o seguinte resultado -
Record Updated SuccessfullyOs seguintes example mostra o uso de DELETE consulta em um programa COBOL -
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
EXEC SQL
INCLUDE SQLCA
END-EXEC.
EXEC SQL
INCLUDE STUDENT
END-EXEC.
EXEC SQL BEGIN DECLARE SECTION
END-EXEC.
01 WS-STUDENT-REC.
05 WS-STUDENT-ID PIC 9(4).
05 WS-STUDENT-NAME PIC X(25).
05 WS-STUDENT-ADDRESS X(50).
EXEC SQL END DECLARE SECTION
END-EXEC.
PROCEDURE DIVISION.
MOVE 1005 TO WS-STUDENT-ID.
EXEC SQL
DELETE FROM STUDENT
WHERE STUDENT-ID=:WS-STUDENT-ID
END-EXEC.
IF SQLCODE = 0
DISPLAY 'Record Deleted Successfully'
ELSE DISPLAY 'Error'
END-IF.
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP001 EXEC PGM = IKJEFT01
//STEPLIB DD DSN = MYDATA.URMI.DBRMLIB,DISP=SHR
//SYSPRINT DD SYSOUT = *
//SYSUDUMP DD SYSOUT = *
//SYSOUT DD SYSOUT = *
//SYSTSIN DD *
DSN SYSTEM(SSID)
RUN PROGRAM(HELLO) PLAN(PLANNAME) -
END
/*Quando você compila e executa o programa acima, ele produz o seguinte resultado -
Record Deleted SuccessfullyCursores
Os cursores são usados para lidar com várias seleções de linha ao mesmo tempo. São estruturas de dados que contêm todos os resultados de uma consulta. Eles podem ser definidos na Seção de Trabalho-Armazenamento ou na Divisão de Procedimento. A seguir estão as operações associadas ao Cursor -
- Declare
- Open
- Close
- Fetch
Declare Cursor
A declaração do cursor pode ser feita na Seção de Trabalho-Armazenamento ou na Divisão de Procedimento. A primeira instrução é a instrução DECLARE, que é uma instrução não executável.
EXEC SQL
DECLARE STUDCUR CURSOR FOR
SELECT STUDENT-ID, STUDENT-NAME, STUDENT-ADDRESS FROM STUDENT
WHERE STUDENT-ID >:WS-STUDENT-ID
END-EXEC.Abrir
Antes de usar um cursor, a instrução Open deve ser executada. A instrução Open prepara o SELECT para execução.
EXEC SQL
OPEN STUDCUR
END-EXEC.Fechar
A instrução Close libera toda a memória ocupada pelo cursor. É obrigatório fechar um cursor antes de encerrar um programa.
EXEC SQL
CLOSE STUDCUR
END-EXEC.Buscar
A instrução Fetch identifica o cursor e coloca o valor na cláusula INTO. Uma instrução Fetch é codificada em loop conforme obtemos uma linha de cada vez.
EXEC SQL
FETCH STUDCUR
INTO :WS-STUDENT-ID, :WS-STUDENT-NAME, WS-STUDENT-ADDRESS
END-EXEC.O exemplo a seguir mostra o uso do cursor para buscar todos os registros da tabela STUDENT -
IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO.
DATA DIVISION.
WORKING-STORAGE SECTION.
EXEC SQL
INCLUDE SQLCA
END-EXEC.
EXEC SQL
INCLUDE STUDENT
END-EXEC.
EXEC SQL BEGIN DECLARE SECTION
END-EXEC.
01 WS-STUDENT-REC.
05 WS-STUDENT-ID PIC 9(4).
05 WS-STUDENT-NAME PIC X(25).
05 WS-STUDENT-ADDRESS X(50).
EXEC SQL END DECLARE SECTION
END-EXEC.
EXEC SQL
DECLARE STUDCUR CURSOR FOR
SELECT STUDENT-ID, STUDENT-NAME, STUDENT-ADDRESS FROM STUDENT
WHERE STUDENT-ID >:WS-STUDENT-ID
END-EXEC.
PROCEDURE DIVISION.
MOVE 1001 TO WS-STUDENT-ID.
PERFORM UNTIL SQLCODE = 100
EXEC SQL
FETCH STUDCUR
INTO :WS-STUDENT-ID, :WS-STUDENT-NAME, WS-STUDENT-ADDRESS
END-EXEC
DISPLAY WS-STUDENT-REC
END-PERFORM
STOP RUN.JCL para executar o programa COBOL acima -
//SAMPLE JOB(TESTJCL,XXXXXX),CLASS = A,MSGCLASS = C
//STEP001 EXEC PGM=IKJEFT01
//STEPLIB DD DSN=MYDATA.URMI.DBRMLIB,DISP=SHR
//SYSPRINT DD SYSOUT=*
//SYSUDUMP DD SYSOUT=*
//SYSOUT DD SYSOUT=*
//SYSTSIN DD *
DSN SYSTEM(SSID)
RUN PROGRAM(HELLO) PLAN(PLANNAME) -
END
/*Quando você compila e executa o programa acima, ele produz o seguinte resultado -
1001 Mohtashim M. Hyderabad
1002 Nishant Malik Delhi
1003 Amitabh Bachan Mumbai
1004 Chulbul Pandey Lucknow