☕ 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 ddf. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta ddf. Mostrar todas as mensagens

quinta-feira, 7 de março de 2024

Mr. Spock Entra no CPD — O Dia em que o Programador COBOL Disse “É Só um SELECT” e Descobriu uma Civilização Inteira Dentro do Db2

 

Bellacosa Mainframe por dentro do Db2

☕ Um Café no Bellacosa Mainframe

Mr. Spock Entra no CPD — O Dia em que o Programador COBOL Disse “É Só um SELECT” e Descobriu uma Civilização Inteira Dentro do Db2

Ou: por que Buffer Pool, IRLM, DDF, Catalog, Directory, Logs, RUNSTATS, Package, RACF, WLM e Parallel Sysplex fazem parte da mesma missão — e por que dizer que Db2 é “apenas um banco de dados” seria, segundo Spock, altamente ilógico

O turno da noite estava tranquilo.

Tranquilo demais.

E todo profissional de mainframe com alguma estrada sabe que essa frase normalmente é seguida por algum desastre.

O monitor do CICS estava verde. O JES2 aparentemente não tinha nada contra a humanidade naquele momento. O RACF não estava distribuindo ICH408I como panfleto em estação de metrô e nenhum operador havia entrado correndo no CPD gritando:

— A PRODUÇÃO PAROU!

Era quase suspeito.

O jovem programador COBOL, ainda naquela fase da carreira em que acreditamos que um programa que compilou também necessariamente funciona, olhou para sua rotina e anunciou:

EXEC SQL
   SELECT NOME,
          SALDO
     INTO :WS-NOME,
          :WS-SALDO
     FROM CLIENTE
    WHERE CONTA = :WS-CONTA
END-EXEC.

Ele sorriu.

— Pronto. É só um SELECT.

Uma sobrancelha levantou-se no outro lado da sala.

Mr. Spock havia entrado no CPD.

Ninguém soube explicar como um oficial científico da Frota Estelar havia conseguido autorização RACF, crachá temporário e acesso à área restrita do datacenter. Mas considerando que o pessoal de infraestrutura já havia liberado consultores externos com justificativas muito piores, ninguém perguntou.

Spock examinou o código.

Depois examinou o programador.

— Sua afirmação contém uma simplificação estatisticamente perigosa.

— Como assim?

— Você acredita ter executado um SELECT. Na realidade, iniciou uma sequência de eventos envolvendo processamento SQL, gerenciamento de memória, otimização, concorrência, storage, catálogo, controle transacional, autorização e possivelmente comunicação distribuída.

O programador ficou olhando para ele.

— Mas voltou um saldo.

— Exatamente. E esta é a parte fascinante.

Assim começa nossa viagem pela arquitetura do Db2 for z/OS.



1. Primeiro diagnóstico de Spock: Db2 não é uma caixa preta

Para muita gente que começa no COBOL, Db2 parece funcionar assim:

COBOL
  ↓
SQL
  ↓
Db2
  ↓
dados

É confortável.

Também está incompleto.

Uma representação mais próxima da realidade seria algo como:

Programa COBOL
      ↓
CICS / Batch / DDF
      ↓
Thread Db2
      ↓
Package
      ↓
Access Path
      ↓
DBM1
      ↓
Buffer Pools
      ↓
Table Space / Index Space
      ↓
DFSMS / Storage

Enquanto isso, paralelamente:

IRLM → locking
Logs → recovery
RACF → segurança
WLM → prioridade
Catalog → metadados
DDF → acesso distribuído

Spock provavelmente resumiria:

“A simplicidade percebida pelo programador é consequência da complexidade absorvida pela infraestrutura.”

E isso é um dos maiores triunfos do mainframe.



2. O que é um Db2 Subsystem?

Vamos começar pela porta da nave.

No z/OS, frequentemente trabalhamos com um Db2 subsystem.

Ele representa uma instância operacional do Db2 dentro daquele ambiente.

Uma empresa poderia ter algo como:

DB2D → desenvolvimento
DB2T → testes
DB2H → homologação
DB2P → produção

Os nomes variam conforme a instalação.

Não existe mandamento dizendo que produção precisa se chamar DB2P.

Aliás, se existe algo que mainframe ensina rapidamente é:

cada empresa tem suas tradições.

Algumas parecem normas técnicas.

Outras parecem decisões tomadas em 1989 por alguém chamado Geraldo, que se aposentou em 2003 e nunca documentou nada.

Curiosidade do CPD

É muito comum o iniciante dizer:

— Estou conectado no Db2.

O veterano pergunta:

— Qual?

E aí começa a aula.

Um mesmo ambiente pode possuir múltiplos subsystems.

Por isso entender onde seu programa está executando é tão importante quanto entender o que ele executa.



3. DBM1 — a sala de máquinas

No coração da arquitetura encontramos o DBM1, o Database Services Address Space.

É onde ocorre uma quantidade enorme do trabalho relacionado ao banco.

Dentro dessa paisagem aparecem conceitos como:

  • Buffer Pools;

  • EDM Pool;

  • estruturas de processamento;

  • threads;

  • acesso a dados;

  • gerenciamento interno;

  • execução de SQL.

Pense no DBM1 como a engenharia da Enterprise.

Você pode estar sentado confortavelmente na ponte dizendo:

— Warp 5.

Mas alguém lá embaixo precisa fazer o motor funcionar.

No COBOL seria:

EXEC SQL
   SELECT SALDO
     INTO :WS-SALDO
     FROM CONTA
    WHERE NUM_CONTA = :WS-CONTA
END-EXEC.

Do ponto de vista do desenvolvedor:

SELECT → resultado

Do ponto de vista da infraestrutura:

solicitação
→ contexto de execução
→ access path
→ memória
→ índice
→ páginas
→ locking
→ eventualmente I/O
→ retorno

“É só um SELECT” começa a parecer uma frase corajosa.


4. Buffer Pool — o truque que evita transformar cada consulta em uma excursão ao storage

Se existe um conceito que todo programador Db2 deveria entender cedo, é Buffer Pool.

Imagine que você tenha uma tabela com 100 milhões de registros.

O programa procura:

SELECT NOME
FROM CLIENTE
WHERE ID_CLIENTE = 928173;

Fisicamente, os dados estão persistidos em storage.

Se toda consulta tivesse que buscar diretamente no disco, teríamos:

programa
   ↓
Db2
   ↓
storage
   ↓
I/O
   ↓
Db2
   ↓
programa

Constantemente.

A performance seria digna de uma carroça klingon.

O Buffer Pool existe justamente para manter páginas de dados e índices em memória.

              MEMÓRIA

        ┌───────────────────┐
        │    BUFFER POOL    │
        │                   │
        │ páginas de dados  │
        │ páginas de índice │
        └─────────┬─────────┘
                  │
          página ausente?
                  │
              SIM ↓
               STORAGE

Se a página já está em memória, evitamos determinado I/O físico.

Essa diferença pode ser gigantesca.


5. O programador pensa em linha; o Db2 frequentemente pensa em página

Aqui está uma mudança de mentalidade poderosa.

O programador escreve:

WHERE CONTA = 12345

Ele pensa:

“Quero essa linha.”

O Db2 precisa lidar com estruturas de armazenamento organizadas em pages.

Então conceitualmente:

linha solicitada
      ↓
página onde ela está
      ↓
Buffer Pool
      ↓
storage se necessário

Isso explica por que performance de banco não pode ser estudada pensando apenas no SQL textual.

Existem questões envolvendo:

  • número de páginas;

  • organização dos dados;

  • índices;

  • clustering;

  • seletividade;

  • Buffer Pool;

  • I/O;

  • estatísticas.

Spock talvez acrescentasse:

— Confundir linha lógica com armazenamento físico seria ilógico.

O DBA responderia:

— Finalmente alguém me entende.


6. Table Space — onde a tabela mora

Uma tabela Db2 precisa viver em uma estrutura apropriada de armazenamento.

Entra o Table Space.

Podemos visualizar:

DATABASE
   │
   ├── TABLE SPACE
   │      │
   │      └── TABLE
   │
   └── INDEX SPACE
          │
          └── INDEX

Aqui vale uma distinção importante.

Table Space e Index Space não são exatamente a mesma coisa.

A tabela reside no Table Space.

O índice possui sua própria estrutura associada.

Essa diferença aparece bastante quando começamos a estudar:

  • utilities;

  • administração;

  • recovery;

  • reorganização;

  • performance.


7. Índice — o tricorder do Db2

Imagine um arquivo com 20 milhões de clientes.

Você quer:

SELECT *
FROM CLIENTE
WHERE CPF = '12345678900';

Sem um caminho adequado, o Db2 pode precisar examinar uma grande quantidade de dados.

Com um índice apropriado:

CPF procurado
    ↓
ÍNDICE
    ↓
localização das páginas
    ↓
dados

Parece maravilhoso.

E é.

Mas existe uma regra que iniciantes aprendem um pouco depois:

índice não é almoço grátis.

Cada índice pode representar:

  • armazenamento;

  • manutenção;

  • custo em INSERT;

  • custo em UPDATE;

  • custo em DELETE;

  • necessidade de reorganização;

  • estatísticas;

  • complexidade adicional.

Criar índice para absolutamente tudo seria como equipar cada tripulante da Enterprise com quinze tricorders.

Em algum momento alguém precisa carregar aquilo.


8. O Optimizer — Spock trabalhando dentro do Db2

Talvez nenhum componente mereça mais o título de “Mr. Spock interno” do que o optimizer.

Você escreve:

SELECT C.NOME,
       P.VALOR
FROM CLIENTE C
JOIN PAGAMENTO P
  ON P.ID_CLIENTE = C.ID_CLIENTE
WHERE C.UF = 'SP';

Você disse o que deseja.

Mas existe mais de uma maneira de conseguir aquilo.

O Db2 pode precisar decidir:

  • qual tabela acessar primeiro;

  • qual índice usar;

  • se deve usar índice;

  • método de join;

  • ordem das tabelas;

  • custo estimado;

  • paralelismo;

  • quantidade provável de linhas.

Esse conjunto de decisões produz o chamado access path.

Simplificando:

SQL
 ↓
Optimizer
 ↓
estatísticas
 ↓
custos estimados
 ↓
Access Path
 ↓
execução

É por isso que dois SQLs que entregam exatamente o mesmo resultado podem ter performances completamente diferentes.


9. RUNSTATS — não mande Spock calcular com sensores quebrados

O optimizer precisa tomar decisões.

Mas baseado em quê?

Em informações sobre os objetos e os dados.

Entram aí as statistics.

Imagine esta distribuição:

CLIENTE

SP = 5.000.000
RJ = 2.000.000
MG = 1.500.000
AC =    30.000
RR =    20.000

Agora compare:

WHERE UF = 'SP'

com:

WHERE UF = 'RR'

A seletividade pode ser radicalmente diferente.

O optimizer precisa ter noção disso.

Ferramentas como RUNSTATS ajudam a coletar estatísticas utilizadas nas decisões de otimização.

Metáfora Bellacosa

Imagine Spock calculando a rota até Vulcano.

Mas você fornece um mapa feito antes da construção das últimas cinquenta colônias.

Ele continua sendo brilhante.

Só está usando informação ruim.

Em banco de dados:

optimizer bom + estatística ruim = possibilidade de access path ruim.

Por isso performance não é apenas:

— “Reescreve esse SELECT.”

Às vezes o SQL estava perfeitamente aceitável.

O ambiente é que mudou.


10. EDM Pool — aquilo que não queremos reconstruir a toda hora

Outro componente importante é o EDM Pool — Environmental Descriptor Manager Pool.

Ele mantém estruturas importantes usadas pelo Db2, incluindo informações relacionadas a packages e estruturas de execução.

O conceito pedagógico é simples:

aquilo que custa processamento para construir pode ser vantajoso manter disponível em memória.

Não confunda EDM Pool com Buffer Pool.

O Buffer Pool trabalha fortemente com páginas de dados e índices.

O EDM Pool está associado a outras estruturas internas necessárias à execução.

Mas ambos ilustram uma obsessão saudável de sistemas de alta performance:

evitar trabalho desnecessário.


11. IRLM — ninguém toca nesse registro sem conversar com o segurança

Chegamos ao IRLM — Internal Resource Lock Manager.

O problema que ele ajuda a resolver é clássico.

Imagine:

Programa A

UPDATE CONTA
SET SALDO = 500
WHERE CONTA = 100;

Programa B

simultaneamente:

UPDATE CONTA
SET SALDO = 800
WHERE CONTA = 100;

Quem ganha?

Quem espera?

Quem pode ler?

Em qual momento?

Que isolamento estamos usando?

Sem controle de concorrência, banco de dados financeiro viraria bingo.

O IRLM participa do gerenciamento de locks.

Podemos pensar:

Programa A ─────┐
                ├── IRLM ── recurso
Programa B ─────┘

Locks existem para preservar consistência em ambientes concorrentes.

E ambiente mainframe costuma ser sinônimo de concorrência em escala bastante séria.


12. Deadlock — quando dois oficiais se recusam a sair da porta

Considere:

Programa A tem recurso X
Programa B tem recurso Y

Agora:

A precisa de Y
B precisa de X

Resultado:

A ───── espera por Y
↑                 │
│                 ↓
X espera por ───── B

Temos um deadlock.

Os dois ficariam esperando eternamente se o sistema não identificasse a situação.

O Db2 precisa detectar o problema e selecionar uma unidade de trabalho para ser interrompida.

Dica para COBOL iniciante

Quando ocorrer erro associado a deadlock ou timeout, não trate imediatamente como:

“Db2 caiu.”

Não.

Na maioria das vezes Db2 está vivíssimo.

Talvez vivo até demais.

Está protegendo a consistência contra seus programas.


13. LOCK não é LATCH

Esse é um pequeno easter egg técnico para quando você estiver conversando com alguém mais experiente.

Lock e latch não são sinônimos.

Locks estão fortemente associados ao controle lógico/transacional de concorrência.

Latches são mecanismos internos de serialização mais leves usados para proteger determinadas estruturas internas.

Portanto quando alguém disser:

— Temos contenção.

Pergunte:

— Que tipo?

Você ganhará pelo menos +3 pontos de experiência mainframe.

Talvez até um café.


14. Logs — a caixa-preta da Enterprise

Agora entramos em uma das áreas mais importantes do Db2.

Imagine:

UPDATE CONTA
SET SALDO = SALDO - 100
WHERE NUM_CONTA = 123;

Uma alteração aconteceu.

O sistema precisa ter capacidade de preservar consistência e recuperar-se de falhas.

Por isso existe toda uma arquitetura de logging.

Em uma visão simplificada:

alteração
   ↓
Log Buffer
   ↓
Active Logs
   ↓
Archive Logs

Os logs guardam informações fundamentais para:

  • recovery;

  • rollback;

  • restart;

  • consistência transacional.

Sem logs, um banco corporativo seria praticamente um caderno escrito a lápis durante um terremoto.


15. COMMIT — quatro letras e uma enorme responsabilidade

No COBOL:

EXEC SQL
   UPDATE CONTA
      SET SALDO = :WS-NOVO-SALDO
    WHERE NUM_CONTA = :WS-CONTA
END-EXEC.

EXEC SQL
   COMMIT
END-EXEC.

COMMIT não significa simplesmente:

“terminei.”

Ele marca uma fronteira transacional importante.

Imagine:

UPDATE
INSERT
DELETE
UPDATE
   ↓
COMMIT

A unidade de trabalho foi confirmada.

O gerenciamento correto de commit é particularmente importante em batch.

Por quê?

Imagine processar cinco milhões de registros e só dar COMMIT no final.

Isso pode aumentar:

  • volume de locks;

  • duração de locks;

  • quantidade de trabalho a desfazer;

  • impacto de rollback;

  • pressão operacional.

Por outro lado, dar COMMIT a cada registro também pode ser inadequado.

A frequência de commit deve ser desenhada conscientemente.

Não existe “número mágico universal”.


16. ACID — as quatro leis de Vulcano das transações

O Db2 trabalha sob princípios transacionais tradicionalmente descritos pela sigla ACID.

Atomicity

Ou a unidade de trabalho ocorre adequadamente ou precisamos impedir resultado parcial inconsistente.

Consistency

O banco deve passar de um estado válido para outro.

Isolation

Transações concorrentes precisam coexistir de forma controlada.

Durability

Depois de confirmado, o resultado deve sobreviver conforme as garantias do sistema.

Considere uma transferência:

Conta Kirk  -100
Conta Spock +100

O universo proibido seria:

Conta Kirk  -100

💥 falha

Conta Spock +0

O dinheiro sumiu em algum buraco de minhoca.

O banco central provavelmente não aceitaria “anomalia espaço-temporal” como justificativa.


17. Active Log, Archive Log e a arte de voltar no tempo sem DeLorean

Os Active Logs participam diretamente das operações correntes de logging do Db2.

Com o avanço do processamento, parte dessas informações pode ser arquivada em Archive Logs.

Conceitualmente:

atividade recente
       ↓
Active Logs
       ↓
arquivamento
       ↓
Archive Logs

Essa arquitetura é um dos pilares das capacidades de recovery.

E aqui entra outro personagem importante.


18. IMAGE COPY — a fotografia antes da tempestade

Uma Image Copy funciona como uma cópia utilizada em estratégias de recuperação dos objetos Db2.

Imagine:

00:00
IMAGE COPY
   │
   │ logs
   │ logs
   │ logs
   │
13:42
falha

Dependendo da estratégia e do cenário, combinamos:

IMAGE COPY
+
LOGS
+
procedimento de recovery

para reconstruir o estado necessário.

Isso é muito mais sofisticado do que aquela frase genérica:

“Restauramos o backup.”

Em ambientes grandes, recovery é ciência.


19. Catalog — o cartório galáctico

Imagine que você cria:

CREATE TABLE PLANETA
(
   ID_PLANETA INTEGER,
   NOME       VARCHAR(80),
   QUADRANTE  CHAR(1)
);

Db2 precisa saber:

  • que a tabela existe;

  • quais colunas existem;

  • seus tipos;

  • seus índices;

  • seus relacionamentos;

  • tablespace;

  • authorities;

  • estatísticas;

  • dependências.

Essas informações vivem no universo do Db2 Catalog.

A metáfora é simples:

Os dados são cidadãos.
O Catalog é o cartório.

Quer saber sobre determinado objeto?

Frequentemente você consulta tabelas do catálogo.


20. Directory — o compartimento em que Spock recomenda não mexer sem motivo

Além do Catalog existe o Db2 Directory.

São estruturas internas essenciais ao próprio funcionamento do Db2.

Uma distinção simplificada:

CATALOG
→ metadados administrativos acessíveis

DIRECTORY
→ estruturas internas do próprio Db2

Não trate os dois termos como sinônimos.

É uma daquelas diferenças que parece acadêmica no começo.

Depois você começa a estudar internals e percebe por que existia.


21. DDF — o momento em que o mainframe abre as portas da nave

Db2 for z/OS não serve apenas a COBOL rodando dentro do próprio mainframe.

Aplicações externas podem acessar Db2 utilizando DDF — Distributed Data Facility.

Por exemplo:

Java
Python
.NET
Linux
Windows
Cloud
   │
   ↓
DRDA
   ↓
TCP/IP
   ↓
DDF
   ↓
Db2 for z/OS

Isso destrói outro mito antigo:

“Mainframe é uma ilha.”

Há décadas não é.

O mainframe moderno pode conversar com praticamente o ecossistema corporativo inteiro.


22. DRDA — o diplomata entre mundos relacionais

DRDA — Distributed Relational Database Architecture fornece mecanismos padronizados para acesso distribuído a bancos relacionais.

Você pode imaginar:

Aplicação externa
      ↓
Driver
      ↓
DRDA
      ↓
TCP/IP
      ↓
DDF
      ↓
Db2

Ou seja, aquele programa Java no Kubernetes pode estar consultando informações que no final vivem no Db2 for z/OS.

O desenvolvedor Java talvez nem saiba.

E em muitos casos nem precisa saber.

Mas o arquiteto deveria.


23. COBOL + CICS + Db2 — o triângulo clássico

Agora voltamos à nossa velha sala de produção.

Um caminho clássico:

usuário
   ↓
CICS
   ↓
Programa COBOL
   ↓
SQL
   ↓
Db2

No programa:

EXEC SQL
   SELECT SALDO
     INTO :WS-SALDO
     FROM CONTA
    WHERE NUM_CONTA = :WS-CONTA
END-EXEC.

Parece natural.

Mas como o SQL foi parar dentro daquele programa executável?

Aí vem uma parte fundamental que muitos cursos passam rápido demais.


24. PRECOMPILE — COBOL e SQL precisam conversar

COBOL puro não interpreta nativamente aquele EXEC SQL.

Existe uma etapa de preparação.

De forma tradicional e simplificada:

Fonte COBOL + SQL
        ↓
   PRECOMPILER
      ┌─┴─────────────┐
      ↓               ↓
COBOL modificado     DBRM
      ↓               ↓
Compiler             BIND
      ↓               ↓
Object              Package
      ↓
Link
      ↓
Load Module

O precompiler identifica instruções SQL e prepara os elementos necessários para o processamento posterior.

Esse fluxo explica por que desenvolvimento COBOL + Db2 envolve muito mais que:

compilar
executar

25. DBRM e PACKAGE — o que Spock realmente queria encontrar

O DBRM guarda informações extraídas das instruções SQL durante a preparação.

Posteriormente ocorre o BIND.

O BIND gera estruturas como packages utilizadas pela execução.

Simplificando:

SQL
 ↓
DBRM
 ↓
BIND
 ↓
PACKAGE
 ↓
Access Path

O package é extremamente importante.

Porque o programa COBOL pode continuar exatamente igual enquanto o comportamento do SQL muda por razões relacionadas a:

  • rebind;

  • novas estatísticas;

  • novos índices;

  • alteração do ambiente;

  • manutenção;

  • mudança de release;

  • access path diferente.

Essa é uma das primeiras grandes revelações para quem trabalha com performance.

Código-fonte igual não significa necessariamente comportamento operacional idêntico.


26. BIND — o casamento arranjado entre SQL e Db2

O BIND é uma etapa fundamental da vida do SQL estático.

É quando informações do DBRM são utilizadas para produzir um package.

E ali são tomadas decisões importantíssimas.

Se você aprende apenas a programar:

EXEC SQL ...

mas não aprende:

  • package;

  • bind;

  • rebind;

  • access path;

você aprendeu a dirigir, mas nunca abriu o capô.

Serve.

Até o carro começar a fazer barulho.


27. O verdadeiro caminho de um SELECT

Nosso jovem programador agora olha novamente para:

SELECT SALDO
FROM CONTA
WHERE NUM_CONTA = :WS-CONTA;

Mas depois da aula de Spock ele já enxerga outra coisa:

COBOL
  ↓
CICS
  ↓
Thread Db2
  ↓
Package
  ↓
Access Path
  ↓
Index?
  ↓
Buffer Pool
  ↓
Página disponível?
   ├── SIM → usa memória
   └── NÃO → solicita I/O
                  ↓
                Storage
                  ↓
              Buffer Pool
                  ↓
                 Db2
                  ↓
                COBOL

Aquela linha de SQL agora parece uma missão espacial inteira.

E é exatamente essa mudança de percepção que diferencia alguém que apenas escreve SQL de alguém que começa a compreender o Db2.


28. DFSMS — quando descobrimos que storage também faz parte do banco

Db2 não administra storage em um vácuo.

No z/OS existe integração com o universo do DFSMS — Data Facility Storage Management Subsystem.

Entram conceitos como:

  • datasets;

  • volumes;

  • storage classes;

  • management classes;

  • data classes;

  • políticas SMS;

  • VSAM.

Esse ponto é profundamente “mainframe”.

Em plataformas mais simples, desenvolvedor e banco às vezes parecem universos separados do storage.

No z/OS, você começa a perceber que:

banco
+
storage
+
sistema operacional
+
segurança
+
workload management

formam uma arquitetura integrada.


29. E então aparece VSAM escondido atrás da cortina

Essa curiosidade normalmente surpreende o iniciante.

Db2 for z/OS utiliza infraestrutura de armazenamento associada ao ecossistema VSAM para seus datasets.

Então podemos desenhar:

Db2 object
   ↓
Table Space
   ↓
datasets
   ↓
VSAM / DFSMS
   ↓
storage

Mas atenção:

Isso NÃO significa que Db2 seja simplesmente “um VSAM com SQL”.

Db2 acrescenta um universo inteiro:

  • modelo relacional;

  • SQL;

  • optimizer;

  • locking;

  • logging;

  • recovery;

  • catálogo;

  • integridade;

  • transações.

VSAM e Db2 possuem propósitos e abstrações diferentes.


30. RACF — nem Spock acessa folha de pagamento sem autorização

Agora imagine:

SELECT *
FROM FOLHA_PAGAMENTO;

Tecnicamente válido.

Mas deveria qualquer programa poder executá-lo?

Claro que não.

Entram mecanismos de segurança do ambiente, incluindo integração com RACF e os mecanismos de autorização do próprio Db2.

A regra fundamental:

SQL válido
≠
SQL autorizado

E ainda bem.

Imagine um estagiário descobrindo:

SELECT *
FROM SALARIOS_DIRETORIA;

e dizendo:

— Funcionou no desenvolvimento.

Produção:

ICH408I

O RACF entra em cena como o segurança vulcano:

— Seu entusiasmo não constitui autorização.


31. WLM — todos são iguais, mas alguns workloads precisam responder em 100 milissegundos

Outro componente importante do ecossistema é o WLM — Workload Manager.

O z/OS pode administrar workloads conforme objetivos definidos.

Imagine simultaneamente:

Transação PIX
Consulta de saldo
Batch de faturamento
Relatório gerencial
Backup
Compilação
Job de teste

Todos querem CPU.

Todos acham que são importantes.

Alguns realmente são.

WLM ajuda o sistema a priorizar recursos conforme políticas de serviço.

Pense nele como o oficial de operações da ponte:

“Essa transação é crítica.”
“Esse relatório pode esperar.”
“Esse batch precisa terminar antes das 06:00.”

É uma das grandes razões pelas quais mainframes conseguem misturar workloads muito distintos de forma eficiente.


32. MQ, CICS, TCP/IP e companhia — Db2 nunca esteve sozinho

Observe uma arquitetura corporativa típica:

Mobile
  ↓
API
  ↓
z/OS Connect
  ↓
CICS
  ↓
COBOL
  ↓
Db2

Ao lado:

COBOL
  ↓
MQ
  ↓
sistema externo

Com:

RACF → segurança
WLM  → prioridades
DFSMS → storage
TCP/IP → comunicação
JES → batch

O segredo do mainframe nunca foi um único produto.

É a integração.

Isso vale para Db2 também.


33. Parallel Sysplex — quando uma Enterprise deixa de ser suficiente

Agora entramos em território mais avançado.

Em ambientes de altíssima disponibilidade, Db2 pode operar em configuração de Data Sharing, dentro do universo do Parallel Sysplex.

Imagine:

            Aplicações
                │
      ┌─────────┼─────────┐
      ↓         ↓         ↓
    DB2A      DB2B      DB2C
      │         │         │
      └─────────┼─────────┘
                ↓
      dados compartilhados

Vários membros Db2 podem trabalhar cooperativamente.

Isso proporciona benefícios associados a:

  • disponibilidade;

  • escalabilidade;

  • flexibilidade operacional;

  • continuidade.

Mas surge um problema lógico.

Se DB2A e DB2B acessam os mesmos dados:

Como garantir coerência?

Excelente pergunta, jovem cadete.


34. Coupling Facility e Group Buffer Pool

No Data Sharing entram estruturas disponibilizadas através da Coupling Facility.

Entre elas aparecem mecanismos relacionados a Group Buffer Pools e coordenação entre membros.

Simplificando:

DB2A                     DB2B
 │                         │
Buffer Pool            Buffer Pool
 │                         │
 └──────────┐   ┌──────────┘
            ↓   ↓
      Coupling Facility
            │
      Group Buffer Pool

Se vários membros acessam os mesmos dados, precisamos impedir que cada um viva numa realidade alternativa.

Afinal, nem Star Trek resolve consistência eventual com universo paralelo em folha de pagamento.


35. O programa funciona, mas está lento. E agora?

Este é um dos momentos mais importantes da carreira.

Iniciante:

“O SQL está lento.”

Profissional experiente:

“Vamos descobrir por quê.”

Possibilidades:

SQL ruim
estatísticas inadequadas
índice ausente
índice inadequado
access path diferente
muito I/O
Buffer Pool pressionado
contenção
locks
volume de dados cresceu
commit inadequado
CPU
storage
DDF
rede
WLM

Percebe a diferença?

Performance não é adivinhação.

É investigação.

Mr. Spock aprovaria.


36. Checklist Bellacosa para o COBOL iniciante

Quando um SQL apresentar problema, pergunte nesta ordem aproximada:

  1. O SQL está logicamente correto?

  2. Quantas linhas deveriam retornar?

  3. Quantas realmente retornam?

  4. Existe índice apropriado?

  5. Qual access path está sendo usado?

  6. As estatísticas estão atualizadas?

  7. Houve REBIND recentemente?

  8. O volume de dados mudou?

  9. Existe contenção?

  10. Existe timeout ou deadlock?

  11. O programa está dando commits adequadamente?

  12. O problema acontece sempre ou apenas em horários específicos?

  13. É batch, CICS ou acesso distribuído?

  14. Existe pressão de CPU ou I/O?

  15. Houve mudança no ambiente?

Já percebeu que:

“Está lento porque Db2 está lento”

é praticamente uma não-explicação.


37. O easter egg do SQLCODE

Todo programador COBOL conhece algum momento assim:

IF SQLCODE NOT = 0
    DISPLAY 'ERRO DB2'
END-IF

Spock vê isso.

Fica silencioso durante oito segundos.

Depois diz:

— Fascinante. Você descartou todas as informações diagnósticas e preservou apenas o fato de que algo ocorreu.

Não seja esse programador.

SQLCODE é começo de diagnóstico.

Não fim.

Considere também as informações disponibilizadas por SQLCA e mecanismos apropriados de diagnóstico.

A mensagem:

ERRO DB2

é quase equivalente a chamar a manutenção dizendo:

“A máquina não está normal.”

Boa sorte.


38. Segundo easter egg: SELECT *

Spock observa:

SELECT *
FROM CLIENTE;

— Por que você deseja todas as colunas?

— Porque é mais fácil.

— Essa justificativa não parece relacionada à necessidade funcional.

Silêncio.

SELECT * pode ser conveniente em testes.

Em aplicação profissional, pense nas colunas realmente necessárias.

Isso melhora:

  • clareza;

  • manutenção;

  • previsibilidade;

  • potencialmente movimentação de dados;

  • dependências.

Escreva o que precisa.

Não o que seus dedos acharam mais curto.


39. Terceiro easter egg: COMMIT dentro do loop sem pensar

Outro clássico:

PERFORM UNTIL EOF
   ...
   EXEC SQL
      UPDATE ...
   END-EXEC

   EXEC SQL
      COMMIT
   END-EXEC
END-PERFORM

Talvez seja correto.

Talvez seja horrível.

Depende.

A pergunta certa não é:

“Posso dar COMMIT aqui?”

É:

“Qual unidade de trabalho faz sentido para esse processo?”

Em batch, estratégia de commit precisa considerar:

  • restart;

  • volume;

  • locking;

  • recuperação;

  • consistência;

  • desempenho.


40. A diferença entre saber SQL e saber Db2

Este talvez seja o ponto mais importante do artigo.

Conhecer:

SELECT
INSERT
UPDATE
DELETE
JOIN
GROUP BY

é conhecer SQL.

Essencial.

Mas conhecer Db2 for z/OS envolve também:

Subsystem
DBM1
MSTR
IRLM
DDF
Buffer Pool
EDM Pool
Table Space
Index Space
Catalog
Directory
Package
DBRM
BIND
Access Path
RUNSTATS
Logs
Recovery
Image Copy
DFSMS
RACF
WLM
Data Sharing
Parallel Sysplex

É outro nível de entendimento.

E você não precisa aprender tudo no primeiro mês.

Apenas precisa saber que essas camadas existem.


41. Um caminho de estudo em sete missões

Se eu estivesse orientando um programador COBOL iniciante, faria assim.

Missão 1 — SQL

Aprenda bem:

SELECT
INSERT
UPDATE
DELETE
JOIN
CURSOR
NULL
SQLCODE

Missão 2 — COBOL + Db2

Entenda:

host variables
SQLCA
cursor
commit
rollback

Missão 3 — preparação

Estude:

Precompile
DBRM
Bind
Package
Plan

Missão 4 — armazenamento

Estude:

Table Space
Index
Page
Buffer Pool

Missão 5 — optimizer

Estude:

Access Path
RUNSTATS
EXPLAIN
seletividade
cardinalidade

Missão 6 — concorrência

Estude:

Lock
Timeout
Deadlock
Isolation
Commit

Missão 7 — arquitetura z/OS

Finalmente:

IRLM
DDF
DFSMS
RACF
WLM
Logs
Recovery
Data Sharing

Quando terminar isso, volte à Missão 1.

Você descobrirá que seu antigo SELECT mudou completamente.


42. A grande revelação

Nosso programador volta finalmente ao código:

EXEC SQL
   SELECT NOME,
          SALDO
     INTO :WS-NOME,
          :WS-SALDO
     FROM CLIENTE
    WHERE CONTA = :WS-CONTA
END-EXEC.

Antes ele via:

“Busca o saldo.”

Agora enxerga:

Aplicação
 ↓
contexto Db2
 ↓
Package
 ↓
Access Path
 ↓
Optimizer
 ↓
Statistics
 ↓
Index
 ↓
Buffer Pool
 ↓
Page
 ↓
possível I/O
 ↓
Storage
 ↓
controle transacional
 ↓
segurança
 ↓
resultado

Ele olha para Spock.

— Então nunca foi “só um SELECT”.

Spock responde:

— Correto.

— E tudo isso acontece para devolver duas colunas?

— Correto.

— Isso é completamente insano.

Spock levanta novamente a sobrancelha.

— Eu escolheria a palavra “engenharia”.


Epílogo — Vida longa ao Db2

Existe uma tendência natural de ensinar mainframe de fora para dentro.

Primeiro mostramos:

IDENTIFICATION DIVISION.

Depois:

EXEC SQL.

Depois CICS.

Depois JCL.

Está correto.

O problema é quando o aprendizado para ali.

Um profissional começa realmente a amadurecer quando pergunta:

O que existe atrás dessa instrução?

Db2 é um ótimo exemplo.

Por trás do humilde:

SELECT SALDO

existe uma arquitetura desenhada para funcionar em ambientes nos quais:

  • milhões de transações podem acontecer;

  • múltiplas aplicações disputam recursos;

  • dados precisam permanecer consistentes;

  • falhas precisam ser recuperáveis;

  • workloads críticos têm prioridade;

  • segurança precisa ser auditável;

  • sistemas externos precisam acessar dados;

  • operações precisam continuar durante enormes cargas.

É por isso que Db2 for z/OS não deve ser estudado apenas como linguagem SQL.

Ele deve ser entendido como parte de uma arquitetura transacional completa.

Buffer Pool ensina que memória é estratégia.

IRLM ensina que concorrência precisa de disciplina.

RUNSTATS ensina que inteligência depende de boas informações.

Logs ensinam que sobreviver ao desastre é tão importante quanto evitar o desastre.

RACF ensina que capacidade técnica não significa autorização.

