 |
| Bellacosa Mainframe Lendo e gravando dataset em REXX |
☕🚀 REXX NO MODO TURBO: O DIA EM QUE O EXECIO VIROU UM CANHÃO DE AUTOMAÇÃO NO z/OS 🚀☕
“Quem domina I/O em REXX deixa de escrever scripts… e começa a construir infraestrutura invisível dentro do mainframe.”
— Bellacosa Mainframe
📚 Introdução
Existe um momento específico na jornada de qualquer profissional mainframe em que tudo muda.
Até então:
- o REXX parecia apenas uma linguagem de comandos,
-
alguns
SAY, -
uns
PARSE, - um loop aqui,
-
um
LISTDSIali.
Mas então surge ele:
🔥 EXECIO 🔥
E junto dele:
- datasets,
- streams,
- automação JES,
- geração dinâmica de JCL,
- pipelines batch,
- processamento massivo,
- e aquele sentimento perigoso de:
“Acho que agora consigo automatizar o datacenter inteiro…”
E sinceramente?
Talvez consiga mesmo.
🏛️ O VERDADEIRO PODER DO REXX
Muita gente acha que o poder do mainframe está:
- no COBOL,
- no CICS,
- no DB2,
- ou no JES2.
Mas existe um herói silencioso escondido no TSO:
⚡ O REXX ⚡
Porque ele conecta tudo.
O REXX:
- conversa com datasets,
- conversa com JES,
- conversa com ISPF,
- conversa com SDSF,
- conversa com USS,
- conversa com RACF,
- conversa com operadores,
- conversa com o sysprog,
- e às vezes…
- conversa até com entidades sobrenaturais chamadas ABENDs.
💾 O PRIMEIRO CONTATO COM O EXECIO
O programador iniciante vê isso:
"EXECIO * DISKR INDD (STEM REC. FINIS"
E pensa:
“Ok… parece simples.”
O sysprog experiente olha o mesmo comando e pensa:
“Esse cidadão acabou de carregar 12 milhões de linhas na memória…”
☠️ O ASTERISCO QUE DESTRÓI REGIÕES
Vamos falar sobre o famoso:
*
No EXECIO ele significa:
“Leia TUDO.”
Parece inocente.
Mas imagine executar isso em:
- um SYSLOG gigantesco,
- um dump textual,
- um relatório SMF,
- ou uma saída monstruosa de SORT.
Resultado:
IEF374I REGION BELOW 16M EXHAUSTED
Ou pior:
S878
O momento em que o operador começa a procurar seu userid no console…
🧠 O SEGREDO DOS PROFISSIONAIS: STEM VARIABLES
A IBM acertou em cheio aqui.
O uso de STEM transforma o REXX em algo elegantíssimo.
📦 Exemplo
/* LEITURA DE DATASET */
"ALLOC FI(INPUT) DA('USER.TEST.DATA') SHR"
"EXECIO * DISKR INPUT (STEM DADOS. FINIS"
SAY "TOTAL DE REGISTROS:" DADOS.0
DO I = 1 TO DADOS.0
SAY DADOS.I
END
"FREE FI(INPUT)"
🔍 O DETALHE QUE MUITA GENTE NÃO PERCEBE
DADOS.0
NÃO é um registro.
Ele contém:
- a quantidade de linhas lidas.
Isso virou praticamente um padrão “sagrado” no universo REXX.
🧙♂️ O FEITICEIRO DOS DATASETS
Depois de algum tempo usando EXECIO, acontece algo curioso.
Você para de pensar em:
- datasets
E começa a pensar em:
- fluxos,
- pipelines,
- transformação de dados,
- automação operacional.
O REXX começa a parecer um mini shell Unix dentro do z/OS.
E isso NÃO é coincidência.
🌊 STREAMS — QUANDO O REXX DESCOBRE O UNIX
A chegada das Stream Functions foi revolucionária.
Antes:
- tudo era “registro”.
Depois:
- tudo virou “fluxo”.
📜 Exemplo com LINEIN()
ARQ = STREAM("'USER.INPUT.DATA'","C","OPEN READ")
DO WHILE LINES(ARQ)
LINHA = LINEIN(ARQ)
SAY LINHA
END
CALL STREAM ARQ,"C","CLOSE"
Isso parece:
- shell scripting,
- C,
- Python,
- Perl,
- Unix clássico.
A IBM basicamente trouxe a filosofia POSIX para dentro do REXX.
🤯 O DIA EM QUE O REXX VIRA DEVOPS
Agora observe isso:
JOB.1="//TESTJOB JOB (ACCT),'REXX'"
JOB.2="//STEP1 EXEC PGM=IEFBR14"
JOB.0=2
SAY SUBMIT("JOB.")
Sim.
Você acabou de:
- gerar um JOB,
- montar o JCL,
- submeter para o JES2,
- tudo dinamicamente.
☕ EASTER EGG #1 — O “SKYNET JES2”
Em algum momento da carreira todo profissional REXX cria um loop acidental assim:
DO FOREVER
SAY SUBMIT("JOB.")
END
Cinco minutos depois:
$HASP375 JOB99999 ESTIMATED LINES EXCEEDED
E nasce uma nova lenda no CPD.
⚡ EXECIO vs STREAMS
EXECIO
Modo clássico mainframe:
- robusto
- tradicional
- extremamente usado
STREAMS
Modo moderno:
- mais portátil
- mais elegante
- mais próximo de Unix/Linux
🏗️ O MAINFRAME É UM ECOSSISTEMA DE I/O
O z/OS inteiro gira em torno de:
- datasets,
- buffers,
- canais,
- spool,
- VSAM,
- logs,
- streams,
- records.
Quem domina I/O:
- domina automação.
Quem domina automação:
- domina operação.
Quem domina operação:
- vira indispensável.
💥 O ERRO CLÁSSICO DO INICIANTE
"EXECIO * DISKR HUGEFILE (STEM BIG."
Quando:
- HUGEFILE tem 48 milhões de registros.
O storage começa a evaporar.
O SDSF fica lento.
O operador abre incidente.
O sysprog começa a investigar.
E você:
- apenas queria “dar uma olhadinha no arquivo”.
🧠 O PADRÃO PROFISSIONAL REAL
Os veteranos fazem assim:
DO FOREVER
"EXECIO 100 DISKR INPUT (STEM REC."
IF RC <> 0 THEN LEAVE
DO I = 1 TO REC.0
SAY REC.I
END
END
Isso:
- escala melhor,
- consome menos memória,
- evita tragédias operacionais.
☕ EASTER EGG #2 — O “FINIS ESQUECIDO”
Poucas coisas assustam mais um sysprog do que descobrir:
"EXECIO * DISKR INPUT (STEM REC."
Sem:
FINIS
O dataset continua aberto…
E às vezes:
- lockado,
- preso,
- pendurado,
- amaldiçoado pelo espírito ancestral do ENQ.
👻 O FANTASMA DO DATASET EM USO
Todo mundo já viu:
DATA SET IN USE
E passou 40 minutos procurando:
- TSO preso,
- ISPF órfão,
- batch zombie,
- ou um REXX abandonado.
🚀 BPXWDYN — O SUPER SAIYAJIN DO ALLOC
Depois vem ele:
BPXWDYN
O allocation moderno do z/OS.
📜 Exemplo
CALL BPXWDYN "ALLOC FI(INPUT) DA(USER.TEST) SHR"
Muito mais poderoso que:
- ALLOC tradicional.
Mais elegante.
Mais flexível.
Mais “Unixificado”.
🌌 O REXX COMO LINGUAGEM UNIVERSAL DO z/OS
Poucas linguagens conseguem:
- operar JES,
- ler spool,
- manipular datasets,
- chamar ISPF,
- usar USS,
- conversar com RACF,
- abrir sockets,
- automatizar operações.
O REXX consegue.
E faz isso há décadas.
☕ EASTER EGG #3 — O SYSADM OCULTO
Existe uma regra não escrita no mainframe:
“Se um ambiente está funcionando perfeitamente há 20 anos… provavelmente existe um REXX misterioso sustentando tudo.”
Ninguém sabe:
- quem escreveu,
- quando escreveu,
- ou como funciona.
Mas todos têm medo de apagar.
🧬 O DNA DO MAINFRAME MODERNO
Hoje:
- DevOps,
- automação,
- pipelines,
- integração contínua,
- observabilidade,
- self-healing systems…
Tudo isso já existia conceitualmente no z/OS há muito tempo.
E o REXX participou disso silenciosamente.
🎯 Conclusão
Aprender:
- EXECIO,
- STREAMS,
- LINEIN,
- LINEOUT,
- BPXWDYN,
- SUBMIT,
não é apenas aprender I/O.
É aprender:
como o mainframe respira.
Porque no fundo:
- o z/OS é movimento de dados,
- fluxo de informação,
- buffers,
- registros,
- streams,
- spool,
- mensagens,
- eventos.
E o REXX é uma das linguagens que melhor conversa com esse universo.
☕ Bellacosa Mainframe Final Advice
Se você realmente quiser evoluir em REXX:
Pare de fazer apenas:
- scripts.
Comece a construir:
- automações,
- frameworks,
- pipelines,
- ferramentas operacionais,
- inteligência operacional.
Porque é aí que o REXX deixa de ser linguagem…
E vira:
