Cobol: manipulando e formatando dados

Entendendo Balance-Line - Apresentação

Boas-vindas ao nosso curso de COBOL, técnicas de programação! Meu nome é Ivan Petrucci e serei seu instrutor.

Audiodescrição: Ivan é uma pessoa de pele clara, tem cabelos, olhos e barba castanhos-escuros. Usa óculos de grau com armação quadrada e uma camiseta preta. Ao fundo, uma parede lisa com iluminação azul-claro.

Objetivos do Curso

Neste curso, vamos investigar e aprender a produzir alguns programas utilizando técnicas tradicionais do COBOL. Entre elas, destacamos o Balance Line. Vamos trabalhar com arquivos, recebê-los e realizar junções.

Também vamos lidar com relatórios, transformando arquivos padrão COBOL em arquivos no formato de relatório, com páginas totais, subtotais e formatados de maneira adequada. Além disso, faremos a extração de dados de um arquivo padrão COBOL para um arquivo padrão CSV, por exemplo.

Essas três técnicas nos ajudarão a entender melhor como funciona o dia a dia de alguns programas ou rotinas comuns no mundo da programação COBOL.

Técnica de Balance Line

Vamos começar com o Balance Line, nossa primeira técnica. Vamos analisar um arquivo de funcionários em conjunto com um arquivo de projeto, procurando a relação que eles têm em comum.

| SAIDA | |--------|------|---------|-------| | IDFUNC | NOME | PROJETO | HORAS |

Nesse caso, o elemento em comum entre os dados é o ID. Precisamos identificar quais funcionários estão alocados e, a partir disso, gerar uma saída que informe o nome do funcionário, o projeto em que está alocado e a quantidade de horas dedicadas.

Por exemplo, Ana é a primeira a ter uma correspondência na relação. Carlos, por outro lado, não possui projeto alocado. Já Ana aparece novamente, agora vinculada ao projeto Banco. Em seguida, temos Paulo, que também está no projeto Banco, com 200 horas. Além disso, Paulo está alocado em outro projeto, o Loja. Por fim, temos Rosana, que está no projeto Drex, com 350 horas.

O balance line consiste em cruzar esses dados, funcionando de maneira semelhante a um SELECT em um banco de dados relacional. Para que isso ocorra corretamente, precisamos definir regras específicas no programa, como critérios para movimentação e leitura dos dados. Essas regras garantirão que o processo funcione de forma estruturada e eficiente.

Criação de relatórios

Relatório é a transposição de dados em formato fixo, COBOL, em um arquivo de dados comum, ou em uma saída, em formato de relatório formatado. Temos títulos, páginas, dados, subtotais e total geral. Fazer a lógica de como ler, transformar, pular páginas e contabilizar subtotais é nossa proposta nos relatórios.

Exportação e importação de arquivos

Temos um arquivo COBOL e um arquivo CSV. A ideia é ler esse arquivo e devolvê-lo em um formato que possamos ler em outro ambiente. Pegamos um arquivo tradicional COBOL, separado fixo, e geramos um arquivo com delimitação de vírgula.

Da mesma forma, aprenderemos a pegar um arquivo que veio para nós como CSV e transformá-lo em um arquivo de layout fixo COBOL. Vamos exportar e importar.

Com isso, reunimos três técnicas interessantes para melhorar ainda mais nosso conhecimento em COBOL. Teremos muitos testes, processos de leitura, contabilização e pareamento de dados em balance line. Convidamos você a se juntar a nós e aprender as técnicas de programação em COBOL.

Entendendo Balance-Line - O que é Balance Line?

O primeiro assunto que abordaremos é chamado de Balance Line. Temos arquivos em COBOL que serão lidos pelo nosso programa. Em cada lado do arquivo, há informações, e a ideia é mesclar essas informações para gerar um terceiro arquivo com os dados encontrados tanto no primeiro quanto no segundo. Isso é o balanço, temos um arquivo que será lido e um segundo arquivo que será consultado. Havendo um encontro, fazemos uma saída, realizando um balanço entre os dois arquivos.

Arquivo de funcionários e projetos

Vamos analisar a teoria. Temos um arquivo chamado funcionários e um arquivo chamado projetos. Cada um deles possui uma sequência de dados. Não é necessário que os dados tenham o mesmo tamanho em termos de registros. A ideia do balanço não implica em igualar os tamanhos, mas sim em fazer a correlação entre os dois. Podemos perceber que o campo ID existe nas duas tabelas.

Esse campo ID é o nosso campo de relação, o ID do funcionário. Os demais são informações pertencentes apenas ao próprio arquivo, como o nome do profissional e a área ou stack em que trabalha. No arquivo de projetos, temos o projeto e a quantidade de horas dedicadas a por aquele profissional.

Por exemplo, Ana, com ID 2, está alocada no projeto ABB BANCO e dedica 150 horas. Paulo está em dois projetos, Rosana também, enquanto João e Carlos não estão em nenhum. Essa relação entre os arquivos nos lembra um pouco o Select do DB2, e é o que chamamos de balanço entre os dois.

Regras para criar um Balance Line funcional

Existem algumas regras obrigatórias para criar um balance line funcional. Primeiramente, os arquivos precisam estar indexados ou classificados pela chave, como 1, 2, 3, 4, 5. Se não estiverem classificados, toda a lógica será comprometida. Provavelmente, receberemos o arquivo já classificado, mas, caso contrário, será necessário classificá-los. Existem várias opções para isso.

Após garantir que os arquivos estão classificados, precisamos lê-los. Devemos fazer um Open em ambos e ler pelo menos a primeira linha de cada um. O ponteiro ficará na primeira linha de cada arquivo. Terminamos o balanço quando ambos chegarem ao final. Mesmo que um termine antes, o outro deve continuar, pois podemos ter mais funcionários do que projetos ou mais alocações de projetos do que funcionários. Por exemplo, três funcionários podem estar alocados em seis projetos, com cada um em dois projetos. Portanto, precisamos ler ambos os arquivos até o final.

Lógica do Balance Line

A primeira lógica é a seguinte, se a chave do funcionário for menor que a do projeto, avançamos um no arquivo de funcionários e não fazemos nada no de projetos. Quando lemos o próximo funcionário e a chave não se encaixa na regra anterior, verificamos a segunda regra. Se a chave do funcionário for igual à do projeto, gravamos essa saída. Por exemplo, gravamos o ID 2, o projeto APP BANCO e a quantidade de horas, 150, no arquivo de saída.

Queremos o id, o projeto e as horas. Se quisermos o nome do funcionário, podemos adicionar mais uma coluna. Assim, nossa saída será a composição dessas chaves.

Ao gravar, avançamos mais um passo e verificamos constantemente se chegamos ao final. Em algum momento, isso ocorrerá. As três regras são menores, então, na primeira ocorrência, avançamos; na segunda ocorrência, era igual, e pode ser que não tenhamos o projeto. O projeto pode não ter o funcionário, o que seria uma exceção. Pode ser que o funcionário não tenha o projeto, o que também seria uma exceção. Temos uma regra para essa exceção.

Na terceira interação, estamos percorrendo o loop, paramos no 3 e no 2. Estamos pedindo para avançar no projeto 3. Quando caímos nas validações, o funcionário volta a ser menor que o projeto. Avançamos no funcionário e igualamos. Rodamos o loop, igualamos, e ele é igual. Então, gravamos que é o funcionário 3, o projeto é o APP BANCO, e temos 200 horas.

Rodamos o loop novamente e comparamos. A chave 3 é igual a 3, então não avançamos em nada, continuamos parados. Gravamos o funcionário 3, no APP LOJA, 120 horas e avançamos.

Nunca avançamos em ambas as tabelas, é uma ou outra. Quando o loop roda, ele verifica que é menor e avançamos. Gravamos o funcionário 4, PIX-DREX com 350 horas.

Finalização do Balance Line

Quando gravamos e avançamos, chegamos ao final. Quando isso acontece, movemos um valor alto. High Value é uma expressão do COBOL que move o maior valor possível. Não poderíamos mover 999? 999 seria o mais alto valor de 3 dígitos, mas podemos ter um funcionário 999 e um projeto 999. Então, não é adequado. O High Value é um valor hexadecimal, ou seja, FFF. É um valor que coloca na variável um valor que ninguém superará e que não é numérico. Se quisermos colocar um valor muito baixo, usamos Low Value.

Colocamos um High Value, o maior valor possível. A partir de agora, nunca será igual. Sempre o funcionário será menor. Quando comparamos o 5 com o ID do funcionário, o funcionário tem um valor muito alto. O 5 é menor. Se tivéssemos mais um funcionário, ele também seria menor. Quando chegarmos ao final do arquivo, ambos serão High Values. Ambos terão chegado ao final do arquivo, e nosso Balance Line terminará.

Resumo e próximos passos