WLM ensina que nem todo trabalho possui a mesma urgência.

DDF ensina que mainframe não é uma ilha.

Parallel Sysplex ensina que alta disponibilidade é uma arquitetura, não uma frase de marketing.

E o humble COBOL programador aprende finalmente uma verdade que acompanha muita gente durante décadas de carreira:

quanto mais você entende o que existe abaixo do seu programa, melhores ficam as decisões que você toma acima dele.

Spock deixou o CPD pouco antes das três da manhã.

Na saída, encontrou o operador.

— O senhor está indo embora?

— Acredito que meu trabalho aqui terminou.

— E o garoto?

Spock olhou através do vidro para o programador, que naquele momento pesquisava access path, Buffer Pool e RUNSTATS enquanto sua caneca de café esfriava ao lado do terminal.

— Ele cometeu um erro comum.

— Qual?

— Pensou que estava aprendendo apenas COBOL.

Spock fez uma pequena pausa.

— Agora começou a aprender sistemas.

O elevador fechou.

No monitor apareceu:

DSN SYSTEM(...)

Depois:

READY

E em algum lugar profundamente dentro do z/OS, um Buffer Pool continuou recebendo páginas, o IRLM continuou arbitrando recursos, os logs continuaram registrando transações e o velho Db2 fez aquilo que vem fazendo há décadas:

carregar boa parte do mundo corporativo nas costas sem exigir que o usuário saiba quantas maravilhas estavam acontecendo atrás de um simples SELECT.

🖖 Vida longa, prosperidade e um access path decente.

quarta-feira, 14 de dezembro de 2022

Db2 Connect e a Banheira do Tempo — Quando Quatro Programadores Voltaram a 1986, Encontraram um JDBC no Fliperama e Descobriram que TCP/IP Não Sabia Executar SELECT

 
Bellacosa Mainframe e o db2 connect e a banheira do tempo

☕ Um Café no Bellacosa Mainframe

Db2 Connect e a Banheira do Tempo — Quando Quatro Programadores Voltaram a 1986, Encontraram um JDBC no Fliperama e Descobriram que TCP/IP Não Sabia Executar SELECT

Ou: o jovem padawan COBOL entrou numa banheira instalada ao lado do datacenter, Igor derramou energético sobre o painel do DDF, o Db2 for z/OS abriu um DBAT e todos descobriram que conexão, sessão, transação e pacote não são quatro nomes para a mesma coisa



Prólogo — A banheira que apontava para o mainframe

Era sexta-feira, 23h47, no datacenter Bellacosa Mainframe.

O processamento noturno já havia começado, o café estava com gosto de óleo hidráulico e Igor acabara de instalar uma banheira de hidromassagem ao lado do rack de desenvolvimento.

— Para reduzir o estresse da equipe — explicou ele, segurando um cabo de rede molhado.

Sobre a borda da banheira havia um notebook executando uma aplicação Java. Na tela, uma mensagem nada relaxante:

ERRORCODE=-4499
SQLSTATE=08001

A aplicação precisava consultar uma tabela no Db2 for z/OS, mas não conseguia estabelecer a conexão.

O jovem padawan COBOL examinou o diagrama preso na parede:

Aplicação → API → TCP/IP → Db2

— Parece simples. Se o ping funciona, o banco deveria funcionar.

Nesse instante, Igor deixou cair uma lata de energético sobre o controlador da banheira. As luzes piscaram, o ventilador do mainframe mudou de tom e os três foram transportados para 1986.

Quando abriram os olhos, havia terminais verdes, cabelos volumosos, fitas cassete e um operador perguntando:

— Que negócio é esse de JDBC? É uma banda de rock?

Aquela viagem ensinaria uma lição importante:

Um diagrama simples pode apresentar a direção da estrada, mas não explica quem dirige o carro, qual idioma é falado na fronteira, quem verifica o passaporte e quem executa a SQL quando todos finalmente chegam ao Db2.



1. O que é Db2 Connect?

Db2 Connect é a família de recursos, drivers, clientes, componentes e direitos de uso que permite a aplicações distribuídas acessar bancos Db2 executados principalmente em plataformas host, como:

  • Db2 for z/OS;

  • Db2 for IBM i;

  • Ambientes host compatíveis previstos pela solução;

  • Outros servidores Db2 suportados, conforme produto, versão e driver.

Imagine uma aplicação Java executada em Linux que precisa consultar uma conta bancária armazenada no Db2 for z/OS.

Os dois sistemas vivem em mundos diferentes:

Aplicação Java
Linux
JDBC
Objetos Java
UTF-8
Containers

Do outro lado:

Db2 for z/OS
DDF
DBAT
Packages
RACF
WLM
Tablespaces

Db2 Connect participa da construção da ponte entre esses mundos.

Mas aqui começa a primeira armadilha: Db2 Connect não é apenas “um conversor de TCP/IP”.

TCP/IP é o transporte. Ele entrega bytes de um endereço a outro. Não conhece:

  • SELECT;

  • INSERT;

  • Cursor;

  • Package;

  • COMMIT;

  • ROLLBACK;

  • SQLCODE;

  • Result set;

  • Unidade de trabalho.

O diálogo de banco utiliza principalmente o DRDA — Distributed Relational Database Architecture. A IBM define Db2 Connect como uma implementação da arquitetura DRDA para acesso distribuído a servidores Db2. IBM — Db2 Connect e DRDA

A arquitetura básica não é apenas:

Aplicação → TCP/IP → Db2

É mais próxima de:

Aplicação
    ↓
API
    ↓
Driver IBM
    ↓
DRDA
    ↓
TLS, quando configurado
    ↓
TCP/IP
    ↓
DDF
    ↓
DBAT
    ↓
Package e SQL
    ↓
Dados

O infográfico original mostra o portal da máquina do tempo. Nosso trabalho é abrir a tampa e descobrir quais peças fazem a viagem acontecer.



2. Aplicação, linguagem, API e driver não são a mesma coisa

O diagrama coloca no mesmo bloco:

  • JDBC;

  • ADO.NET;

  • Python;

  • SQL;

  • ODBC;

  • Db2 CLI;

  • Perl;

  • OLE DB;

  • Embedded SQL;

  • Ruby.

O problema é que esses elementos pertencem a categorias diferentes.

CategoriaExemplosO que representa
LinguagemJava, Python, Ruby, Perl, PHP, COBOLLinguagem em que o programa foi escrito
APIJDBC, ODBC, CLI, ADO.NETInterface usada pelo programa para solicitar serviços do banco
DriverIBM JCC, IBM ODBC/CLI Driver, IBM .NET ProviderImplementação que conversa efetivamente com o Db2
Linguagem de bancoSQLForma de consultar e alterar os dados
Técnica de programaçãoEmbedded SQL, SQLJForma de incorporar SQL ao programa

Dizer que Python, JDBC e SQL são todos “APIs” seria como dizer que COBOL, CICS e EXEC CICS READ são a mesma coisa.

Eles cooperam, mas exercem funções diferentes.

Exemplo Java

Connection conn = DriverManager.getConnection(
    "jdbc:db2://db2host.empresa.com:448/DBP1",
    usuario,
    senha
);

Neste exemplo:

  • Java é a linguagem;

  • JDBC é a API;

  • O IBM Data Server Driver for JDBC and SQLJ implementa a comunicação;

  • A URL descreve o destino;

  • DRDA organiza o diálogo com o servidor;

  • TCP/IP transporta as mensagens.

Exemplo Python

import ibm_db

conexao = ibm_db.connect(
    "DATABASE=DBP1;"
    "HOSTNAME=db2host.empresa.com;"
    "PORT=448;"
    "PROTOCOL=TCPIP;"
    "UID=APPUSER;"
    "PWD=senha;",
    "",
    ""
)

Python continua sendo a linguagem. O módulo e o driver cuidam do acesso. Depois, a aplicação pode executar SQL:

sql = """
    SELECT NOME, SALDO
      FROM CLIENTE
     WHERE ID_CLIENTE = 100
"""

stmt = ibm_db.exec_immediate(conexao, sql)

Exemplo COBOL

EXEC SQL
    SELECT NOME,
           SALDO
      INTO :WS-NOME,
           :WS-SALDO
      FROM CLIENTE
     WHERE ID_CLIENTE = :WS-ID-CLIENTE
END-EXEC.

COBOL é a linguagem. SQL é a linguagem de banco. EXEC SQL delimita o comando embutido. O programa ainda precisa passar por pré-compilação, compilação, linkedição e preparação dos componentes Db2.

O jovem padawan deve guardar:

A API é o painel da banheira. O driver é a máquina escondida embaixo dela. DRDA é o manual de comunicação temporal. TCP/IP é o túnel. O Db2 é o destino.



3. O personagem que o infográfico esqueceu: o driver

O driver é um dos componentes mais importantes da arquitetura.

