☕ Um Café no Bellacosa Mainframe
Gostou do conteúdo? Ajude a manter o café quente, o COBOL compilando e o mainframe acordado. 😄
☕ Pague um café ao Bellacosa

Translate

Mostrar mensagens com a etiqueta DL/I. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta DL/I. Mostrar todas as mensagens

quinta-feira, 28 de maio de 2026

☕🔥💣 LABORATÓRIO IMS DL/I: CRIANDO UM BANCO HIERÁRQUICO NA PRÁTICA

 

Bellacosa Mainframe lahoratorio pratico de ims dl/i crie seu banco de dados hierarquico

☕🔥💣 LABORATÓRIO IMS DL/I: CRIANDO UM BANCO HIERÁRQUICO NA PRÁTICA

Como construir um banco IMS para CURSOS, ALUNOS e NOTAS — passo a passo para programadores COBOL iniciantes

Se você veio do mundo:

  • DB2

  • Oracle

  • SQL Server

  • MySQL

prepare-se.

Porque no IMS o mundo funciona de maneira MUITO diferente. 😄

Aqui não existem:

❌ tabelas tradicionais
❌ SELECT com JOIN
❌ modelagem relacional clássica

No IMS nós pensamos em:

🌳 HIERARQUIA

E quando você entende isso…

o “dinossauro” começa a fazer sentido.


🚀 Objetivo do Laboratório

Vamos criar um banco IMS para armazenar:

  • cursos

  • alunos

  • notas

Nossa estrutura será:

CURSO
 └── ALUNO
      └── NOTA

Exemplo:

COBOL
 └── JOAO
      └── 9.5

🌳 Entendendo a Hierarquia

No IMS existe:

TipoFunção
ROOTtopo da árvore
CHILDfilho
DEPENDENTdependente

No nosso caso:

SegmentoTipo
CURSOROOT
ALUNOCHILD
NOTACHILD do ALUNO

💾 Estrutura Física Mental

Fisicamente o IMS gravará algo parecido com:

CURSO
   ↓ ponteiro
ALUNO
   ↓ ponteiro
NOTA

O IMS literalmente conecta segmentos usando ponteiros físicos.


☕ Etapa 1 — Criando o DBD

O:

DBD

(Database Description)

define a estrutura do banco.


📦 DBD Básico

DBD   NAME=ESCOLA,ACCESS=HIDAM

DATASET DD1=ESCOLADB

SEGM  NAME=CURSO,BYTES=50,PARENT=0
FIELD NAME=(CODCURSO,SEQ,U),BYTES=5,START=1

SEGM  NAME=ALUNO,BYTES=80,PARENT=CURSO
FIELD NAME=(MATRIC,SEQ,U),BYTES=6,START=1

SEGM  NAME=NOTA,BYTES=20,PARENT=ALUNO
FIELD NAME=(IDNOTA,SEQ,U),BYTES=4,START=1

DBDGEN
FINISH
END

🧠 O Que Está Acontecendo?


🌳 CURSO

Segmento ROOT.

Topo da árvore.


👨‍🎓 ALUNO

Filho de CURSO.


📊 NOTA

Filho de ALUNO.


🚀 ACCESS=HIDAM

Define tipo do banco.

HIDAM:

✅ rápido
✅ indexado
✅ muito usado em IMS clássico


☕ Etapa 2 — Gerando o DBD

Agora precisamos gerar o banco.

Usamos JCL.


📜 JCL DBDGEN

//DBDGEN EXEC PGM=ASMA90
//SYSIN DD *
  DBD ...
/*

Depois fazemos:

DBDGEN

para criar o módulo do banco.


🚀 Etapa 3 — Criando o PSB

O:

PSB

(Program Specification Block)

define como programas acessam o banco.


📦 Exemplo PSB

PSBGEN  PSBNAME=PSBESC

PCB     TYPE=DB,DBDNAME=ESCOLA,PROCOPT=G

SENSEG  NAME=CURSO
SENSEG  NAME=ALUNO,PARENT=CURSO
SENSEG  NAME=NOTA,PARENT=ALUNO

END

🧠 PROCOPT=G

Permite:

GET

Somente leitura.

Depois podemos usar:

PROCOPTFunção
Gread
Aall
Iinsert
Ddelete

☕ Etapa 4 — ACBGEN

Depois geramos:

ACB

O famoso:

Application Control Block

📜 JCL ACBGEN

//ACBGEN EXEC PGM=DFSRRC00

🚀 Etapa 5 — Inicializando Banco

Criamos datasets IMS.

Normalmente usando:

  • IDCAMS

  • VSAM

  • utilities IMS


📦 Exemplo IDCAMS

//IDCAMS EXEC PGM=IDCAMS

 DEFINE CLUSTER -
 (NAME(ESCOLADB))

☕ Etapa 6 — Inserindo Dados

Agora vem a parte divertida. 😄


👨‍💻 Programa COBOL IMS

CALL 'CBLTDLI'
     USING 'ISRT'
           DB-PCB
           CURSO-AREA

🌳 ISRT

Significa:

INSERT SEGMENT


📦 Inserindo CURSO

CURSO = COBOL

👨‍🎓 Inserindo ALUNO

Depois navegamos:

CURSO → ALUNO

📊 Inserindo NOTA

Depois:

ALUNO → NOTA

🚀 Estrutura Final

COBOL
 └── JOAO
      └── 9.5

COBOL
 └── MARIA
      └── 8.7

☕ Etapa 7 — Consultando Dados

Agora usamos:

GU

(Get Unique)


📦 Exemplo

CALL 'CBLTDLI'
     USING 'GU  '
           DB-PCB
           AREA
           SSA.

🔑 SSA

Segment Search Argument.

Exemplo:

CURSO(CODCURSO=COBOL)

🚀 Navegando Pela Árvore

Agora usamos:

ComandoFunção
GUbusca específica
GNpróximo
GNPpróximo filho

🌳 Exemplo Navegação

GU CURSO
GN ALUNO
GNP NOTA

☕ Etapa 8 — Atualizando Nota

Usamos:

REPL

(Replace)


📦 Fluxo

1️⃣ GU NOTA
2️⃣ altera AREA
3️⃣ REPL

☕ Etapa 9 — Deletando Registro

Usamos:

DLET


📦 Exemplo

CALL 'CBLTDLI'
     USING 'DLET'
           DB-PCB

🚀 O Que o Programador Junior Precisa Entender

No IMS:

⚡ você NÃO pensa em tabela.

Você pensa em:

✅ árvore
✅ caminho
✅ navegação
✅ pai-filho
✅ segmentos


⚔️ Diferença Mental DB2 vs IMS


🟦 DB2

Você pergunta:

SELECT *

🌳 IMS

Você navega:

ROOT → CHILD → CHILD

☕ Curiosidade Bellacosa Mainframe

O IMS nasceu em:

🚀 1968

para ajudar a NASA no projeto Apollo.

Décadas depois…

a mesma lógica hierárquica ainda processa:

💳 cartões
🏦 bancos
📱 mobile banking
✈️ companhias aéreas
📡 telecom

O “dinossauro” continua vivo.

E absurdamente rápido.


☕🔥 DLI IMS AVANÇADO: O LADO SOMBRIO DO MAINFRAME QUE O SQL NUNCA CONSEGUIU SUBSTITUIR

 

Bellacosa Mainframe e o DL/I IMS o painel de controle dentro do banco de dados hierarquico

☕🔥 DLI IMS AVANÇADO: O LADO SOMBRIO DO MAINFRAME QUE O SQL NUNCA CONSEGUIU SUBSTITUIR

Durante décadas o mercado tentou decretar a morte do IMS.

Vieram os bancos relacionais.

Vieram os ERPs.

Vieram os clusters distribuídos.

Vieram NoSQL, cloud, Kubernetes, microservices e a eterna promessa de que “agora o mainframe acabou”.

Mas existe um pequeno detalhe inconveniente:

Enquanto muita tecnologia moderna ainda luta para entregar estabilidade em escala planetária…

o velho IMS continua processando bilhões de transações críticas diariamente com tempos de resposta absurdos.

E quem realmente conhece DL/I avançado sabe de uma verdade quase proibida no mundo corporativo:

Existem workloads onde o IMS simplesmente continua imbatível.

Não por nostalgia.

Não por legado.

Mas por engenharia brutalmente eficiente.


🌳 DL/I — O Anti-SQL

O SQL venceu o mundo porque trouxe abstração.

O DL/I sobreviveu porque eliminou abstração.

Essa diferença muda tudo.

No SQL o banco precisa descobrir:

  • caminho de acesso

  • plano de execução

  • índice

  • optimizer

  • cardinalidade

  • join strategy

No DL/I:

o programador já sabe exatamente onde quer chegar.

O acesso é navegacional.

Direto.

Hierárquico.

Cirúrgico.

Enquanto o SQL pergunta:

“O que você deseja?”

o DL/I pergunta:

“Você sabe navegar?”

E essa pergunta separa operadores de aventureiros.


⚡ O Verdadeiro Poder do Posicionamento

Muitos programadores COBOL juniores enxergam:

CALL 'CBLTDLI'

como apenas uma API antiga.

Veteranos enxergam outra coisa:

Controle absoluto do path físico.

No IMS avançado, posicionamento é tudo.

O estado corrente do PCB literalmente define o universo de navegação da aplicação.

Quando um programa executa:

GU ROOT
GNP CHILD
GNP CHILD
GN NEXT ROOT

ele não está apenas lendo registros.

Ele está percorrendo estruturas físicas reais de armazenamento.

O IMS não pensa em linhas.

Ele pensa em:

  • segmentos

  • paths

  • dependência hierárquica

  • posicionamento lógico

  • ponteiros físicos

E isso muda completamente a mentalidade de desenvolvimento.


💾 O Segredo Físico Que Pouca Gente Entende

O maior erro de quem vem do SQL é imaginar que o IMS seja apenas “um banco hierárquico”.

Não.

O IMS é um modelo de acesso físico extremamente otimizado.

A verdadeira mágica está nos ponteiros.

Em bancos HIDAM, HDAM e DEDB, o IMS reduz drasticamente o custo de navegação usando estruturas físicas extremamente agressivas para a época.

Enquanto bancos relacionais modernos frequentemente precisam montar planos complexos de execução…

o IMS muitas vezes apenas segue ponteiros previamente organizados.

É quase obsceno de tão eficiente.

Especialmente em workloads previsíveis.


🚀 HDAM — Quando Hashing Vira Arte Negra

Veteranos IMS sabem que HDAM não é apenas “acesso direto”.

HDAM é uma filosofia.

A randomizing routine define praticamente o comportamento físico do banco.

E aqui mora um dos pontos mais subestimados do universo mainframe:

O programador IMS influenciava diretamente o layout físico da informação.

Não existia o conforto moderno do:

“deixa o banco resolver.”

No IMS avançado:

você é parcialmente responsável pelo desempenho físico do sistema.

E isso assusta desenvolvedores modernos acostumados com abstração total.


🌳 Parentage — O Peso da Hierarquia

No mundo relacional:

JOIN resolve quase tudo.

No IMS:

hierarquia mal desenhada vira pesadelo operacional.

Veteranos conhecem a dor de:

  • logical relationships

  • secondary indexing

  • twin chains

  • parentage explosion

  • reorgs monstruosos

Porque o IMS premia modelos previsíveis.

Mas pune violentamente modelagens ruins.

Um DBD mal desenhado pode condenar décadas de manutenção.

E muitos sistemas bancários ainda carregam decisões arquiteturais feitas nos anos 70.


☠️ O Trauma Coletivo Chamado REORG

Se existe uma entidade mitológica no mundo IMS…

ela se chama:

REORG

Quem nunca passou madrugada acompanhando:

  • unload

  • reload

  • image copy

  • prefix resolution

  • pointer rebuild

  • HD reorganization

ainda não conheceu o verdadeiro lado operacional do IMS.

Porque diferente do mundo SQL moderno, no IMS o layout físico importa absurdamente.

Overflow chains crescem.

Ponteiros degradam.

Randomizers envelhecem mal.

E eventualmente o banco precisa ser reorganizado.

O problema?

Alguns ambientes IMS possuem dezenas de TB e bilhões de segmentos.

Reorganizar isso não é “maintenance window”.

É engenharia de guerra.


🔥 Fast Path — O Monstro Sagrado

Quando alguém menciona:

DEDB Fast Path

os veteranos imediatamente entendem que a conversa ficou séria.

Porque Fast Path não foi criado para conveniência.

Foi criado para TPS brutal.

A ideia era simples:

reduzir ainda mais overhead.

Menos logging.

Menos locking.

Menos complexidade.

Mais velocidade.

E mesmo hoje o desempenho de certos ambientes Fast Path continua assustador.

Especialmente em telecom e financial switching.


⚔️ IMS vs DB2 — A Guerra Que Nunca Acabou

O mercado gosta de tratar IMS e DB2 como concorrentes.

Veteranos sabem que isso é ingenuidade.

Os maiores ambientes do planeta usam:

IMS + DB2

ao mesmo tempo.

Porque cada um resolve problemas diferentes.

DB2 entrega:

  • flexibilidade

  • SQL

  • analytics

  • BI

  • consultas ad-hoc

IMS entrega:

  • TPS monstruoso

  • previsibilidade

  • latência mínima

  • throughput absurdo

O DB2 é um cérebro analítico.

O IMS é um sistema nervoso autônomo.


🧠 O Que os Novatos Não Percebem

A maioria dos desenvolvedores modernos nunca precisou pensar em:

  • CI split

  • root anchor points

  • segment occurrence

  • PCB sensitivity

  • path call optimization

  • SSA qualification

  • PROCOPT impact

Mas no IMS avançado esses detalhes definem:

  • performance

  • lock contention

  • response time

  • CPU consumption

  • operational scalability

E é justamente isso que torna o IMS tão fascinante.

Ele exige que o desenvolvedor compreenda a máquina.


☕ Easter Egg Mainframe

Existe uma velha piada entre sysprogs veteranos:

“SQL é para perguntar.
DL/I é para saber.”

😄

E honestamente…

existe uma certa verdade cruel nisso.


🌐 IMS Moderno — O Dinossauro Virou API

Talvez o aspecto mais surreal do IMS moderno seja este:

Hoje APIs REST em JSON frequentemente terminam em:

CBLTDLI

Lá no fundo.

Aplicativos mobile modernos.

Pix.

Cartões.

Cloud híbrida.

OpenShift.

Tudo isso frequentemente desemboca em um banco hierárquico criado antes da internet existir.

É quase cyberpunk corporativo.


💣 O Grande Paradoxo do IMS

O IMS parece antigo porque ele é antigo.

Mas ao mesmo tempo ele continua incrivelmente moderno em alguns princípios fundamentais:

  • eficiência

  • previsibilidade

  • throughput

  • estabilidade

  • controle físico

  • otimização extrema

Enquanto o mundo moderno adicionou camadas infinitas de abstração…

o IMS permaneceu brutalmente próximo do hardware.

E talvez seja justamente por isso que ele ainda sobreviva.


🚀 O Dinossauro Que Continua Dominando

O mercado adora prever o fim do mainframe.

Mas existe um detalhe inconveniente:

Boa parte do sistema financeiro mundial ainda depende dele.

E dentro desse ecossistema…

o IMS continua sendo uma das peças mais resilientes já criadas pela engenharia de software corporativa.

Talvez porque no final das contas:

moda tecnológica muda.

Mas performance real em missão crítica continua rara.

E o velho DL/I ainda sabe exatamente onde os dados estão.

quarta-feira, 27 de maio de 2026

☕🚀 IMS: O DINOSSAURO IMORTAL QUE AINDA MOVE O MUNDO

 

Bellacosa Mainframe apresenta o banco de dados hieraquico ISM

☕🚀 IMS: O DINOSSAURO IMORTAL QUE AINDA MOVE O MUNDO

A incrível história do sistema criado na era Apollo que continua processando bilhões de transações todos os dias

Se você é um programador COBOL júnior e começou recentemente a ouvir palavras como IMS, DL/I, PCB, PSB ou GU, talvez tenha pensado:

“Meu Deus… isso parece tecnologia alienígena dos anos 70.”

E sinceramente?

Você não está totalmente errado. 😄

O IMS é uma das tecnologias mais antigas ainda em operação no planeta. Mas existe um detalhe importante:

Ele também é uma das mais resilientes, rápidas e lucrativas da história da computação corporativa.

Enquanto centenas de tecnologias desapareceram, o IMS sobreviveu.

E não apenas sobreviveu.

Ele continua processando:

  • cartões de crédito

  • ATM bancário

  • sistemas de companhias aéreas

  • seguros

  • telecom

  • operações financeiras globais

em volumes absurdos.

Sim… existe uma chance enorme de você já ter usado IMS hoje sem perceber.


🌕 A Origem do IMS — NASA, Apollo e o Homem na Lua

O IMS nasceu em 1968.

Naquela época, a IBM e a Rockwell trabalhavam no projeto Apollo da NASA.

O problema era gigantesco.

A NASA precisava controlar milhares de componentes do foguete Saturn V:

  • peças

  • logística

  • engenharia

  • rastreamento

  • montagem

E os bancos de dados tradicionais da época simplesmente não conseguiam entregar a performance necessária.

Então nasceu o IMS:

Information Management System

Inicialmente criado para gerenciamento hierárquico de informações críticas do projeto Apollo.

Ou seja:

Existe uma ligação histórica real entre o IMS e a corrida espacial.

☕ Easter Egg Mainframe:

Muita gente brinca dizendo:

“O homem chegou à Lua graças ao COBOL, ao mainframe e ao café.”

E honestamente… não é tão exagerado assim.


🌳 O Grande Diferencial do IMS

Diferente do DB2 ou Oracle, o IMS NÃO é relacional.

Ele trabalha com:

Banco de dados hierárquico

Imagine uma árvore:

CLIENTE
 └── CONTA
      └── CARTAO
           └── MOVIMENTO

No IMS os dados possuem:

  • pai

  • filho

  • caminho de navegação

Isso deixa o acesso extremamente rápido.

Enquanto um banco relacional precisa pensar em:

  • JOIN

  • optimizer

  • plano de acesso

  • estatísticas

o IMS normalmente já sabe exatamente onde navegar.

É quase como um labirinto secreto onde o programa já conhece o caminho.


⚡ Por Que o IMS é Tão Rápido?

Porque ele foi criado numa época brutalmente limitada.

Nos anos 60 e 70:

  • CPU era caríssima

  • disco era lento

  • memória era minúscula

Então a IBM projetou o IMS para minimizar ao máximo o número de acessos físicos ao disco.

O resultado?

Uma arquitetura extremamente otimizada.

O IMS utiliza:

  • ponteiros físicos

  • navegação direta

  • acesso hierárquico

  • estruturas previsíveis

Em vez de perguntar:

“Como encontrar o dado?”

o IMS trabalha com:

“Eu já sei exatamente onde ele está.”


💾 Como os Dados São Gravados Fisicamente?

Aqui entra uma das partes mais fascinantes do IMS.

Fisicamente os dados normalmente são armazenados em datasets z/OS usando:

  • VSAM

  • OSAM

Mas o IMS NÃO grava tabelas como um banco relacional.

Ele grava:

Segmentos hierárquicos

Exemplo:

CLIENTE
   ↓ ponteiro físico
CONTA
   ↓ ponteiro físico
MOVIMENTO

Os segmentos ficam ligados fisicamente por ponteiros internos.

Isso permite uma navegação extremamente rápida entre os registros.

É quase como se o banco tivesse túneis secretos ligando os dados.


🧠 O Que é DL/I?

Se existe um coração no IMS…

Esse coração é o:

DL/I — Data Language One

O DL/I é a interface usada pelos programas COBOL para conversar com o IMS.

No DB2 usamos:

SELECT
INSERT
UPDATE
DELETE

No IMS usamos comandos como:

  • GU

  • GN

  • GNP

  • ISRT

  • REPL

  • DLET

Tudo via:

CALL 'CBLTDLI'

Ou seja:

O programa COBOL literalmente navega pela árvore do banco.


👨‍💻 Exemplo Simples de Acesso IMS

Imagine que queremos localizar um cliente.

A chamada clássica seria:

CALL 'CBLTDLI'
     USING 'GU  '
           DB-PCB
           CLIENTE-AREA
           CLIENTE-SSA.

O comando:

GU

significa:

Get Unique

O IMS então:

  1. usa o índice

  2. localiza o segmento

  3. posiciona o ponteiro

  4. devolve o registro

Tudo absurdamente rápido.


🔑 PCB, PSB e SSA — As Siglas Misteriosas

Quando alguém começa IMS pela primeira vez, parece que caiu num filme cyberpunk dos anos 70.

As siglas assustam.

Mas a lógica é simples.

PCB

Program Communication Block

Define o acesso ao banco.

PSB

Program Specification Block

Define quais bancos e PCBs o programa pode usar.

SSA

Segment Search Argument

É quase um “WHERE” do IMS.

Exemplo:

CLIENTE(COD=00001)

📜 IMS e JCL

No mundo IMS, o JCL também ganha superpoderes.

Um programa batch IMS normalmente roda com:

//STEP01 EXEC PGM=DFSRRC00,
// PARM='DLI,PROGIMS,PSBTEST'

O famoso:

DFSRRC00

é praticamente o “portal mágico” do batch IMS.

☕ Curiosidade Bellacosa Mainframe:

Quando um iniciante vê um JCL IMS pela primeira vez, normalmente reage assim:

“Isso é um JCL… ou um ritual arcano da IBM?”

😄


⚔️ IMS vs DB2

Essa é uma guerra clássica.

O IMS possui:

✅ performance monstruosa
✅ baixo overhead
✅ TPS absurdamente alto

Mas o DB2 possui:

✅ SQL flexível
✅ analytics
✅ joins
✅ consultas ad-hoc

Por isso muitos bancos usam:

IMS + DB2 juntos

IMS processa o core transacional.

DB2 faz relatórios e analytics.

É como:

IMS = motor Fórmula 1
DB2 = cérebro analítico

🤖 IMS Moderno — Sim, Ele Continua Evoluindo

Muita gente pensa que IMS ficou preso nos anos 70.

Errado.

Hoje o IMS conversa com:

  • APIs REST

  • JSON

  • Java

  • OpenShift

  • Cloud híbrida

  • Mobile banking

  • z/OS Connect

Ou seja:

Seu aplicativo de banco no celular pode estar conversando com um software criado há mais de 50 anos.

Isso é simplesmente absurdo.

E incrível.


💼 Vale a Pena Aprender IMS?

Para um programador COBOL júnior?

SIM. MUITO.

Porque existem poucos especialistas.

E muitos profissionais IMS estão se aposentando.

O mercado procura gente que entenda:

  • COBOL

  • IMS

  • JCL

  • VSAM

  • CICS

  • DB2

Essa combinação continua extremamente valorizada.

Especialmente em:

  • bancos

  • seguradoras

  • telecom

  • aviação

  • governo


☕ O Dinossauro Que Nunca Morreu

O IMS é um paradoxo fascinante.

Ele nasceu antes da internet moderna.

Antes do Windows.

Antes do Linux.

Antes do SQL dominar o mundo.

E mesmo assim continua vivo.

Mais do que vivo.

Continua movimentando bilhões de dólares diariamente.

Porque no fim das contas, empresas gigantes não querem apenas “tecnologia nova”.

Elas querem:

  • estabilidade

  • velocidade

  • segurança

  • confiabilidade

E nisso o IMS ainda é um verdadeiro monstro.

Ou como muita gente brinca no mundo mainframe:

“Tecnologia antiga não significa tecnologia ultrapassada.”

Especialmente quando ela ainda move o planeta.

domingo, 26 de outubro de 2025

☕🔥💣 IMS DL/I É O VERDADEIRO NoSQL ORIGINAL?

 

Bellacosa Mainframe apresenta conceitos de DL/I em IMS

☕🔥💣 IMS DL/I É O VERDADEIRO NoSQL ORIGINAL?

O dinossauro do mainframe que já fazia navegação hierárquica décadas antes do Vale do Silício inventar o termo “NoSQL”

Existe uma ironia maravilhosa na história da computação.

Durante anos o mercado vendeu a ideia de que:

  • NoSQL era revolucionário

  • bancos hierárquicos eram ultrapassados

  • o futuro havia finalmente derrotado o legado

Então, em algum momento, muita gente percebeu uma coisa desconfortável:

O IMS já fazia várias dessas ideias nos anos 60.

Sim.

Décadas antes de MongoDB, Cassandra, DynamoDB ou Redis existirem…

o velho IMS já trabalhava com:

  • navegação hierárquica

  • acesso sem SQL

  • paths previsíveis

  • estruturas não relacionais

  • acesso ultrarrápido

  • escalabilidade absurda

E isso gera uma pergunta extremamente provocativa:

O IMS DL/I pode ser considerado um NoSQL?

A resposta curta é:

☕ Tecnicamente… SIM.

Mas com algumas nuances MUITO interessantes.


🌳 Antes do SQL Existia o Mundo Selvagem

Hoje quase todo desenvolvedor nasce dentro do universo SQL.

Tudo gira em torno de:

SELECT
INSERT
UPDATE
DELETE
JOIN

Mas antes da explosão dos bancos relacionais, o cenário era completamente diferente.

Existiam:

  • bancos hierárquicos

  • bancos em rede

  • ISAM

  • VSAM

  • estruturas proprietárias

E foi nesse ambiente que nasceu o IMS.

Em 1968.

Durante o projeto Apollo.

Ou seja:

o IMS surgiu ANTES do SQL dominar o planeta.


🚀 O Que Define um Banco NoSQL?

Essa é a chave da discussão.

NoSQL normalmente significa:

“Not Only SQL”

Ou seja:

bancos que NÃO dependem do modelo relacional tradicional.

Exemplos modernos:

  • MongoDB → documento

  • Cassandra → colunar distribuído

  • Redis → chave/valor

  • Neo4j → grafos

O ponto central é:

O modelo não-relacional.

E aqui o IMS entra com força brutal.


🌳 IMS NÃO é Relacional

O IMS trabalha com:

Estruturas hierárquicas

Exemplo:

CLIENTE
 └── CONTA
      └── CARTAO
           └── MOVIMENTO

Isso NÃO é uma tabela relacional.

Não existem JOINs naturais.

Não existe optimizer SQL clássico.

Não existe álgebra relacional.

O acesso ocorre via:

  • navegação

  • paths

  • ponteiros físicos

  • hierarquia

Exatamente como muitos NoSQL modernos.


⚡ DL/I — O Anti-SQL

Aqui está a maior diferença filosófica.

No SQL você diz:

“O que eu quero.”

O banco decide:

  • índice

  • plano

  • join

  • optimizer

No DL/I você diz:

“Como navegar.”

Exemplo clássico:

CALL 'CBLTDLI'
     USING 'GU  '
           PCB
           AREA
           SSA.

O programador controla explicitamente:

  • navegação

  • path

  • posição

  • contexto hierárquico

Isso é MUITO mais próximo de certos bancos NoSQL modernos do que muita gente imagina.


💾 O IMS Já Fazia “Document Thinking”

Observe a estrutura:

CLIENTE
 └── CONTA
      └── MOVIMENTO

Isso lembra MUITO:

  • documentos aninhados

  • árvores JSON

  • estruturas embedded

Exatamente o tipo de modelagem popularizada décadas depois por MongoDB.

A diferença?

O IMS fazia isso quando memória ainda era luxo.


🚀 Então o IMS Era um MongoDB dos Anos 60?

😄

Não exatamente.

Mas existe uma verdade desconfortável:

Muitos conceitos NoSQL modernos já existiam no IMS.

Especialmente:

  • hierarquia

  • navegação direta

  • ausência de JOIN

  • acesso por path

  • performance orientada ao modelo físico


⚔️ Onde o IMS Difere do NoSQL Moderno

Aqui entram diferenças importantes.


🌐 Distribuição

Muitos NoSQL modernos nasceram para:

  • cloud

  • clusters massivos

  • commodity servers

  • sharding horizontal

O IMS nasceu para:

Mainframe centralizado de missão crítica.


🧠 Consistência

Muitos NoSQL modernos sacrificam:

  • consistência forte

  • ACID completo

em troca de escalabilidade.

O IMS faz o contrário.

Ele foi criado para:

  • integridade brutal

  • transações críticas

  • confiabilidade absoluta

Ou seja:

O IMS é MUITO mais conservador.


🔥 O IMS é Quase “Pré-NoSQL”

Talvez a melhor definição seja:

O IMS é um ancestral direto do pensamento NoSQL.

Porque ele já trabalhava com:

✅ modelo não relacional
✅ paths previsíveis
✅ hierarquia
✅ performance orientada à estrutura
✅ ausência de JOIN pesado

Décadas antes do termo existir.


🌳 O Grande Segredo: O Modelo Físico

A maioria dos bancos modernos tenta esconder o armazenamento físico.

O IMS faz quase o oposto.

No IMS avançado:

  • HDAM

  • HIDAM

  • DEDB

  • randomizers

  • root anchor points

influenciam diretamente o comportamento do banco.

O programador IMS clássico precisava entender:

COMO O DADO EXISTE NO DISCO.

Isso é extremamente raro hoje.


⚡ Por Que o IMS Continua Tão Rápido?

Porque ele evita camadas gigantescas de abstração.

No SQL moderno:

consulta
 → optimizer
 → parser
 → planner
 → join engine
 → executor

No IMS:

path → ponteiro → segmento

Muito mais direto.

Muito mais previsível.

Muito mais brutal.


☕ Easter Egg Mainframe

Existe uma piada cruel no mundo IMS:

“MongoDB reinventou a árvore.
IMS já morava na floresta.”

😄

E honestamente?

Existe bastante verdade nisso.


🌳 IMS e JSON — O Paradoxo Moderno

Aqui a coisa fica quase cyberpunk.

Hoje muitos sistemas modernos fazem:

JSON → API REST → z/OS Connect → IMS DL/I

Ou seja:

Aplicações mobile modernas acabam alimentando um banco hierárquico criado antes da internet existir.

Isso é absurdamente fascinante.


🚀 O Que os Desenvolvedores Modernos Não Percebem

Muita gente olha o IMS e pensa:

“legado.”

Veteranos enxergam outra coisa:

Engenharia extrema.

Porque o IMS foi construído numa época onde:

  • CPU era escassa

  • disco era lento

  • memória era minúscula

Então a IBM precisou criar um sistema:

  • previsível

  • eficiente

  • econômico

  • extremamente otimizado

O resultado?

Uma arquitetura que continua competitiva em workloads específicos até hoje.


⚔️ O SQL Venceu… Mas Não Matou o IMS

O SQL venceu o mercado corporativo.

Isso é fato.

Mas ele NÃO substituiu totalmente o IMS.

Porque existem workloads onde:

  • previsibilidade

  • TPS

  • throughput

  • latência mínima

são mais importantes que flexibilidade.

Especialmente em:

  • bancos

  • telecom

  • ATM

  • autorização financeira

  • seguros


🌐 O Verdadeiro Paradoxo

O mercado moderno adora chamar IMS de “tecnologia antiga”.

Mas muitas arquiteturas modernas acabaram:

voltando para ideias que o IMS já utilizava.

Inclusive:

  • modelos não relacionais

  • acesso orientado a documento

  • estruturas hierárquicas

  • paths previsíveis

  • performance baseada no modelo físico

A história da computação é cheia dessas ironias.


💣 Então… IMS DL/I É NoSQL?

A resposta mais honesta seria:

SIM.

Mas um NoSQL ancestral.

Um NoSQL criado décadas antes do marketing inventar o termo.

O IMS não nasceu tentando ser moderno.

Ele nasceu tentando sobreviver às limitações brutais dos anos 60.

E talvez justamente por isso ele ainda exista.

Porque no final das contas:

modas tecnológicas mudam.

Mas sistemas que realmente entregam performance absurda em missão crítica raramente desaparecem.

E o velho DL/I continua navegando pela árvore como poucos sistemas modernos conseguem fazer.

sábado, 25 de outubro de 2025

☕🌳 BANCO HIERÁRQUICO: O DINOSSAURO DO MAINFRAME QUE AINDA MOVE BILHÕES

 

Bellacosa Mainframe introduz o Banco de Dados Hierarquico

☕🌳 BANCO HIERÁRQUICO: O DINOSSAURO DO MAINFRAME QUE AINDA MOVE BILHÕES

Entenda de forma simples como o IMS organiza dados como uma árvore gigante ultra rápida 🚀

Quando um programador COBOL júnior escuta:

🌳 “Banco Hierárquico”

normalmente imagina algo complicado, antigo e misterioso.

E sinceramente?

😄 O IMS realmente parece saído de um laboratório secreto da IBM dos anos 70.

Mas depois que você entende a lógica…

tudo começa a fazer MUITO sentido.


🧠 O Que é um Banco Hierárquico?

A ideia principal é simples:

📌 Os dados são organizados como uma árvore.

Exemplo:

CLIENTE
 └── CONTA
      └── CARTAO
           └── MOVIMENTO

Existe:

✅ pai
✅ filho
✅ relacionamento fixo

Igual uma árvore genealógica.


🌳 Pense Numa Árvore Real

Imagine:

TRONCO
 └── GALHO
      └── FOLHA

No IMS é parecido:

CLIENTE
 └── CONTA
      └── MOVIMENTO

Cada nível depende do anterior.


🚀 Diferença Para Banco Relacional

No DB2 ou Oracle:

SELECT * FROM CLIENTE

Tudo funciona via:

  • tabelas

  • joins

  • SQL


🌳 No Banco Hierárquico

Não existem joins clássicos.

Você:

⚡ navega pela árvore.


📦 Exemplo Real Bancário

Imagine um banco:

CLIENTE
 └── CONTA
      └── FATURA
           └── MOVIMENTO

O IMS entende naturalmente que:

✅ cliente possui conta
✅ conta possui fatura
✅ fatura possui movimentos


🧠 O Grande Segredo

No banco hierárquico:

📌 O caminho importa.

Você normalmente começa do topo:

CLIENTE

e vai descendo.


⚡ Por Que Isso é Tão Rápido?

Porque o IMS não precisa:

❌ montar JOIN complexo
❌ calcular relacionamento
❌ pensar demais

Ele já conhece o caminho.

É quase como:

seguir túneis secretos

entre os dados.


🌳 O IMS Usa Ponteiros

O IMS liga os segmentos com:

🔑 ponteiros físicos

Exemplo:

CLIENTE
   ↓
CONTA
   ↓
MOVIMENTO

Então o acesso é extremamente rápido.


💾 Segmentos

No IMS os registros são chamados de:

🟦 Segmentos

Exemplo:

SegmentoSignificado
CLIENTEregistro cliente
CONTAconta bancária
MOVIMENTOtransação

🚀 O Programa COBOL Navega

No IMS o COBOL não faz SQL.

Ele usa:

CALL 'CBLTDLI'

com comandos como:

ComandoFunção
GUbusca única
GNpróximo
GNPpróximo filho
ISRTinsert
REPLupdate
DLETdelete

🌳 Exemplo Mental

Imagine:

CLIENTE JOAO
 └── CONTA 123
      └── MOVIMENTO PIX

O programa faz:

1️⃣ encontra cliente
2️⃣ entra conta
3️⃣ lê movimentos

Tudo navegando pela árvore.


⚔️ Hierárquico vs Relacional

Banco HierárquicoBanco Relacional
árvoretabelas
navegaçãoSQL
pai/filhojoins
muito rápidoflexível
rígidodinâmico

💣 A Desvantagem

O banco hierárquico é MUITO rápido…

mas menos flexível.

Exemplo:

Se o banco foi desenhado assim:

CLIENTE
 └── CONTA

e amanhã você quiser acessar:

CONTA → CLIENTE

pode virar dor de cabeça.


🚀 Então Por Que Bancos Ainda Usam IMS?

Porque para sistemas críticos:

⚡ velocidade importa muito.

Especialmente em:

  • ATM

  • cartão

  • PIX

  • autorização financeira

  • telecom

  • aviação


☕ Curiosidade Bellacosa Mainframe

O IMS nasceu em:

🚀 1968

durante o projeto Apollo da NASA.

Sim.

O mesmo sistema que ajudou a organizar informações da corrida espacial…

continua hoje processando bilhões de transações financeiras.

Enquanto muita tecnologia moderna já morreu…

o “dinossauro” hierárquico continua vivo.

E extremamente rápido.


sexta-feira, 24 de outubro de 2025

☕🔥💣 IMS SYSTEM PROGRAMMER: O LADO BRUTAL DO MAINFRAME QUE SEGURA O MUNDO EM PÉ

 

Bellacosa Mainframe e o IMS System Programmer

☕🔥💣 IMS SYSTEM PROGRAMMER: O LADO BRUTAL DO MAINFRAME QUE SEGURA O MUNDO EM PÉ

O que realmente faz um especialista IMS na IBM — e por que poucos conseguem dominar esse universo

Quando alguém escuta:

“IMS System Programmer”

muita gente imagina apenas:

  • instalar software

  • rodar jobs

  • olhar logs

😄

Mas a realidade é MUITO mais pesada.

Na prática, um especialista IMS trabalha literalmente no coração operacional do sistema financeiro mundial.

Porque quando:

  • ATM para

  • autorização de cartão falha

  • telecom cai

  • fila IMS trava

  • Shared Queue degrada

  • DBRC perde sincronismo

o problema não é “apenas TI”.

💣 O impacto pode custar milhões em minutos.

E é exatamente aí que entra o profissional IMS.


🚀 Instalar, Atualizar e Manter IMS com SMP/E

Essa é uma das tarefas mais clássicas — e perigosas — do mundo z/OS.

O:

SMP/E

(System Modification Program Extended)

é o sistema responsável por instalar e manter software no mainframe IBM.

No mundo distribuído você baixa instalador.

No mainframe você trabalha com:

  • FMID

  • HOLDDATA

  • APPLY

  • ACCEPT

  • CSI

  • zones

Ou seja:

engenharia cirúrgica de software corporativo.


☠️ O Terror do APPLY CHECK

Veteranos conhecem o ritual:

SET BDY(TGT1).
APPLY CHECK.

E então começa a tensão.

Porque um PUT errado pode:

💣 quebrar IMS
💣 afetar CICS
💣 impactar DB2
💣 gerar incompatibilidades de SYSPLEX

SMP/E não é apenas “instalação”.

É controle absoluto de manutenção em ambiente crítico.


🌳 Configurar IMS Transaction Manager

Aqui começa o verdadeiro mundo IMS.

O:

IMS TM

(Transaction Manager)

é o cérebro transacional do ambiente.

Ele controla:

  • mensagens

  • filas

  • transações

  • scheduling

  • regiões online

  • comunicação terminal/programa

Quando alguém faz:

💳 pagamento
🏧 saque
📱 consulta saldo

há grandes chances de um IMS TM estar trabalhando por trás.


⚡ IMS Shared Queue — O Monstro do Paralelismo

O Shared Queue foi criado para ambientes gigantescos.

Ele permite que múltiplos IMS compartilhem:

  • filas

  • mensagens

  • workload

em ambiente SYSPLEX.

Isso traz:

✅ escalabilidade
✅ failover
✅ balanceamento
✅ alta disponibilidade

Mas também traz:

😄 pesadelos operacionais.

Porque quando Shared Queue degrada…

o caos pode ficar lindo.


🧠 Common Service Layer — A Cola do Ecossistema

O:

CSL

(Common Service Layer)

é a camada que integra diversos componentes IMS modernos.

Ela fornece:

  • Operations Manager

  • Structured Call Interface

  • Resource Manager

Sem CSL, ambientes modernos IMS praticamente não existem mais.

É ele quem permite gerenciamento mais centralizado e inteligente.


🔥 DBRC — O Guardião da Integridade

Se existe uma entidade sagrada no IMS…

ela se chama:

DBRC

(Database Recovery Control)

O DBRC controla:

  • recovery

  • logs

  • image copy

  • autorização de banco

  • integridade operacional

Ele sabe:

✅ quais logs existem
✅ quais backups são válidos
✅ qual banco pode abrir
✅ quais datasets estão consistentes

Sem DBRC:

💣 recovery vira inferno.


☕ Easter Egg Mainframe

Veteranos dizem:

“No dia que o RECON quebra…
o DBA envelhece 10 anos.”

😄

E honestamente?

Não é exagero.


🌐 IMS Connect — O Portal Entre Mundos

Hoje o IMS conversa com:

  • APIs REST

  • Java

  • JSON

  • mobile banking

  • cloud híbrida

E quem faz muita dessa ponte é o:

IMS Connect

Ele permite integração TCP/IP moderna com o velho mundo DL/I.

Ou seja:

📱 aplicativo no celular
→ API REST
→ IMS Connect
→ IMS TM
→ COBOL
→ DL/I

Cyberpunk corporativo puro.


📊 Monitorar IMS com RMF e SMF

No mundo distribuído muita gente olha dashboard bonito.

No mainframe…

o profissional IMS olha:

  • SMF

  • RMF

  • throughput

  • EXCP

  • CPU

  • enqueue

  • response time

Porque aqui performance é religião.


🚀 SMF — O DNA do z/OS

O:

SMF

(System Management Facility)

registra praticamente tudo.

É o “gravador de caixa preta” do mainframe.

Você consegue analisar:

  • uso CPU

  • transações

  • I/O

  • locks

  • workload

  • comportamento do IMS


⚡ RMF — O Olho da Performance

O:

RMF

(Resource Measurement Facility)

mede:

  • CPU

  • canais

  • memória

  • coupling facility

  • workload

Num ambiente IMS gigantesco, RMF é praticamente um estetoscópio do sistema.


💣 Analisar Abends e Problemas Complexos

Aqui mora a parte mais brutal da profissão.

Porque quando aparece:

U0777
S0C4
DFSxxxx
ABEND878

o especialista IMS entra em modo guerra.

Ele precisa analisar:

  • dumps

  • logs

  • traces

  • control blocks

  • storage overlays

  • waits

  • contention

Muitas vezes sob pressão absurda.


🌳 Alta Disponibilidade — Onde o IMS Brilha

IMS foi criado para:

missão crítica contínua.

Então arquiteturas IMS modernas usam:

  • SYSPLEX

  • Shared Queue

  • Coupling Facility

  • XRF

  • Fast Path

  • HALDB

para entregar:

✅ uptime gigantesco
✅ failover rápido
✅ workload sharing
✅ resiliência extrema


🚀 Disaster Recovery — O Dia do Juízo Final

Todo ambiente sério IMS possui:

DR TEST

Porque eventualmente:

  • data center cai

  • storage falha

  • rede quebra

  • região inteira desaparece

E o IMS precisa sobreviver.

O time testa:

  • recovery

  • restart

  • log apply

  • DBRC

  • reconnect

  • queue rebuild

Tudo sob cronômetro.


⚔️ O Arsenal Obrigatório do Profissional IMS


🟦 JCL

O idioma operacional do z/OS.

Sem JCL você literalmente não entra no jogo.


🟩 TSO/ISPF

O cockpit do operador mainframe.


🟨 JES2

Gerencia jobs, spool e execução batch.


🟪 REXX

O canivete suíço do mainframe.

Automação.

Monitoramento.

Operação.

Recovery.


🟥 SYSPLEX

O conceito que permite múltiplos z/OS trabalharem como um único sistema gigante.

Fundamental para IMS moderno.


☕ O Grande Segredo do Mundo IMS

O mercado moderno adora falar sobre:

  • cloud

  • microservices

  • kubernetes

  • serverless

Mas existe um detalhe curioso:

Boa parte das transações financeiras globais ainda depende de profissionais que dominam:

  • IMS

  • DL/I

  • DBRC

  • Shared Queue

  • SYSPLEX

  • SMP/E

Tecnologias criadas décadas atrás…

mas ainda absurdamente eficientes.


🚀 O Último Bastião da Engenharia Hardcore

Talvez seja isso que torne o universo IMS tão fascinante.

Ele não foi construído para ser bonito.

Foi construído para:

  • sobreviver

  • escalar

  • performar

  • resistir

E enquanto muita tecnologia moderna luta para manter estabilidade básica…

o velho IMS continua processando bilhões de transações silenciosamente.

Como um dinossauro mecânico escondido no subsolo do sistema financeiro mundial.


quinta-feira, 25 de agosto de 2022

Do IMS/360 ao IMS 15 no IBM z16

 

Bellacosa Mainframe uma overview do ims 360  ao ims 15

☕ Um Café no Bellacosa Mainframe

Do IMS/360 ao IMS 15 no IBM z16

A Evolução da Arquitetura que Inspirou os Sistemas Corporativos Modernos — Um Guia Definitivo para um Programador COBOL Padawan

Durante décadas, muita gente acreditou que os sistemas corporativos nasceram com Java, Oracle, APIs REST ou Kubernetes. Outros imaginam que microserviços, filas de mensagens, observabilidade e processamento distribuído são invenções da computação moderna.

A realidade é muito mais interessante.

Muito antes da internet existir, antes da Web, antes do Linux e até antes do banco de dados relacional se popularizar, engenheiros da IBM já haviam construído uma arquitetura extremamente sofisticada sobre o IBM System/360. Essa arquitetura possuía processamento online, banco de dados, recuperação automática, auditoria, processamento batch, filas de mensagens e milhares de usuários simultâneos.

O nome dela era simplesmente:

IMS – Information Management System

A imagem que analisamos nesta conversa é um excelente exemplo dessa arquitetura clássica. Embora o diagrama tenha sido desenhado há mais de cinquenta anos, praticamente todos os conceitos presentes nele continuam vivos no IBM Z moderno.

Hoje vamos desmontar essa arquitetura peça por peça e reconstruí-la utilizando a visão de um programador COBOL Padawan, entendendo não apenas "como funciona", mas também "por que continua funcionando".


O nascimento do IMS

Pouca gente conhece essa curiosidade.

O IMS não nasceu para bancos.

Nem para bancos financeiros.

Nem para seguradoras.

Ele nasceu por causa da NASA.

No final da década de 1960, a IBM precisava criar um sistema capaz de controlar milhões de componentes utilizados no Programa Apollo.

Imagine controlar parafusos.

Cabos.

Circuitos.

Motores.

Bombas.

Sensores.

Tudo precisava ser localizado em segundos.

Foi então que surgiu um banco de dados hierárquico extremamente rápido.

Esse projeto evoluiu e tornou-se o IMS.

Curiosamente, poucos anos depois, bancos, seguradoras, companhias aéreas e governos passaram a utilizá-lo.

Até hoje.


Bellacosa Mainframe e o workflow do ims dl/i

Entendendo o workflow

Observe a estrutura geral.

Ela é extremamente organizada.

Entradas


Processamento Online


Banco de Dados


Batch


Relatórios

Parece simples.

Mas escondia uma engenharia impressionante.

Cada bloco tinha uma responsabilidade específica.

Exatamente como fazemos hoje utilizando microserviços.

A diferença é que isso já existia décadas antes do termo "microservice" ser inventado.


Os Inputs

Na parte superior aparecem três caixas.

INPUT

INPUT

INPUT

Essas entradas podiam ser praticamente qualquer coisa.

Um terminal 3270.

Uma leitora de cartões.

Uma fita magnética.

Outro computador.

Uma aplicação externa.

Hoje poderíamos substituir essas caixas por:

  • API REST

  • IBM MQ

  • Kafka

  • Event Streams

  • Mobile App

  • Browser

  • Portal Web

  • IoT

O conceito continua exatamente igual.

Alguém envia uma informação.

O sistema precisa processá-la.


O verdadeiro cérebro: IMS Transaction Manager

No desenho original aparece:

IMS/360

Hoje ele seria:

IMS TM 15

Ele recebe transações.

Gerencia filas.

Controla sessões.

Executa programas COBOL.

Protege os dados.

Controla concorrência.

Garante integridade.

É praticamente um servidor de aplicações.

Muito antes do WebSphere existir.


Os famosos Message Processing Programs (MPP)

Na lateral aparece uma inscrição discreta.

Message Processing Programs

Esse pequeno detalhe representa uma das maiores ideias da computação corporativa.

O usuário envia uma mensagem.

O IMS coloca essa mensagem em uma fila.

Depois escolhe automaticamente qual programa COBOL deve executá-la.

Hoje isso lembra imediatamente:

  • Controller REST

  • Lambda

  • Azure Function

  • Cloud Function

  • Microserviço

Na prática é exatamente isso.

Só que rodando em um IBM Z.


O ciclo de uma transação

Imagine um operador alterando uma ordem de produção.

O fluxo interno acontece assim.

Terminal

↓

Mensagem

↓

Fila IMS

↓

MPP

↓

COBOL

↓

IMS DB

↓

Resposta

O usuário vê apenas alguns segundos.

Mas centenas de mecanismos internos entram em ação.

Locks.

Recovery.

Logs.

Buffers.

Commit.

Checkpoint.

Tudo acontece automaticamente.


Os módulos internos

Dentro da aplicação aparecem vários nomes.

STATUS

CHANGE

SPLIT

INQUIRY

ADD

Não são apenas palavras.

Cada uma representa uma operação de negócio.

STATUS

Consulta.

CHANGE

Atualização.

ADD

Inclusão.

INQUIRY

Pesquisa.

SPLIT

Divisão de pedidos.

Perceba uma curiosidade.

Hoje chamaríamos isso de:

GET

POST

PUT

PATCH

As ideias mudaram de nome.

Não de essência.


Os bancos de dados

A aplicação conversa com três bancos.

Isso já demonstra uma preocupação enorme com organização.

Manufacturing Order Database

Banco principal.

Pedidos.

Clientes.

Produção.

Ordens.

Materiais.


Part Number Cross Reference

Uma base auxiliar.

Ela permite descobrir equivalências.

Imagine:

Parafuso antigo

↓

Parafuso novo

Ou

Fornecedor A

↓

Fornecedor B

Hoje chamaríamos isso de Master Data Management.


Manufacturing Planning Database

Aqui mora o planejamento.

Capacidade.

Estoque.

Cronograma.

Previsão.

Hoje esse banco conversa diretamente com sistemas ERP.


Easter Egg nº 1

Muita gente acredita que Data Warehouse nasceu nos anos 90.

Na verdade não.

Observe o bloco:

Unload and Select

Ele já fazia exatamente isso.

Extraía dados.

Selecionava informações.

Preparava estatísticas.

Produzia relatórios.

É praticamente um ETL primitivo.


O IMS LOG

Este talvez seja o componente mais importante de toda arquitetura.

Toda alteração gera um registro.

Nada acontece sem ser registrado.

É graças ao LOG que existem:

Recovery

Rollback

Auditoria

Sincronização

Checkpoint

Hoje fazemos exatamente isso.

Oracle.

Db2.

SQL Server.

PostgreSQL.

Todos utilizam o mesmo princípio.


Easter Egg nº 2

Se você já ouviu falar em WAL (Write Ahead Log) do PostgreSQL...

Parabéns.

Você já conhece o IMS LOG.

O conceito é praticamente idêntico.


IMS Utilities

Após registrar tudo no LOG entram as Utilities.

Elas realizam tarefas fundamentais.

Reorganização.

Validação.

Compressão.

Recovery.

Carga.

Descarga.

Verificação.

Sem Utilities, um ambiente IMS simplesmente não sobrevive.


O mundo Batch

Na parte inferior aparece outro universo.

Os Batch Programs.

Hoje muitos iniciantes imaginam que Batch significa tecnologia antiga.

Não.

Batch significa processamento em massa.

Todos os grandes bancos ainda executam milhares de jobs batch diariamente.

Mudaram apenas as ferramentas.


Report Writer

Responsável pelos relatórios.

No passado.

Impressoras

Papel contínuo

Listagens verdes

Hoje.

Power BI.

Cognos.

Grafana.

Excel.

PDF.

O objetivo continua igual.

Transformar dados em informação.


Selected Report Writer

Relatórios específicos.

Por exemplo.

Pedidos atrasados.

Pedidos acima de R$ 1 milhão.

Produção do turno noturno.

Database Statistics

Outro detalhe interessante.

O sistema produzia estatísticas do banco.

Quantidade de registros.

Espaço ocupado.

Fragmentação.

Performance.

Hoje isso lembra:

RUNSTATS

EXPLAIN

Catalog Statistics

SMF

RMF

OMEGAMON


POSR

No desenho aparece uma sigla curiosa.

POSR

Dependendo da instalação, poderia representar um sistema interno responsável pela consolidação de relatórios operacionais.

É praticamente um pequeno Data Mart.

Observe que ele recebe dados extraídos.

Processa.

Produz relatórios.

Hoje isso seria um pipeline analítico.


Atualizando para o IBM z16

Na versão moderna do diagrama acrescentamos diversos componentes.

Observe como tudo evoluiu.

Entradas

Agora temos.

3270

REST

JSON

MQ

Kafka

Mobile

Cloud

Eventos

Mas todos continuam convergindo para o mesmo lugar.

IMS TM.


Segurança

Hoje um ambiente corporativo possui:

RACF

TLS

AT-TLS

MFA

Criptografia

SMF

Auditoria

LGTO

Compliance

Zero Trust

No desenho antigo isso estava implícito.

Hoje tornou-se um bloco próprio.


DevOps

Outro componente inexistente no desenho original.

Agora encontramos.

Git

GitHub

GitLab

Jenkins

UrbanCode

DBB

Zowe CLI

Ansible

Terraform

Pipelines

Observe.

Nenhum deles substitui o IMS.

Eles apenas automatizam seu gerenciamento.


Observabilidade

Outro grande avanço.

Hoje monitoramos praticamente tudo.

OMEGAMON

Instana

Operations Analytics

SMF

RMF

Grafana

OpenTelemetry

Anomalias

Machine Learning

No IMS/360 isso era feito através de relatórios.

Hoje fazemos em tempo real.


Integração

Outro enorme salto.

O IMS moderno conversa naturalmente com:

Db2

MQ

IMS Connect

REST

SOAP

JSON

Cloud Pak for Data

Data Lake

IBM Cloud

AWS

Azure

Kafka

OpenShift

O IMS deixou de ser um ambiente isolado.

Hoje participa do ecossistema corporativo inteiro.


O maior equívoco sobre o Mainframe

Existe uma frase repetida há décadas.

"O Mainframe é um computador antigo."

Errado.

Na verdade.

O Mainframe é uma arquitetura extremamente moderna cuja origem é antiga.

É diferente.

O IBM z16 possui:

IA embarcada.

Criptografia por hardware.

Processadores especializados.

Linux.

Containers.

Kubernetes.

OpenShift.

APIs.

Cloud.

Mas continua executando IMS.

Porque a arquitetura foi bem projetada.


Easter Egg nº 3

Sabe o que mais impressiona?

Se um programador COBOL de 1985 voltasse hoje, ele provavelmente reconheceria a lógica de um sistema IMS em poucos minutos.

Agora imagine o contrário.

Um desenvolvedor moderno tentando entender um programa IMS de 1985.

Ele descobriria que quase tudo o que considera "novo" já existia em alguma forma:

  • filas de mensagens;

  • processamento orientado a eventos;

  • separação entre regras de negócio e acesso a dados;

  • auditoria transacional;

  • recuperação automática;

  • alta disponibilidade.

Os nomes mudaram. Os princípios permaneceram.


Passo a passo para um Padawan dominar o IMS

Não tente aprender tudo de uma vez. Construa conhecimento em camadas.

Nível 1 – Fundamentos

  • Entenda o que é o IBM Z e o z/OS.

  • Aprenda JCL, datasets e utilitários básicos.

  • Conheça a diferença entre processamento online e batch.

Nível 2 – IMS TM

  • Descubra o que é uma transação IMS.

  • Estude Message Processing Programs (MPP).

  • Aprenda o fluxo: entrada → fila → programa → resposta.

Nível 3 – IMS DB

  • Compreenda bancos de dados hierárquicos.

  • Estude segmentos, hierarquias e DBD/PSB.

  • Pratique navegação usando chamadas DL/I.

Nível 4 – Operação

  • Aprenda a interpretar logs.

  • Estude checkpoints e recovery.

  • Conheça as principais IMS Utilities.

Nível 5 – Modernização

  • Explore IMS Connect.

  • Publique APIs REST para aplicações IMS.

  • Integre com IBM MQ, Event Streams e microsserviços.


Curiosidades que quase ninguém conhece

  • O IMS é um dos softwares comerciais mais antigos ainda em desenvolvimento contínuo.

  • Milhões de transações financeiras diárias no mundo passam por aplicações IMS sem que o usuário perceba.

  • Bancos de dados hierárquicos continuam sendo extremamente eficientes para cargas transacionais previsíveis.

  • O IMS foi projetado quando memória e processamento eram recursos escassos, o que explica sua impressionante eficiência até hoje.

  • Muitas arquiteturas modernas de mensageria reproduzem conceitos que o IMS já implementava há décadas.


Conclusão

A imagem histórica que analisamos não é apenas um diagrama técnico; ela representa uma filosofia de engenharia. Ela mostra que sistemas corporativos robustos são construídos com responsabilidades bem definidas, processamento confiável, recuperação planejada e forte disciplina arquitetural.

Ao atualizarmos esse desenho para um ambiente IBM z16 com IMS 15, percebemos que a essência permanece intacta. Entradas continuam chegando ao Transaction Manager, programas COBOL continuam executando regras de negócio, bancos de dados continuam preservando a integridade das informações e processos batch continuam alimentando análises e relatórios. A diferença é que agora tudo isso convive com APIs REST, JSON, IBM MQ, Event Streams, DevOps, observabilidade em tempo real, OpenShift, inteligência artificial e integração com nuvens híbridas.

Essa é a maior lição para um programador COBOL Padawan: tecnologias vêm e vão, mas boas arquiteturas atravessam gerações. O IMS sobreviveu porque foi projetado com princípios sólidos. Entender esse legado não é estudar apenas o passado; é compreender os alicerces sobre os quais a computação corporativa moderna continua sendo construída.

quinta-feira, 24 de fevereiro de 2022

Da Compilação à Execução de um Programa COBOL — Parte II

 

Bellacosa Mainframe e a compilação cobol parte II

☕ Um Café no Bellacosa Mainframe

Da Compilação à Execução de um Programa COBOL — Parte II

CICS, Db2, IMS e Adabas: O que Acontece com o Código Antes de o Compilador Entrar em Cena

Introdução

Na primeira parte desta jornada, conhecemos o nascimento de um programa COBOL.

Vimos que tudo começa com o código-fonte armazenado em uma biblioteca, geralmente um PDS ou PDSE, e que os copybooks funcionam como contratos reutilizáveis entre programas, arquivos, mensagens e sistemas.

Também descobrimos uma diferença essencial:

COPY inclui código-fonte.
CALL executa outro módulo.

Porém, quando abrimos um programa corporativo real, especialmente em um banco, seguradora, indústria ou grande empresa, encontramos instruções que parecem COBOL, mas que não pertencem diretamente à linguagem.

Por exemplo:

           EXEC CICS
                READ FILE('CLIENTE')
                INTO(REGISTRO-CLIENTE)
                RIDFLD(WS-CHAVE)
           END-EXEC.

Ou:

           EXEC SQL
                SELECT NOME
                  INTO :WS-NOME
                  FROM CLIENTES
                 WHERE CODIGO = :WS-CODIGO
           END-EXEC.

Também podemos encontrar chamadas como:

           CALL 'CBLTDLI'
                USING GU-FUNCTION
                      PCB-MASK
                      AREA-SEGMENTO
                      SSA-CLIENTE.

Ou estruturas utilizadas na comunicação com Adabas.

O Programador COBOL Padawan olha para tudo isso e pode imaginar que o compilador entende todos esses comandos naturalmente.

Mas não é exatamente assim.

Antes que o compilador COBOL possa transformar o fonte em código objeto, outros componentes precisam preparar partes específicas do programa.

É como uma grande cozinha corporativa.

O compilador é o chef principal, mas alguns ingredientes precisam ser preparados por especialistas antes de chegar à bancada.

Nesta segunda parte, vamos entender:

  • o papel do tradutor CICS;

  • como o Db2 processa comandos EXEC SQL;

  • o que é um DBRM;

  • por que o BIND do Db2 não é linkedição;

  • como programas COBOL acessam IMS;

  • como ocorre a comunicação com Adabas;

  • o que todas essas tecnologias possuem em comum.

Prepare o café, abra o ISPF e venha descobrir o que realmente acontece com o código antes da compilação.


1. Nem tudo o que aparece no programa é COBOL puro

COBOL possui instruções próprias, como:

MOVE
ADD
SUBTRACT
MULTIPLY
DIVIDE
COMPUTE
IF
EVALUATE
PERFORM
READ
WRITE
REWRITE
DELETE
OPEN
CLOSE
CALL

Essas instruções fazem parte da linguagem e podem ser analisadas diretamente pelo compilador.

Porém, comandos como:

EXEC CICS
EXEC SQL

pertencem a ambientes externos.

Eles foram incorporados ao fonte por meio de uma sintaxe padronizada, mas precisam ser interpretados por componentes especializados.

Uma representação simples seria:

Programa COBOL
   ├── comandos COBOL
   ├── comandos CICS
   ├── comandos SQL
   ├── chamadas IMS
   └── interfaces Adabas

O compilador entende plenamente a primeira parte.

As demais exigem preparação, tradução, bibliotecas ou interfaces específicas.


2. O que é o CICS?

CICS significa Customer Information Control System.

Na prática, ele é uma plataforma de processamento de transações online.

Quando um cliente consulta o saldo, realiza uma transferência, altera um endereço ou solicita uma segunda via de documento, existe uma grande possibilidade de algum componente CICS estar envolvido em ambientes tradicionais IBM Z.

O CICS gerencia elementos como:

  • transações;

  • programas;

  • terminais;

  • sessões;

  • arquivos;

  • filas;

  • segurança;

  • recuperação;

  • sincronização;

  • comunicação entre sistemas;

  • controle de recursos;

  • integração com Db2, MQ e outras tecnologias.

O programa COBOL contém a regra de negócio.

O CICS controla o ambiente transacional em que essa regra será executada.

Imagine uma transação chamada:

C001

Ela pode estar associada ao programa:

PGMCLI01

Quando o usuário informa C001, o CICS localiza o programa, cria uma task, verifica segurança, entrega o controle e acompanha sua execução.


3. Os comandos EXEC CICS

Um programa pode utilizar comandos como:

           EXEC CICS
                RECEIVE MAP('MAPCLI')
                        MAPSET('SETCLI')
                        INTO(AREA-MAPA)
           END-EXEC.

Esse comando solicita o recebimento dos dados de uma tela.

Outro exemplo:

           EXEC CICS
                SEND MAP('MAPCLI')
                     MAPSET('SETCLI')
                     FROM(AREA-MAPA)
                     ERASE
           END-EXEC.

Nesse caso, o programa solicita o envio de um mapa para o terminal.

Também podemos encontrar:

           EXEC CICS
                READ FILE('ARQCLI')
                     INTO(REGISTRO-CLIENTE)
                     RIDFLD(WS-CODIGO)
                     RESP(WS-RESP)
           END-EXEC.

Ou:

           EXEC CICS
                LINK PROGRAM('PGM002')
                     COMMAREA(AREA-COMUNICACAO)
                     LENGTH(WS-TAMANHO)
           END-EXEC.

Esses comandos parecem fazer parte do COBOL porque estão misturados ao código.

Entretanto, o compilador COBOL puro não sabe implementar operações como:

  • enviar uma tela;

  • ler um arquivo controlado pelo CICS;

  • iniciar outra transação;

  • acessar uma fila temporária;

  • chamar outro programa por meio do CICS;

  • devolver o controle ao monitor transacional.

Por isso, entra em cena o tradutor CICS.


4. O tradutor CICS

O tradutor CICS analisa os comandos:

EXEC CICS
...
END-EXEC

e os transforma em estruturas que o compilador COBOL consegue processar.

O fluxo conceitual é:

Fonte COBOL com EXEC CICS
             ↓
Tradutor CICS
             ↓
Fonte COBOL traduzido
             ↓
Compilador COBOL

O tradutor não executa a transação.

Ele apenas prepara o fonte.

Imagine o seguinte comando:

           EXEC CICS
                WRITEQ TS
                QUEUE('TEMP001')
                FROM(WS-DADOS)
                LENGTH(WS-TAMANHO)
           END-EXEC.

O tradutor converte essa instrução em uma sequência de chamadas e estruturas internas utilizadas pela interface do CICS.

Depois dessa tradução, o compilador enxerga COBOL válido.

Durante a execução, o programa chama os serviços CICS correspondentes.


5. EXEC CICS é uma macro?

No cotidiano do mainframe, alguns profissionais chamam os comandos EXEC CICS de macros.

Essa forma de falar é compreensível, mas pode gerar confusão.

Uma macro, em outros contextos, costuma ser um trecho expandido diretamente durante a montagem ou compilação.

O comando EXEC CICS é melhor compreendido como uma instrução embutida que precisa ser traduzida por um processador específico.

Portanto, tecnicamente, é mais correto dizer:

EXEC CICS é um comando CICS embutido no programa COBOL.

A distinção pode parecer pequena, mas ajuda o iniciante a compreender que existe uma etapa especializada antes da compilação.


6. CICS controla o recurso, não o programa COBOL

Considere:

           EXEC CICS
                READ FILE('CLIENTES')
                     INTO(REG-CLIENTE)
                     RIDFLD(WS-CODIGO)
                     RESP(WS-RESP)
           END-EXEC.

O programa não abre diretamente o arquivo físico.

Ele pede ao CICS que realize a leitura.

O CICS pode cuidar de:

  • localização do recurso;

  • compartilhamento;

  • segurança;

  • recuperação;

  • bloqueios;

  • integridade;

  • controle transacional;

  • resposta de erro.

O programa recebe o resultado e continua a regra de negócio.

Esse modelo é poderoso porque separa responsabilidades.

Programa COBOL → lógica de negócio
CICS          → controle transacional

7. O que é o Db2?

Db2 é o sistema gerenciador de banco de dados relacional da IBM amplamente utilizado no IBM Z.

Ele organiza informações em:

  • tabelas;

  • colunas;

  • linhas;

  • índices;

  • views;

  • tablespaces;

  • databases;

  • schemas;

  • packages;

  • plans;

  • collections.

O COBOL pode acessar dados Db2 por meio de SQL embutido.

Exemplo:

           EXEC SQL
                SELECT NOME,
                       SALDO
                  INTO :WS-NOME,
                       :WS-SALDO
                  FROM CLIENTES
                 WHERE CODIGO = :WS-CODIGO
           END-EXEC.

Esse SQL está inserido dentro do fonte COBOL.

Porém, ele não pertence diretamente à linguagem COBOL.

Assim como ocorre com o CICS, o SQL precisa ser processado antes da compilação.


8. O pré-compilador Db2

Historicamente, programas COBOL com SQL passavam pelo pré-compilador Db2.

O fluxo clássico é:

Fonte COBOL com EXEC SQL
              ↓
Pré-compilador Db2
              ↓
Fonte COBOL modificado
              +
             DBRM

O pré-compilador realiza duas tarefas importantes.

Primeiro, ele substitui ou prepara os comandos SQL no fonte para que o compilador COBOL possa processá-los.

Segundo, ele gera o DBRM.

Em ambientes modernos, pode ser utilizado um coprocessador SQL integrado ao compilador.

Para o iniciante, o conceito fundamental permanece:

O SQL precisa ser analisado por uma tecnologia Db2 antes ou durante a compilação COBOL.


9. O que é o DBRM?

DBRM significa Database Request Module.

Ele contém informações extraídas dos comandos SQL presentes no programa.

Considere:

           EXEC SQL
                UPDATE CONTAS
                   SET SALDO = SALDO - :WS-VALOR
                 WHERE AGENCIA = :WS-AGENCIA
                   AND CONTA   = :WS-CONTA
           END-EXEC.

O Db2 precisa conhecer essa instrução para preparar sua execução.

O DBRM representa as requisições SQL encontradas no programa.

Posteriormente, ele será utilizado em uma operação de BIND.

O fluxo é:

Programa com SQL
       ↓
DBRM
       ↓
BIND PACKAGE
       ↓
Package Db2

O package contém a preparação necessária para que o Db2 execute as instruções SQL.


10. O BIND do Db2

O BIND do Db2 transforma o DBRM em um package executável pelo subsistema.

Durante esse processo, o Db2 pode avaliar:

  • existência das tabelas;

  • existência das colunas;

  • existência dos índices;

  • autorizações;

  • estatísticas;

  • opções de isolamento;

  • caminhos de acesso;

  • versões;

  • collections;

  • parâmetros de execução.

O Db2 decide como determinada instrução poderá ser executada.

Por exemplo:

SELECT NOME
FROM CLIENTES
WHERE CODIGO = ?

O Db2 poderá utilizar:

  • um índice;

  • uma varredura de tabela;

  • um índice composto;

  • uma combinação de acessos;

  • alguma estratégia definida pelo otimizador.

O programa COBOL informa o que deseja.

O Db2 decide como localizar os dados.


11. BIND Db2 não é linkedição

Este é um dos pontos mais importantes deste capítulo.

No mainframe, a palavra “bind” pode aparecer em contextos diferentes.

Existe o Binder do z/OS, responsável pela criação do módulo executável.

E existe o BIND do Db2, responsável pela preparação do SQL.

Binder z/OS → cria load module ou program object
BIND Db2    → cria package

Portanto:

Compilação + linkedição ≠ BIND Db2

Um programa pode estar perfeitamente compilado e linkedidado, mas falhar porque:

  • o package não existe;

  • o package está inválido;

  • a collection está incorreta;

  • o usuário não possui autorização;

  • os objetos Db2 foram alterados;

  • a versão do package não corresponde ao programa.


12. As duas trilhas de um programa Db2

Um programa COBOL com Db2 segue duas trilhas paralelas.

Trilha COBOL

Fonte
  ↓
Compilador
  ↓
Código objeto
  ↓
Binder
  ↓
Módulo executável

Trilha Db2

EXEC SQL
  ↓
DBRM
  ↓
BIND
  ↓
Package

Na execução, as duas trilhas se encontram.

O módulo executável inicia a lógica COBOL.

Quando chega a um comando SQL, ele aciona a interface Db2, que utiliza o package correspondente.

O load module sozinho não é suficiente.

O package sozinho também não é suficiente.

Eles trabalham em conjunto.


13. Host variables

Campos COBOL utilizados dentro de instruções SQL são chamados de host variables.

Exemplo:

       01  WS-CODIGO            PIC 9(09).
       01  WS-NOME              PIC X(40).

No SQL:

           EXEC SQL
                SELECT NOME
                  INTO :WS-NOME
                  FROM CLIENTES
                 WHERE CODIGO = :WS-CODIGO
           END-EXEC.

Os dois-pontos indicam que os campos pertencem ao programa COBOL.

Sem essa indicação, o Db2 poderia interpretar o nome como uma coluna ou outro elemento SQL.

As host variables formam a ponte entre:

Memória COBOL ↔ Db2

14. A SQLCA

SQLCA significa SQL Communication Area.

Ela contém informações sobre a execução do último comando SQL.

Sua inclusão pode ser feita assim:

           EXEC SQL
                INCLUDE SQLCA
           END-EXEC.

Depois de uma instrução SQL, o programa pode testar:

           EVALUATE SQLCODE
               WHEN 0
                   DISPLAY 'OPERACAO REALIZADA'
               WHEN 100
                   DISPLAY 'REGISTRO NAO ENCONTRADO'
               WHEN OTHER
                   DISPLAY 'ERRO SQL: ' SQLCODE
           END-EVALUATE.

O SQLCODE é um dos campos mais conhecidos.

Alguns resultados comuns são:

SQLCODE 0    → sucesso
SQLCODE 100  → nenhuma linha encontrada
SQLCODE negativo → erro
SQLCODE positivo → aviso ou situação específica

O programa precisa tratar esses resultados.

Ignorar o SQLCODE é como atravessar uma rodovia sem olhar os sinais.


15. Indicadores de nulo

No Db2, uma coluna pode aceitar valor nulo.

COBOL, porém, trabalha com campos que possuem conteúdo físico.

Para representar um nulo, é comum utilizar uma variável indicadora.

Exemplo:

       01  WS-TELEFONE          PIC X(15).
       01  WS-IND-TELEFONE      PIC S9(04) COMP.

No SQL:

           EXEC SQL
                SELECT TELEFONE
                  INTO :WS-TELEFONE
                       :WS-IND-TELEFONE
                  FROM CLIENTES
                 WHERE CODIGO = :WS-CODIGO
           END-EXEC.

Se o indicador retornar valor negativo, a coluna estava nula.

Sem o indicador adequado, o programa pode receber erros ao tentar trabalhar com valores nulos.


16. Um programa CICS com Db2

Em sistemas online, é comum encontrar CICS e Db2 dentro do mesmo programa.

Exemplo:

           EXEC CICS
                RECEIVE MAP('MAPCLI')
                        MAPSET('SETCLI')
                        INTO(AREA-MAPA)
           END-EXEC.

           MOVE MAP-CODIGO TO WS-CODIGO.

           EXEC SQL
                SELECT NOME,
                       SALDO
                  INTO :WS-NOME,
                       :WS-SALDO
                  FROM CLIENTES
                 WHERE CODIGO = :WS-CODIGO
           END-EXEC.

           EXEC CICS
                SEND MAP('MAPCLI')
                     MAPSET('SETCLI')
                     FROM(AREA-MAPA)
           END-EXEC.

Nesse caso, o programa utiliza:

  • CICS para controlar a transação e a tela;

  • Db2 para acessar os dados;

  • COBOL para executar a regra de negócio.

O fluxo pode envolver:

Fonte com CICS e SQL
          ↓
Tradução CICS
          ↓
Processamento Db2
          ↓
Compilação COBOL
          ↓
Linkedição
          ↓
BIND do package Db2

A sequência exata pode variar conforme as ferramentas e versões.

Mas todos esses elementos precisam ser preparados.


17. O que é IMS?

IMS significa Information Management System.

É uma plataforma histórica e extremamente importante no ecossistema IBM Z.

Ela pode ser dividida em duas grandes áreas:

IMS DB → gerenciamento de banco de dados hierárquico
IMS TM → gerenciamento de transações e mensagens

Um banco IMS não organiza os dados exatamente como uma tabela relacional.

Ele utiliza uma estrutura hierárquica baseada em segmentos.

Podemos imaginar:

CLIENTE
   ├── CONTA
   │      ├── MOVIMENTO
   │      └── CARTAO
   └── ENDERECO

O segmento CLIENTE pode ser o pai.

CONTA e ENDERECO podem ser filhos.

MOVIMENTO pode ser filho de CONTA.

Essa estrutura lembra uma árvore.


18. Chamadas DL/I

Programas COBOL acessam IMS por meio da interface DL/I.

DL/I significa Data Language/I.

Uma chamada conceitual pode ser:

           CALL 'CBLTDLI'
                USING GU-FUNCTION
                      PCB-MASK
                      SEGMENTO-CLIENTE
                      SSA-CLIENTE.

A função GU significa Get Unique.

Ela solicita a localização de um segmento específico.

Outras funções comuns incluem:

GU    Get Unique
GN    Get Next
GNP   Get Next Within Parent
GHU   Get Hold Unique
GHN   Get Hold Next
ISRT  Insert
REPL  Replace
DLET  Delete

O programa envia uma solicitação ao IMS.

O IMS navega pela estrutura hierárquica e retorna o segmento solicitado.


19. O PCB no IMS

PCB significa Program Communication Block.

Ele representa a comunicação entre o programa e um banco ou fila de mensagens IMS.

Após uma chamada DL/I, o programa pode verificar campos da PCB para descobrir:

  • status da operação;

  • nome do segmento;

  • nível hierárquico;

  • informações de processamento;

  • resultado da chamada.

É semelhante ao papel do FILE STATUS em arquivos ou do SQLCODE no Db2.

Cada tecnologia possui sua maneira de informar ao programa o resultado da operação.

QSAM/VSAM → FILE STATUS
Db2       → SQLCODE e SQLSTATE
IMS       → status da PCB
CICS      → RESP e RESP2
Adabas    → response code

Um bom programador não ignora nenhum desses retornos.


20. O que são DBD e PSB?

O ambiente IMS utiliza definições importantes.

DBD

DBD significa Database Description.

Ele descreve a estrutura do banco IMS:

  • segmentos;

  • relacionamentos;

  • campos-chave;

  • organização;

  • métodos de acesso;

  • características físicas e lógicas.

PSB

PSB significa Program Specification Block.

Ele define quais recursos um programa pode acessar e como poderá acessá-los.

O PSB pode conter PCBs para:

  • bancos IMS;

  • filas de mensagens;

  • outros recursos.

Podemos imaginar:

DBD → descreve o banco
PSB → descreve a visão do programa
PCB → interface usada durante a execução

21. IMS Transaction Manager

O IMS TM controla transações baseadas em mensagens.

Um fluxo simplificado pode ser:

Terminal, API ou outro sistema
             ↓
Mensagem de entrada
             ↓
Fila IMS
             ↓
Código de transação
             ↓
Programa COBOL
             ↓
Processamento
             ↓
Mensagem de saída

O programa pode receber a mensagem por meio de uma PCB de entrada e produzir uma resposta.

Assim como o CICS, o IMS controla o ambiente transacional.

Mas sua arquitetura, seus conceitos e sua forma de programação são diferentes.


22. Regiões IMS

Programas IMS podem executar em diferentes tipos de regiões.

Entre elas:

  • MPP;

  • BMP;

  • batch DL/I;

  • regiões utilitárias;

  • ambientes controlados pelo IMS.

MPP

Message Processing Program.

Processa mensagens e transações IMS.

BMP

Batch Message Processing.

Executa processamento batch com acesso controlado a bancos IMS e, em certos casos, filas.

O programa COBOL continua sendo compilado e linkedidado.

Porém, sua execução depende do ambiente IMS e das definições corretas.


23. O que é Adabas?

Adabas é um sistema de gerenciamento de banco de dados criado pela Software AG.

Ele se tornou muito conhecido em ambientes que utilizam Natural, mas também pode ser acessado por programas COBOL.

O Adabas possui uma arquitetura própria e utiliza componentes como:

  • Nucleus;

  • arquivos Adabas;

  • control blocks;

  • buffers;

  • interfaces de chamada;

  • códigos de resposta.

O Nucleus é o componente central que processa as solicitações.

Uma representação simplificada seria:

Programa COBOL
      ↓
Interface Adabas
      ↓
Adabas Nucleus
      ↓
Arquivo Adabas

24. Control Block e buffers Adabas

Um programa pode utilizar um control block para informar:

  • comando;

  • arquivo;

  • identificadores;

  • opções;

  • códigos de resposta;

  • informações de navegação;

  • parâmetros da operação.

Também podem existir buffers como:

Format Buffer

Define os campos que serão lidos ou atualizados.

Record Buffer

Recebe ou envia os dados do registro.

Search Buffer

Descreve os critérios de pesquisa.

Value Buffer

Contém os valores utilizados na pesquisa.

ISN Buffer

Pode armazenar números internos de sequência de registros.

Essas estruturas são fornecidas à interface Adabas durante a chamada.


25. Response Code Adabas

Após uma operação, o programa precisa verificar o código de resposta.

Um retorno de sucesso indica que a solicitação foi processada.

Outros códigos podem indicar:

  • registro não encontrado;

  • arquivo indisponível;

  • comando inválido;

  • conflito;

  • erro de formato;

  • problema de segurança;

  • falha de comunicação;

  • inconsistência de parâmetros.

Assim como no Db2, IMS, CICS ou VSAM, nunca se deve presumir que uma operação foi bem-sucedida sem verificar o retorno.


26. Natural e Adabas

Muitos iniciantes associam Adabas exclusivamente à linguagem Natural.

Essa associação existe porque as duas tecnologias são frequentemente utilizadas juntas.

Porém:

Natural é uma linguagem e ambiente de desenvolvimento.
Adabas é um sistema gerenciador de banco de dados.

Um programa COBOL também pode acessar Adabas por meio de interfaces apropriadas.

Da mesma forma, um programa Natural pode acessar outros recursos.

Não confunda a linguagem com o banco de dados.


27. O padrão comum entre CICS, Db2, IMS e Adabas

Apesar das diferenças, existe um padrão arquitetural comum.

O programa COBOL não controla diretamente toda a infraestrutura.

Ele solicita serviços.

COBOL → descreve a regra de negócio
CICS  → controla a transação
Db2   → gerencia dados relacionais
IMS   → gerencia dados hierárquicos e mensagens
Adabas → gerencia dados em sua arquitetura

Cada ambiente fornece:

  • interfaces;

  • comandos;

  • códigos de retorno;

  • controle de recursos;

  • segurança;

  • recuperação;

  • mecanismos de diagnóstico.

O programa COBOL deve respeitar os contratos de cada um.


28. O código de retorno é parte da lógica

Considere um programador que escreve:

           EXEC SQL
                UPDATE CONTAS
                   SET SALDO = SALDO - :WS-VALOR
                 WHERE CONTA = :WS-CONTA
           END-EXEC.

           DISPLAY 'OPERACAO REALIZADA'.

Esse programa exibe sucesso sem verificar o SQLCODE.

Se a conta não existir, o programa poderá informar uma operação que não aconteceu.

O correto seria:

           EXEC SQL
                UPDATE CONTAS
                   SET SALDO = SALDO - :WS-VALOR
                 WHERE CONTA = :WS-CONTA
           END-EXEC.

           EVALUATE SQLCODE
               WHEN 0
                   DISPLAY 'OPERACAO REALIZADA'
               WHEN 100
                   DISPLAY 'CONTA NAO ENCONTRADA'
               WHEN OTHER
                   DISPLAY 'ERRO DB2: ' SQLCODE
           END-EVALUATE.

O mesmo princípio vale para:

RESP CICS
FILE STATUS
PCB IMS
Response Code Adabas

No mainframe, tratar retorno não é uma recomendação opcional.

É parte da regra de negócio.


29. O perigo das opções implícitas

Alguns comandos utilizam tratamento automático de erro.

No CICS, por exemplo, certos erros podem transferir o controle para mecanismos padrão caso o programa não utilize opções como:

RESP
RESP2
NOHANDLE
HANDLE CONDITION

Em programas modernos, é comum preferir tratamento explícito por RESP e RESP2.

Exemplo:

           EXEC CICS
                READ FILE('ARQCLI')
                     INTO(REG-CLIENTE)
                     RIDFLD(WS-CODIGO)
                     RESP(WS-RESP)
                     RESP2(WS-RESP2)
           END-EXEC.

           EVALUATE WS-RESP
               WHEN DFHRESP(NORMAL)
                   CONTINUE
               WHEN DFHRESP(NOTFND)
                   DISPLAY 'CLIENTE NAO ENCONTRADO'
               WHEN OTHER
                   DISPLAY 'ERRO CICS: ' WS-RESP
           END-EVALUATE.

O objetivo é impedir que falhas sejam tratadas de forma inesperada.


30. Copybooks especializados

Esses ambientes também utilizam copybooks.

No CICS, podem existir:

  • layouts de COMMAREA;

  • mapas BMS;

  • estruturas de mensagens;

  • áreas de resposta;

  • contratos entre programas.

No Db2, podem existir:

  • DCLGENs;

  • estruturas de tabelas;

  • SQLCA;

  • áreas de entrada e saída.

No IMS:

  • layouts de segmentos;

  • PCBs;

  • SSAs;

  • áreas de mensagens.

No Adabas:

  • control blocks;

  • buffers;

  • layouts de registros;

  • constantes e códigos.

Portanto, o copybook apresentado na primeira parte continua sendo fundamental.

Ele liga o programa às interfaces dos subsistemas.


31. DCLGEN no Db2

DCLGEN significa Declarations Generator.

Ele pode gerar estruturas COBOL compatíveis com colunas de uma tabela Db2.

Exemplo conceitual:

       01  DCLCLIENTES.
           10 CLIENTE-CODIGO     PIC S9(9) COMP.
           10 CLIENTE-NOME       PIC X(40).
           10 CLIENTE-SALDO      PIC S9(11)V99 COMP-3.

O programa inclui essa estrutura por meio de um copybook ou processo equivalente.

Isso reduz a possibilidade de divergência entre os campos COBOL e as definições do banco.

Porém, a geração não elimina a necessidade de análise.

Tipos, precisão, nulos e conversões precisam ser compreendidos.


32. O programa ainda não é executável

Depois da tradução CICS, do processamento SQL e da preparação das interfaces IMS ou Adabas, o programa ainda não está pronto para executar.

Neste momento, temos algo semelhante a:

Fonte COBOL preparado
Copybooks expandidos ou localizados
Comandos CICS traduzidos
Comandos SQL processados
DBRM gerado
Interfaces disponíveis

O próximo passo será a compilação.

O compilador transformará o fonte em código objeto.

Depois, o Binder realizará a linkedição.

Somente então surgirá o módulo executável.


33. O fluxo completo desta etapa

Podemos representar a Parte II assim:

Fonte COBOL
     ↓
Identificação de comandos externos
     ↓
EXEC CICS → tradução CICS
     ↓
EXEC SQL → pré-compilação ou coprocessamento Db2
     ↓
Geração do DBRM
     ↓
Chamadas IMS → preparação das interfaces DL/I
     ↓
Chamadas Adabas → uso de control blocks e buffers
     ↓
Fonte preparado para compilação

Em paralelo:

DBRM
  ↓
BIND Db2
  ↓
Package

34. Erros típicos antes da compilação

Nesta fase, podem ocorrer problemas como:

CICS

  • comando EXEC CICS inválido;

  • opção incompatível;

  • copybook CICS ausente;

  • tamanho incorreto de COMMAREA;

  • referência a campo inexistente;

  • estrutura de mapa incorreta.

Db2

  • host variable não declarada;

  • SQLCA ausente;

  • sintaxe SQL inválida;

  • DCLGEN incompatível;

  • indicador de nulo inexistente;

  • DBRM não gerado.

IMS

  • PCB incompatível;

  • SSA incorreta;

  • função DL/I inválida;

  • layout de segmento divergente;

  • ordem incorreta dos parâmetros.

Adabas

  • control block incorreto;

  • buffer incompatível;

  • código de comando inválido;

  • tamanho inconsistente;

  • interface ausente.

O segredo é identificar em qual tecnologia o erro está ocorrendo.


35. O Padawan pergunta: quem executa primeiro?

A resposta depende do programa.

Um programa COBOL batch simples pode seguir diretamente para o compilador.

Um programa CICS pode precisar de tradução.

Um programa Db2 precisa de processamento SQL.

Um programa CICS Db2 precisa dos dois.

Um programa IMS ou Adabas precisa das interfaces corretas durante compilação, linkedição e execução.

Portanto:

Não existe um único fluxo universal.

Existe um fluxo-base que recebe etapas adicionais conforme as tecnologias utilizadas.


36. O verdadeiro papel do COBOL

O COBOL continua sendo o centro da regra de negócio.

Exemplo:

           IF WS-SALDO >= WS-VALOR
               PERFORM DEBITAR-CONTA
               PERFORM REGISTRAR-MOVIMENTO
           ELSE
               MOVE 'SALDO INSUFICIENTE'
                 TO WS-MENSAGEM
           END-IF.

Porém, as operações internas podem utilizar vários subsistemas.

DEBITAR-CONTA        → Db2
REGISTRAR-MOVIMENTO  → IMS
ENVIAR-MENSAGEM      → CICS ou MQ
CONSULTAR-CADASTRO   → Adabas

O COBOL orquestra a regra.

Os subsistemas fornecem capacidades especializadas.


37. Uma analogia com uma missão espacial

Imagine uma nave espacial.

O programa COBOL é o comandante da missão.

Ele decide:

  • qual objetivo deve ser atingido;

  • qual operação deve ser realizada;

  • o que fazer em caso de falha;

  • quando continuar;

  • quando interromper.

O CICS é o centro de controle de missões online.

O Db2 é o banco de dados científico organizado em tabelas.

O IMS é o sistema hierárquico de navegação e mensagens.

O Adabas é outro repositório especializado de dados.

O tradutor CICS e o pré-compilador Db2 são intérpretes que transformam os comandos do comandante em instruções compreensíveis por cada sistema.

O compilador, que veremos no próximo capítulo, será o engenheiro que converterá toda a missão em instruções executáveis pela máquina.


38. Conselhos do Mestre Bellacosa

Ao trabalhar com programas que utilizam CICS, Db2, IMS ou Adabas, sempre pergunte:

  • Quais processadores precisam preparar o fonte?

  • Existe tradução CICS?

  • Existe pré-compilação ou coprocessador Db2?

  • O DBRM foi gerado?

  • O package correto foi criado?

  • O programa utiliza a versão certa do DCLGEN?

  • As host variables estão compatíveis?

  • O SQLCODE está sendo tratado?

  • O RESP CICS está sendo validado?

  • A PCB IMS corresponde ao PSB utilizado?

  • Os códigos de resposta Adabas são verificados?

  • Os copybooks estão na versão correta?

  • O ambiente de compilação utiliza as bibliotecas corretas?

  • O processo automatizado esconde quais etapas?

Essas perguntas transformam um iniciante em um profissional que entende arquitetura.


Conclusão

Um programa COBOL corporativo pode conter muito mais do que instruções COBOL tradicionais.

Comandos EXEC CICS precisam ser traduzidos para que o compilador possa processá-los.

Comandos EXEC SQL precisam ser analisados pelo pré-compilador ou coprocessador Db2, gerando um fonte preparado e um DBRM.

O DBRM será utilizado no BIND para criação de um package.

No IMS, o programa utiliza chamadas DL/I, PCBs, PSBs, DBDs e layouts hierárquicos.

No Adabas, o acesso ocorre por meio de interfaces, control blocks, buffers e códigos de resposta.

Apesar das diferenças, todos esses ambientes compartilham o mesmo princípio:

O programa COBOL descreve a regra de negócio e solicita serviços a subsistemas especializados.

O CICS controla transações.

O Db2 gerencia dados relacionais.

O IMS processa bancos hierárquicos e mensagens.

O Adabas administra dados por meio de sua própria arquitetura.

E o COBOL permanece no centro, coordenando decisões, cálculos, validações e fluxos empresariais.

Mas ainda falta uma etapa fundamental.

Até agora, o código foi apenas preparado.

Ele ainda não se tornou um módulo executável.

No próximo capítulo

Na Parte III — Compilação, Linkedição e Load Library, entraremos no coração da transformação.

Veremos passo a passo:

  • como o compilador analisa o programa;

  • como o fonte se transforma em código objeto;

  • por que o objeto ainda não é o executável final;

  • como funciona o Binder;

  • o que são chamadas estáticas e dinâmicas;

  • como nasce um load module;

  • onde o executável é armazenado;

  • como interpretar return codes e listagens.

Se nesta parte conhecemos os tradutores que preparam a mensagem, no próximo capítulo conheceremos a fábrica que transforma palavras em instruções de máquina.

Prepare outra xícara de café.

A verdadeira transformação do programa COBOL está prestes a começar.

“O Padawan enxerga CICS, Db2, IMS e Adabas como comandos misturados ao COBOL. O especialista enxerga contratos entre arquiteturas, cada uma responsável por uma parte essencial do processamento corporativo.”

Laboratório Forense Bellacosa Mainframe

CSI z/OS: Da Compilação à Execução de um Programa COBOL

Cinco arquivos de evidências revelam como o código-fonte COBOL atravessa copybooks, CICS, Db2, IMS, compilação, Binder, load library, JCL, JES2, memória e CPU até produzir um resultado no IBM Z.

CASO: COBOL-2022-EXEC EVIDÊNCIAS: 05 ARTIGOS AMBIENTE: IBM Z / z/OS STATUS: ARQUIVO ABERTO

Esta investigação técnica apresenta o ciclo completo de um programa COBOL no mainframe IBM Z. A série explica o nascimento do código-fonte, o uso de copybooks, a preparação de comandos CICS e SQL, a geração de código objeto, a atuação do Binder, o armazenamento em load libraries e a execução por JCL, JES2, loader, Language Environment, dispatcher e CPU. Selecione uma evidência abaixo para ler o artigo correspondente dentro do visualizador.

Evidência selecionada Parte I — Código-fonte, bibliotecas e copybooks
Processando evidência digital...

Laudo preliminar: o nascimento do programa

A primeira parte acompanha a transformação da regra de negócio em código-fonte COBOL, explica o papel das bibliotecas e mostra por que copybooks funcionam como contratos de dados compartilhados entre programas.

COBOL código-fonte copybook SYSLIB IBM Z
Bellacosa Mainframe Forensic Lab · Nenhum byte é inocente até que os logs provem o contrário.
Vagner Renato Bellacosa, IBM Champion e especialista em IBM Mainframe
IBM Z17 SYSTEM ONLINE
Sobre o autor

Vagner Renato Bellacosa

IBM Champion 2026 • Especialista em IBM Mainframe

Vagner Renato Bellacosa trabalha com IBM Mainframe desde 1988 , é IBM Champion e especialista em COBOL, CICS, Db2, z/OS e IBM Z. Compartilha experiências profissionais, conhecimento técnico, história da computação e práticas do universo mainframe para aproximar novas gerações das tecnologias que sustentam empresas, bancos e governos ao redor do mundo.

IBM Champion IBM Z COBOL CICS Db2 z/OS Mainframe desde 1988
GitHub LinkedIn
Inicializando conteúdo...