A ideia é ler as duas chaves, classificar o arquivo nessa ordem e iniciar um loop no programa. Primeiro, realizamos uma leitura inicial de ambos os arquivos, carregamos os dados e iniciamos o processo de repetição. A cada iteração, comparamos os valores: se uma chave for menor que a outra, avançamos no arquivo correspondente; se forem iguais, gravamos os dados e seguimos adiante. Esse processo se repete dos dois lados até chegarmos ao final.

Esse é o conceito do Balance Line, onde a leitura de um arquivo impulsiona o avanço do outro, garantindo que os registros sejam processados de forma ordenada. Por isso, a elipse A está indexada, sem essa organização, os dados não se alinham corretamente e podem ser perdidos. A leitura inicial é fundamental para definir as chaves e garantir a consistência do processo.

Agora, vamos colocar isso em prática e, no próximo vídeo, aprender como implementar essa lógica em um programa COBOL.

Entendendo Balance-Line - Estruturando o programa

Chegou o momento de colocarmos a mão na massa. Já deixamos em nossa máquina uma pasta chamada "Curso_Cobol", que contém a base do programa do Balance Line. Também criamos previamente a pasta "BIN", onde ficarão os executáveis. Sempre que compilarmos, o executável será direcionado para ela, além da pasta "DADOS". Você pode fazer o download desse material na atividade do curso.

Duas informações importantes: a extensão que utilizamos é Cobol, da BitLang, é recomendável que você também tenha. Além disso, o compilador Cobol que estamos utilizando pode ser baixado nas atividades, caso ainda tenha.

Estrutura do programa Cobol

No início do código, temos três arquivos apontados: FUNC, PROJETO e RELAT, que será o arquivo de saída. Vamos realizar o balance do funcionário com o projeto. Se o funcionário tiver projeto, ele será gravado, caso contrário, passamos para o próximo. O balanço será registrado. Sempre que um funcionário tiver projeto, ele será exportado.

//Código omitido

INPUT-OUTPUT SECTION.
       FILE-CONTROL.
           SELECT ARQ-FUNC ASSIGN TO '..\DADOS\FUNC.TXT'
           FILE STATUS IS FS-FUNC.

           SELECT ARQ-PROJETO ASSIGN TO '..\DADOS\PROJETO.TXT'
           FILE STATUS IS FS-PROJETO.

           SELECT ARQ-RELAT ASSIGN TO '..\DADOS\RELAT.TXT'
           FILE STATUS IS FS-RELAT
           ORGANIZATION IS LINE SEQUENTIAL.

O arquivo de funcionários será processado em input sequencial, assim como o de projetos. Já o relatório será gravado de forma sequencial, mas no formato line sequential.

O arquivo de funcionários está estruturado como line sequential, ou seja, sem quebras de linha explícitas. Em breve, veremos seu layout, mas, ao codificar, receberemos os dados nesse formato contínuo. É importante não quebrar o arquivo linha por linha manualmente, pois isso pode inserir caracteres indesejados que comprometerão a leitura. O mesmo princípio se aplica ao arquivo de projetos, que também é tratado como sequencial.

Estrutura dos arquivos

Os arquivos de funcionário e projeto estão disponíveis, e o relatório é uma consequência. A estrutura do arquivo de funcionário é a seguinte: três caracteres para o código, 20 para o nome e 10 para a stack. O projeto possui três caracteres, 20 para o nome do projeto e três para a quantidade de horas. O tamanho total do arquivo de funcionário é 26, e o do projeto é 33.

O que importa é o relatório, que terá um layout de 46 posições. Podemos combinar, por exemplo, o nome e o projeto, que ocupam 20 cada, totalizando 40, além da chave e da quantidade de horas. Planejamos colocar na saída a chave e o nome, que somam 23, o projeto, que soma 43, e as horas, que completam 46.

Vamos definir a estrutura dos arquivos na seção de arquivos:

       FILE SECTION.
       FD ARQ-FUNC.
       01 REG-FUNC.
          05 FD-CHAVE-FUNC        PIC 9(03).
          05 FD-NOME-FUNC         PIC X(20).
          05 FD-STACK             PIC X(10).

       FD ARQ-PROJETO.
       01 REG-PROJETO.
          05 FD-CHAVE-PROJETO     PIC 9(03).
          05 FD-PROJ-PROJETO      PIC X(20).
          05 FD-QTHORAS-PROJETO   PIC 9(03).

       FD ARQ-RELAT.
       01 REG-RELAT.
          05 FD-RELAT             PIC X(46).