Ele:

  • Implementa JDBC, ODBC, CLI ou .NET;

  • Converte chamadas da aplicação em mensagens entendidas pelo servidor;

  • Monta e interpreta o protocolo DRDA;

  • Converte tipos de dados;

  • Entrega result sets;

  • Envia COMMIT e ROLLBACK;

  • Controla propriedades de timeout;

  • Participa de pooling e concentração de conexões;

  • Pode colaborar com automatic client reroute;

  • Pode colaborar com Sysplex workload balancing;

  • Negocia capacidades com o servidor;

  • Reporta SQLCODE, SQLSTATE e erros de comunicação.

A IBM distribui drivers e clientes diferentes para JDBC/SQLJ, ODBC/CLI, .NET, OLE DB e outras interfaces. IBM — Tipos de clientes e drivers

Por isso, ao atualizar um driver, não estamos apenas trocando “um arquivo .jar qualquer”.

A atualização pode alterar:

  • Suporte a TLS;

  • Conversão de timestamps;

  • Tipos de dados suportados;

  • Propriedades de failover;

  • Comportamento de timeouts;

  • Pacotes utilizados no servidor;

  • Recursos de compatibilidade;

  • Balanceamento no Sysplex.

Uma aplicação pode funcionar com determinada versão do driver em homologação e falhar em produção porque os pacotes correspondentes não foram preparados no Db2 for z/OS.

Easter egg número 1: se Igor disser “é só trocar o db2jcc4.jar escondido e ninguém perceberá”, esconda a senha do RACF e chame o change manager.



4. TCP/IP é a estrada; DRDA é o idioma

Durante a viagem de volta a 1986, o jovem padawan viu um telefone público.

Igor levantou o aparelho e começou a falar COBOL com a telefonista.

— MOVE TELEFONISTA TO WS-CONEXAO.

A telefonista desligou.

O telefone funcionava. A linha estava ativa. Mas ninguém falava o mesmo idioma.

Essa é a diferença entre TCP/IP e DRDA.

TCP/IP estabelece o transporte confiável e ordenado entre endpoints. DRDA define como clientes e servidores de bancos relacionais distribuem solicitações e respostas.

Uma forma didática de separar as camadas é:

SQL          → O que queremos fazer
API          → Como a aplicação solicita
Driver       → Quem implementa a solicitação
DRDA         → Como cliente e Db2 conversam
TLS          → Como o conteúdo pode ser protegido
TCP/IP       → Como os bytes viajam

Por isso, executar:

ping db2host

e receber resposta não prova que o Db2 funciona.

O ping pode confirmar que algum caminho IP está disponível, mas não confirma:

  • Que a porta do DDF está aberta;

  • Que o listener está ativo;

  • Que o firewall permite o tráfego da aplicação;

  • Que o TLS consegue negociar;

  • Que o certificado é confiável;

  • Que o usuário consegue autenticar;

  • Que o location name está correto;

  • Que os pacotes existem;

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

  • Que a SQL pode ser executada.

É como chegar à cidade correta e concluir que sua reserva no hotel está garantida.



5. No z/OS, quem abre o portal é o DDF

Quando o destino é Db2 for z/OS, entra em cena o:

DDF — Distributed Data Facility

O DDF é o componente que permite ao Db2 for z/OS participar do processamento distribuído, recebendo e iniciando comunicações com sistemas remotos.

Para uma aplicação externa estabelecer uma conexão, o DDF precisa estar:

  • Instalado e configurado;

  • Ativo;

  • Associado a portas TCP/IP;

  • Publicado no endereço correto;

  • Integrado à segurança;

  • Preparado para o protocolo utilizado.

A IBM deixa claro que o subsistema Db2 for z/OS precisa ter o DDF habilitado para receber conexões JDBC por TCP/IP. IBM — JDBC acessando Db2 for z/OS

No diagnóstico, dois comandos são particularmente conhecidos:

-DISPLAY DDF DETAIL

e:

-DISPLAY LOCATION

Eles podem ajudar a verificar informações como:

  • Estado do DDF;

  • Location name;

  • Endereços;

  • Portas;

  • Informações de comunicação;

  • Características do ambiente distribuído.

Se o DDF estiver parado, a aplicação poderá enxergar o host, alcançar o z/OS e mesmo assim não falar com o Db2.

Easter egg número 2: no filme, a banheira precisava de uma combinação improvável de água, energia e bebida derramada. No datacenter, DDF não deve depender de Igor derramando energético no console.



6. DBAT: o funcionário que recebe o visitante

Depois que a conexão chega ao DDF, o trabalho precisa ser processado. Entra o:

DBAT — Database Access Thread

O DBAT é uma thread de acesso ao banco utilizada no processamento de solicitações distribuídas.

Imagine a recepção de um hotel:

  • A conexão é o hóspede;

  • DDF é a recepção;

  • A autenticação verifica o documento;

  • O DBAT é o funcionário que atende a solicitação;

  • O package define determinados recursos e regras de execução;

  • O Db2 acessa os dados.

Uma conexão lógica não significa necessariamente um DBAT permanentemente dedicado.

O Db2 for z/OS pode utilizar pooling de DBATs. Depois de uma unidade de trabalho, um DBAT elegível pode ser liberado para atender outra conexão. Isso reduz o consumo de recursos em ambientes com grandes quantidades de conexões remotas. IBM — Gerenciamento de DBATs

Também existem high-performance DBATs. Nesse caso, o DBAT permanece associado à conexão através das fronteiras de transação, reduzindo determinados custos de liberação e reassociação, mas mantendo recursos dedicados por mais tempo. IBM — Como DBATs processam conexões remotas

Portanto:

Conexão ≠ DBAT permanentemente ativo

Essa diferença torna-se crucial quando containers entram na história.

Suponha:

50 pods
× 100 conexões máximas
= 5.000 conexões potenciais

Agora o Kubernetes faz autoscaling:

200 pods
× 100 conexões
= 20.000 conexões potenciais

O desenvolvedor olha para uma configuração e pensa:

“Cem conexões é um número pequeno.”

O Db2 olha para o conjunto e vê vinte mil visitantes atravessando o portal temporal.



7. Conexão direta ou servidor Db2 Connect?

Nas arquiteturas antigas, era comum encontrar:

Aplicação
    ↓
Servidor Db2 Connect
    ↓
Db2 for z/OS

O servidor Db2 Connect funcionava como um ponto intermediário de conectividade.

Essa arquitetura ainda pode fazer sentido em situações específicas:

  • Centralização de determinados componentes;

  • Ambientes com requisitos legados;

  • Federation;

  • Monitores transacionais;

  • Necessidades operacionais específicas;

  • Administração concentrada.

Mas não é obrigatório colocar um gateway intermediário em todos os cenários.

Muitas aplicações modernas utilizam:

Aplicação + driver IBM
    ↓
DRDA/TCP/IP
    ↓
Db2 for z/OS

A própria IBM recomenda conexão direta por cliente ou driver em muitos ambientes, reduzindo a necessidade de uma máquina intermediária. IBM — Opções de conexão cliente-servidor

Conexão direta

Vantagens:

  • Menos saltos de rede;

  • Menor latência;

  • Menos infraestrutura intermediária;

  • Diagnóstico potencialmente mais simples;

  • Recursos implementados diretamente pelo driver.

Cuidados:

  • Controle de versões dos drivers;

  • Distribuição de certificados;

  • Configuração em múltiplos servidores;

  • Licenciamento;

  • Padronização entre equipes.

Gateway Db2 Connect

Vantagens possíveis:

  • Ponto central de conectividade;

  • Administração concentrada;

  • Suporte a arquiteturas específicas;

  • Menor dispersão de certas configurações.

Cuidados:

  • Mais um salto;

  • Mais um componente monitorado;

  • Possível gargalo;

  • Possível ponto único de falha;

  • Maior cadeia de diagnóstico.

Um gateway não é automaticamente ruim. Conexão direta não é automaticamente melhor. A escolha deve nascer dos requisitos, não da nostalgia de um diagrama de 1998.



8. O que acontece durante um SELECT?

Considere:

SELECT NOME,
       LIMITE_CREDITO
  FROM CLIENTE
 WHERE CPF = ?

A aplicação Java executa algo aparentemente simples:

ResultSet rs = statement.executeQuery();

Por baixo dessa linha, a banheira do tempo entra em funcionamento:

  1. A requisição da aplicação precisa de uma conexão;

  2. A aplicação solicita essa conexão ao pool;

  3. O pool entrega uma conexão existente ou cria outra;

  4. JDBC recebe a solicitação;

  5. O driver IBM converte os parâmetros;

  6. O driver monta a conversa DRDA;

  7. TLS pode proteger o tráfego;

  8. TCP/IP transporta as mensagens;

  9. DDF recebe a requisição no z/OS;

  10. O usuário é autenticado;

  11. A conexão é associada a um DBAT;

  12. O Db2 identifica o package e o contexto;

  13. As autorizações são verificadas;

  14. A SQL é preparada ou localizada;

  15. O access path é utilizado;

  16. Os dados são lidos;

  17. As linhas retornam por DRDA;

  18. O driver converte os tipos;

  19. JDBC entrega o ResultSet;

  20. A aplicação consome os registros;

  21. COMMIT ou ROLLBACK encerra a unidade de trabalho;

  22. A conexão pode retornar ao pool.

Portanto, “tempo da query” pode significar coisas diferentes:

  • Espera pelo pool;

  • Abertura da conexão;

  • Autenticação;

  • Negociação TLS;

  • Transporte de rede;

  • Espera por DBAT;

  • Espera por WLM;

  • Prepare;

  • Execução;

  • Locks;

  • Fetch das linhas;

  • Conversão no driver;

  • Processamento na aplicação.

Quando alguém disser “o Db2 demorou oito segundos”, primeiro descubra onde os oito segundos foram gastos.



9. Packages: o detalhe que aparece quando chega o -805

Uma conexão pode alcançar o host, atravessar a porta, autenticar o usuário e ainda assim falhar.

Um erro clássico é:

SQLCODE -805
SQLSTATE 51002

Ele normalmente indica que um package necessário não foi encontrado, não está disponível no contexto esperado ou não corresponde ao que está sendo solicitado.

Drivers JDBC e CLI utilizam packages preparados no servidor. A collection NULLID aparece frequentemente nesses ambientes.

A IBM disponibiliza, por exemplo, o utilitário DB2Binder para vincular packages utilizados pelo IBM Data Server Driver for JDBC and SQLJ no Db2 for z/OS. IBM — DB2Binder

É possível também trabalhar com collections diferentes e níveis distintos de APPLCOMPAT.

Exemplo conceitual:

NULLID
NULLID_V12R1M500
NULLID_V12R1M501

Cada collection pode representar uma combinação planejada de packages e compatibilidade.

Isso permite que uma aplicação nova utilize determinadas capacidades sem obrigar todas as aplicações antigas a avançarem imediatamente.

Dica de produção:

Antes de atualizar o driver, confirme quais packages serão necessários, quem realizará o bind, quais opções serão usadas e como será feito o rollback.

Atualizar o .jar e esquecer o servidor é uma maneira elegante de transformar uma melhoria técnica em incidente noturno.



10. COMMIT, ROLLBACK e a viagem que talvez já tenha acontecido

Considere uma transferência:

UPDATE CONTA
   SET SALDO = SALDO - 100
 WHERE CONTA_ID = 10;

UPDATE CONTA
   SET SALDO = SALDO + 100
 WHERE CONTA_ID = 20;

As duas operações precisam pertencer à mesma unidade de trabalho.

Em JDBC:

connection.setAutoCommit(false);

try {
    debitar.executeUpdate();
    creditar.executeUpdate();
    connection.commit();
} catch (Exception e) {
    connection.rollback();
    throw e;
}

O commit() não acontece apenas dentro da aplicação Java. A solicitação precisa viajar até o servidor e ser processada pelo Db2.

Agora imagine:

  1. A aplicação envia o COMMIT;

  2. O Db2 recebe;

  3. O Db2 confirma a transação;

  4. A resposta retorna;

  5. A rede cai antes de a aplicação receber a confirmação.

A aplicação pode concluir:

“Não recebi sucesso; tentarei novamente.”

Mas o Db2 talvez já tenha confirmado.

Se o retry repetir a operação inteira, podemos debitar o cliente duas vezes.

Esse é o lado realmente perigoso das falhas distribuídas: nem sempre sabemos imediatamente se a viagem temporal ocorreu.

Por isso, operações críticas precisam considerar:

  • Idempotência;

  • Identificador único de transação;

  • Controle de duplicidade;

  • Reconciliação;

  • Logs técnicos e de negócio;

  • Estado desconhecido após falhas;

  • Estratégias específicas de retry.

Retry não é GO TO TENTE-NOVAMENTE aplicado cegamente a qualquer erro.



11. Pool de conexões: o táxi que retorna à praça

Abrir uma conexão para cada requisição custa caro. Por isso, servidores de aplicações normalmente mantêm pools.

Requisição
    ↓
Solicita conexão
    ↓
Pool entrega uma conexão
    ↓
Aplicação executa SQL
    ↓
Commit ou rollback
    ↓
Conexão retorna ao pool

O problema surge quando a aplicação devolve a conexão em estado inadequado.

Ela pode retornar com:

  • Transação aberta;

  • Cursor abandonado;

  • Isolation level alterado;

  • CURRENT SCHEMA modificado;

  • Registros especiais alterados;

  • Erro não tratado;

  • Estado inválido após falha de comunicação.

Exemplo:

SET CURRENT SCHEMA = FINANCEIRO;

Se a aplicação devolve a conexão sem restaurar o estado, o próximo usuário pode herdar aquela configuração.

O pool é como um táxi reutilizado. O próximo passageiro não deveria encontrar no banco traseiro:

  • A carteira do anterior;

  • Uma transação aberta;

  • Um cursor;

  • O schema financeiro;

  • Nem Igor tentando voltar a 1986.

Boas práticas incluem:

  • Sempre fechar recursos;

  • Usar blocos try-with-resources;

  • Executar rollback em exceções;

  • Configurar validação de conexões;

  • Definir timeouts;

  • Dimensionar mínimo e máximo;

  • Monitorar espera pelo pool;

  • Evitar pools enormes em cada instância;

  • Considerar o total agregado de containers.



12. Segurança: TCP/IP não é colete à prova de balas

A existência de uma conexão TCP/IP não garante que seu conteúdo esteja protegido.

No Db2 for z/OS, TLS pode ser implementado com participação do z/OS Communications Server e AT-TLS. O SECPORT pode identificar a porta utilizada para conexões seguras. IBM — TLS no Db2 for z/OS

Devemos separar quatro perguntas:

Quem é você?

Autenticação:

  • Usuário e senha;

  • RACF PassTicket;

  • Kerberos;

  • Outros mecanismos previstos pela arquitetura.

A conversa está protegida?

Transporte:

  • TLS;

  • Certificados;

  • Truststore;

  • Cipher suites;

  • AT-TLS;

  • Políticas de rede.

O que você pode fazer?

Autorização:

  • SELECT;

  • INSERT;

  • UPDATE;

  • DELETE;

  • EXECUTE em package;

  • EXECUTE em stored procedure;

  • Uso de uma collection.

Quem é a aplicação?

Identificação operacional:

  • Application name;

  • Workstation;

  • Client user;

  • Accounting string;

  • Correlation ID.

Sem identificação adequada, o monitoramento pode apresentar centenas de conexões chamadas simplesmente de:

db2jcc_application

É como receber 500 viajantes temporais e registrar todos como “Igor”.



13. Por que uma SQL rápida no SPUFI pode ser lenta no Java?

Essa comparação aparece frequentemente:

“No SPUFI leva meio segundo; no Java leva dez segundos. Logo, Java ou Db2 Connect está lento.”

Talvez. Mas ainda não foi provado.

Compare:

  • A SQL é exatamente igual?

  • Os valores dos parâmetros são iguais?

  • O usuário é o mesmo?

  • O schema é o mesmo?

  • O package é o mesmo?

  • O APPLCOMPAT é igual?

  • O isolation level é igual?

  • A aplicação executa apenas uma SQL?

  • O tempo inclui espera no pool?

  • Há latência de rede?

  • Quantas linhas retornam?

  • Qual é o fetch size?

  • A aplicação processa cada linha lentamente?

  • Existe gateway intermediário?

  • Há conversões de tipos?

  • A conexão foi aberta durante a medição?

SPUFI e aplicação distribuída podem usar caminhos operacionais muito diferentes.

A aplicação talvez faça:

1 consulta para obter clientes
+ 1 consulta para cada cliente

Para mil clientes:

1 + 1.000 = 1.001 SQLs

Esse é o conhecido problema N+1.

O Db2 pode executar cada consulta rapidamente, mas a aplicação acumula mil viagens de rede.

O relatório final dirá “Db2 lento”. O Db2, inocente, estará apenas respondendo mil vezes à mesma insistência.



14. Fetch size: quantas malas entram em cada viagem?

Se uma consulta retorna 100 mil linhas, trazê-las uma por uma pode ser desastroso.

Imagine:

100.000 linhas
÷ 10 linhas por bloco
= 10.000 trocas

Com blocos de cem linhas:

100.000
÷ 100
= 1.000 trocas

Ajustar fetch size e blocagem pode reduzir viagens, mas aumentar indiscriminadamente também não é solução.

Blocos maiores podem:

  • Consumir mais memória;

  • Aumentar o volume transferido antecipadamente;

  • Ser desperdiçados se a aplicação abandonar o cursor;

  • Pressionar o heap do servidor.

O ajuste deve considerar:

  • Tamanho médio da linha;

  • Volume do resultado;

  • Latência;

  • Memória disponível;

  • Padrão de consumo;

  • Necessidade real do usuário.

A melhor otimização pode ser não buscar 100 mil linhas.

Às vezes, a solução correta é:

FETCH FIRST 100 ROWS ONLY

ou implementar paginação adequada.



15. Data Sharing, Sysplex e a banheira com várias saídas

Em um Db2 Data Sharing Group, vários membros podem atender o workload.

Aplicação
    ↓
Driver com recursos de disponibilidade
    ↓
Location do grupo
    ↓