Variáveis de status e estrutura básica

A chave do projeto não será necessária, pois é a mesma. Temos duas variáveis de status e aqui a lógica básica: iniciar, processar e finalizar. Vamos substituir o STOPRUN para GOBACK. É fundamental acostumar-se a utilizar o GOBACK para tornar o programa mais modular. Mesmo que um programa não seja originalmente um executável, ele pode ser tratado como tal, desde que esteja estruturado corretamente.

Imagine que esse executável seja chamado por outro programa. Nesse caso, ao retornar, ele não interrompe o fluxo geral do processo. No entanto, se utilizarmos GOBACK nesse ponto, toda a sequência será interrompida, garantindo um controle mais preciso sobre a execução.

A abertura e o fechamento dos três arquivos são fundamentais. Depois, é importante realizar o tratamento para verificar se foram abertos e fechados corretamente. Essa é a base do código do relatório.

       WORKING-STORAGE SECTION.
       01 FS-FUNC                 PIC 99 VALUE ZEROS.
       01 FS-PROJETO              PIC 99 VALUE ZEROS.
       01 FS-RELAT                PIC 99 VALUE ZEROS.

       PROCEDURE DIVISION.
       000-PRINCIPAL SECTION.
       001-PRINCIPAL.
           PERFORM 100-INICIAR.
           PERFORM 200-PROCESSAR.
           PERFORM 300-FINALIZAR.
           STOP RUN.

Segundo nosso checklist, havia três aspectos a considerar. O primeiro era verificar se os arquivos estavam em ordem. Para isso, conferimos os arquivos de dados e sim, todos seguem a sequência correta. O mesmo ocorre com o arquivo de projeto, que também está em ordem. Com isso, podemos concluir que ambos estão organizados corretamente.

Vamos implementar a abertura dos arquivos:

       100-INICIAR SECTION.
           OPEN INPUT ARQ-FUNC.
           OPEN INPUT ARQ-PROJETO.
           OPEN OUTPUT ARQ-RELAT.

Em segundo lugar, precisamos ler as duas primeiras chaves. Por isso, é importante verificar se o arquivo foi aberto corretamente e se não está vazio. Vamos considerar, no nosso caso, que há dados. Vamos ler o arquivo de funcionários e o arquivo de projetos. Após a leitura dos dois, no processo, exibiremos o que foi lido. Exibiremos o funcionário e a chave correspondente. A chave está no campo FD, chave, func. Apenas isso. Faremos o mesmo para o projeto, exibindo a chave do projeto.

//Código omitido

           READ ARQ-FUNC.
           READ ARQ-PROJETO.
                     
        200-PROCESSAR SECTION
        
                DISPLAY "FUNC " FD-CHAVE-FUNC.
                DISPLAY "PROJETO" FD-CHAVE-PROJETO.
                
//Código omitido

Dessa forma, no início, faremos a abertura e a primeira leitura. Para iniciar, o balance line deve começar com as duas chaves lidas. Se os arquivos estiverem vazios, o balance não será executado. É necessário ter algo em ambos, pelo menos uma informação em cada. Caso contrário, não faz sentido.

Após o início, passamos para o processamento, onde as chaves são exibidas, e então fechamos. Isso já é suficiente para resolver os dois primeiros itens do checklist. Primeiro, verificamos se estão classificados, e depois, a leitura para igualar as chaves.

Abrimos o terminal e passamos o comando abaixo:

cob -x -x bin\BALANCE.EXE BALANCE.COB

Pressionamos "Enter" e abrimos o prompt de comando para verificar o resultado. Estamos na pasta "BIN". Vamos verificar o BALANCE. Ao fazer isso, não nos devolve as chaves. Isso acontece, pois não havíamos salvado. Então, fazemos isso e repetimos o processo. Assim, temos o retorno abaixo:

FUNC 001

PROJETO 002

Foi feita a leitura dos arquivos e igualou as chaves. Percebemos que nossa primeira regra, que será discutida no próximo vídeo, está no menor. É o less, o funcionário é menor que o projeto. Mas isso é assunto para o próximo vídeo. Até lá!

Sobre o curso Cobol: manipulando e formatando dados

O curso Cobol: manipulando e formatando dados possui 146 minutos de vídeos, em um total de 39 atividades. Gostou? Conheça nossos outros cursos de em Programação, ou leia nossos artigos de Programação.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Entendendo Balance Line
• Relatório
• Finalizando relatório
• Gravação e leitura de CSV