DB2A / DB2B / DB2C

O driver pode colaborar com:

  • Sysplex workload balancing;

  • Automatic client reroute;

  • Failover;

  • Afinidade;

  • Concentração de transporte.

Mas esses recursos precisam ser planejados e configurados. Não surgem apenas porque alguém escreveu “HA” no PowerPoint.

Também é importante compreender:

Reconectar não significa continuar uma transação interrompida exatamente de onde ela parou.

O driver pode encontrar outro membro disponível, mas a aplicação ainda precisa tratar:

  • Unidade de trabalho anterior;

  • Commit de resultado incerto;

  • Cursores perdidos;

  • Estado da sessão;

  • Reexecução segura.

Alta disponibilidade reduz interrupções. Não revoga as leis do processamento distribuído.



16. Mapa rápido dos erros

SintomaCamada provávelO que verificar
Host desconhecidoDNSNome e resolução
Connection refusedTCP/DDFPorta, listener, firewall
Timeout de conexãoRedeRota, firewall, endereço
Falha de handshakeTLSCertificado, truststore, cipher
Usuário inválidoSegurançaCredencial, RACF, método
SQLCODE -805PackageCollection, bind, versão
SQLCODE -551AutorizaçãoPrivilégios
SQLCODE -911/-913ConcorrênciaLock, deadlock, timeout
SQLCODE -904RecursoReason code e resource name
SQL30081NComunicaçãoProtocolo, socket e códigos
-4499JDBC/comunicaçãoExceções encadeadas e timeout
Muitas conexões ociosasPoolMínimo, máximo e total agregado
Lentidão intermitenteVáriasPool, DBAT, WLM, lock, rede

Nunca pare na primeira mensagem genérica.

Em JDBC, investigue as exceções encadeadas. Registre:

  • SQLCODE;

  • SQLSTATE;

  • Reason code;

  • Timestamp;

  • Host de origem;

  • Nome da aplicação;

  • Versão do driver;

  • Correlation ID;

  • URL sem senha;

  • Operação executada;

  • Estado da transação.


17. Passo a passo do jovem padawan COBOL

Passo 1 — Desenhe o caminho real

Aplicação
→ servidor
→ driver
→ gateway, se houver
→ firewall
→ porta
→ DDF
→ Db2

Não use o desenho idealizado. Use o caminho de produção.

Passo 2 — Identifique o driver

Descubra:

  • Nome;

  • Versão;

  • Arquivo;

  • Configuração;

  • Compatibilidade;

  • Licença aplicável.

Passo 3 — Confirme host, porta e location

Não confunda:

  • Nome DNS;

  • Nome do subsistema;

  • Location name;

  • Alias;

  • Nome do data sharing group;

  • Database da URL JDBC.

Passo 4 — Teste a rede

Verifique:

  • DNS;

  • Rota;

  • Porta;

  • Firewall;

  • Origem real da aplicação.

O teste deve ser executado a partir do servidor onde o programa roda, não do notebook do analista.

Passo 5 — Verifique TLS

Confirme:

  • Porta segura;

  • Validade do certificado;

  • Cadeia de confiança;

  • Truststore;

  • Nome do host;

  • Política AT-TLS.

Passo 6 — Verifique DDF

No z/OS:

  • DDF está ativo?

  • A porta está correta?

  • O location está correto?

  • Existem mensagens DSNL?

  • A conexão chega?

Passo 7 — Verifique autenticação

Pergunte:

  • O usuário existe?

  • Está revogado?

  • A credencial expirou?

  • O método é compatível?

  • O RACF registrou falha?

Passo 8 — Verifique packages

Se houver -805:

  • Qual package?

  • Qual collection?

  • Qual versão do driver?

  • Houve atualização?

  • O bind foi feito?

  • O APPLCOMPAT é compatível?

Passo 9 — Verifique autorização

Se houver -551:

  • Qual authid?

  • Qual objeto?

  • Qual operação?

  • A autorização é direta ou por papel?

  • O usuário pode executar o package?

Passo 10 — Verifique a unidade de trabalho

  • Autocommit está ativo?

  • Existe commit explícito?

  • O rollback é garantido?

  • A conexão volta limpa ao pool?

  • Há transações longas?

Passo 11 — Verifique performance

  • Espera no pool;

  • Tempo de conexão;

  • Tempo de SQL;

  • Tempo de fetch;

  • Tempo da aplicação;

  • Lock;

  • DBAT;

  • WLM;

  • Número de viagens.

Passo 12 — Documente o resultado

Uma solução que vive apenas na memória do analista sofrerá um DELETE quando ele sair de férias.






18. Curiosidades escondidas na banheira

Curiosidade 1 — O nome histórico pode denunciar a idade do desenho

O infográfico usa “Db2 for i5/OS”. A nomenclatura atual é Db2 for IBM i.

Também aparece algo parecido com “Db2 for x/OS”, provavelmente um erro gráfico para Db2 for z/OS.

Curiosidade 2 — SQL não é API de transporte

SQL descreve operações relacionais. JDBC, ODBC e CLI oferecem interfaces para a aplicação. O driver transforma essas chamadas em comunicação com o servidor.

Curiosidade 3 — “Conectou” não significa “funcionou”

Existem vários marcos:

Host respondeu
≠ porta abriu
≠ TLS negociou
≠ usuário autenticou
≠ package foi encontrado
≠ autorização concedida
≠ SQL executou
≠ commit confirmou

Curiosidade 4 — O nome da aplicação é recurso de produção

Preencher corretamente os atributos do cliente ajuda:

  • Accounting;

  • WLM;

  • Monitoramento;

  • Profile tables;

  • Diagnóstico;

  • Chargeback;

  • Identificação de ofensores.

Curiosidade 5 — O erro mais perigoso pode vir depois do sucesso

A SQL pode ter sido executada e confirmada, mas a resposta pode ter se perdido. Isso cria estado incerto e torna retries cegos particularmente perigosos.

Curiosidade 6 — Microserviço não reduz automaticamente o consumo

Transformar um monólito em cem containers pode multiplicar:

  • Pools;

  • Conexões;

  • Certificados;

  • Logs;

  • Timeouts;

  • Pontos de falha;

  • Viagens ao Db2.

A arquitetura ficou distribuída. O bom senso também precisa ser.



19. O mapa mental definitivo

Quando uma aplicação distribuída acessa Db2 for z/OS, pense nesta sequência:

A aplicação pede
A API formaliza
O driver traduz
DRDA organiza
TLS protege
TCP/IP transporta
DDF recebe
RACF autentica
WLM classifica
DBAT trabalha
O package sustenta
Db2 executa
O cursor entrega
COMMIT confirma
O pool reutiliza
A monitoração conta a história

Se cada componente possuir dono, versão, configuração, métrica e procedimento, a arquitetura será administrável.

Se tudo for chamado genericamente de “Db2 Connect”, o incidente será uma excursão temporal sem mapa.



Epílogo — Ninguém voltou para 1986, mas o chamado foi encerrado

De volta ao datacenter, o jovem padawan COBOL examinou novamente o erro:

ERRORCODE=-4499
SQLSTATE=08001

Dessa vez ele não começou pelo SELECT.

Primeiro confirmou:

  • O servidor de origem;

  • A versão do driver;

  • O hostname;

  • A porta segura;

  • A cadeia de certificados;

  • O status do DDF;

  • As mensagens no z/OS.

Descobriu que o certificado havia sido renovado no servidor, mas o truststore da aplicação ainda continha a cadeia anterior.

A rede funcionava.

O DDF funcionava.

O Db2 funcionava.

A SQL nunca havia chegado ao banco.

Igor olhou para a banheira e perguntou:

— Então podemos colocá-la em produção?

O padawan respondeu:

IF IGOR-IN-PRODUCTION
    MOVE 'N' TO APPROVAL-FLAG
    PERFORM CHAMAR-CHANGE-MANAGER
END-IF

A maior lição daquela noite não foi apenas aprender o que Db2 Connect faz.

Foi compreender que arquiteturas distribuídas são formadas por contratos encadeados. Cada camada promete alguma coisa à camada seguinte:

  • A aplicação promete usar corretamente a API;

  • O driver promete implementar a conversa;

  • DRDA promete organizar o diálogo;

  • TCP/IP promete transportar;

  • TLS promete proteger;

  • DDF promete receber;

  • DBAT promete processar;

  • O Db2 promete preservar integridade;

  • A aplicação promete saber quando confirmar ou desfazer.

Quando uma promessa é quebrada, o erro aparece em algum lugar da cadeia — nem sempre no lugar onde nasceu.

Db2 Connect, portanto, não é uma simples ponte entre um computador e um banco.

É uma máquina do tempo cuidadosamente controlada: leva aplicações escritas hoje até dados acumulados durante décadas, permite que Java, Python, .NET, ferramentas ODBC e sistemas modernos conversem com o Db2 for z/OS e demonstra que o mainframe não está preso ao passado.

O passado continua em produção.

E, ao contrário da banheira de Igor, processa bilhões de transações sem derramar energético no DDF.




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