☕ 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 Otimização SQL. Mostrar todas as mensagens
Mostrar mensagens com a etiqueta Otimização SQL. Mostrar todas as mensagens

sábado, 9 de dezembro de 2023

SQL sem Mistérios no Db2 for z/OS

 

Bellacosa Mainframe e o sql sem misterios no db2 for z/os

☕ Um Café no Bellacosa Mainframe

SQL sem Mistérios no Db2 for z/OS

A Jornada Completa de uma Query no IBM Z — O Guia Definitivo do Programador COBOL Padawan Inspirado em Jornada nas Estrelas

"A lógica é o começo da sabedoria, não o fim."

— Sr. Spock


Introdução — Bem-vindo à USS Enterprise... digo... ao IBM Z

Imagine que você acabou de embarcar na USS Enterprise.

Você é um jovem cadete da Academia da Frota Estelar.

Seu trabalho não é pilotar a nave.

Também não é disparar phasers.

Sua missão é muito mais importante.

Você precisa descobrir como um simples pedido chega ao computador da nave, é analisado, processado e retorna em poucos milissegundos.

No universo Star Trek, esse computador responde perguntas como:

"Computador, localizar todos os oficiais Vulcanos da nave."

No mundo corporativo existe outro computador igualmente impressionante.

Ele atende pelo nome de IBM Z.

E seu cérebro de dados chama-se Db2 for z/OS.

Quando um programa COBOL executa um simples:

SELECT *
FROM CLIENTE
WHERE CPF='12345678900'

A maioria dos iniciantes imagina algo parecido com isto:

"O Db2 abriu a tabela, procurou o CPF e devolveu o registro."

Se fosse tão simples, este artigo terminaria aqui.

Mas...

Na realidade, entre o momento em que o programa envia o SQL e o momento em que os dados retornam, acontece uma verdadeira operação digna da Frota Estelar.

São dezenas de decisões inteligentes.

Milhares de estatísticas.

Análises matemáticas.

Escolha de estratégias.

Gerenciamento de memória.

Uso de caches.

Escolha de índices.

Controle de concorrência.

Tudo isso acontece quase instantaneamente.

Hoje vamos fazer uma viagem completa por essa jornada.

Prepare seu café.

Dr. Spock será nosso guia.


Capítulo 1 — O Computador Nunca Faz Apenas o Que Você Escreveu

Existe um dos maiores mitos entre iniciantes.

"Eu escrevi primeiro o SELECT."

Então ele executa primeiro.

Errado.

Na verdade, o Db2 praticamente ignora a ordem em que você escreveu.

Ele interpreta a intenção da consulta.

Depois decide sozinho como obter o resultado da forma mais eficiente possível.

É exatamente como Spock faria.

Se Kirk diz:

"Chegue até Vulcano."

Spock não pergunta:

"Qual estrada devo pegar?"

Ele calcula:

  • combustível

  • gravidade

  • buracos negros

  • campos de dobra

  • rotas inimigas

  • economia de energia

O destino é o mesmo.

O caminho muda.

O Db2 pensa exatamente assim.


Capítulo 2 — A Ponte de Comando do Db2

Imagine a ponte da Enterprise.

Cada oficial possui uma função.

No Db2 também.

OficialComponente Db2
Capitão KirkAplicação COBOL
Sr. SpockOptimizer
ScottyBuffer Manager
UhuraSQL Parser
SuluAccess Path
ChekovIndex Manager
ComputadorBuffer Pools
EngenhariaDisk Storage

O COBOL faz a pergunta.

Spock decide a melhor estratégia.

Scotty garante que tudo funcione.

O computador responde.


Capítulo 3 — A Missão Começa: EXEC SQL

Tudo começa aqui.

EXEC SQL

SELECT NOME

INTO :WS-NOME

FROM CLIENTES

WHERE CPF=:WS-CPF

END-EXEC.

Parece simples.

Mas isso ainda nem é SQL.

O COBOL sequer entende SQL.

Quem entende é o Pré-compilador.


Capítulo 4 — O Tradutor Universal

Antes da compilação acontece algo exclusivo do mundo Mainframe.

O famoso:

Pré-Compiler.

Ele encontra cada bloco EXEC SQL.

Substitui por chamadas internas.

Gera o famoso:

DBRM

(Database Request Module)

Este DBRM será utilizado posteriormente no BIND.

Curiosidade:

Oracle não trabalha assim.

SQL Server também não.

Este é um dos diferenciais históricos do Db2 z/OS.


Capítulo 5 — O Conselho Vulcano: BIND

Aqui mora uma das maiores diferenças entre o Db2 e praticamente todos os bancos relacionais.

O comando:

BIND PACKAGE

é como uma reunião do Alto Conselho Vulcano.

O Db2 olha para a consulta e pensa:

"Se esta SQL for executada milhões de vezes, qual será o melhor caminho?"

Ele cria um PACKAGE, contendo o plano de acesso ideal para aquele momento.

É aqui que nasce o famoso Access Path.


Capítulo 6 — O Dr. Spock Analisa as Probabilidades

Imagine duas tabelas.

CLIENTES

50 milhões de linhas.

ESTADOS

27 linhas.

Você faria o JOIN começando por qual?

Até um cadete responderia:

ESTADOS.

Mas...

Como o Db2 sabe disso?

A resposta chama-se:

RUNSTATS.


Capítulo 7 — RUNSTATS: Os Sensores de Longo Alcance

Os sensores da Enterprise informam:

  • quantas naves existem;

  • velocidade;

  • distância;

  • massa.

O RUNSTATS faz exatamente isso.

Ele informa ao Optimizer:

  • quantidade de linhas;

  • cardinalidade;

  • distribuição;

  • frequência;

  • seletividade;

  • clustering;

  • número de páginas;

  • estatísticas dos índices.

Sem RUNSTATS...

O Optimizer fica praticamente cego.

E um Spock sem sensores toma decisões muito piores.


Capítulo 8 — Álgebra Relacional: O Idioma Secreto do Computador

Depois que o SQL é validado, ele deixa de existir como texto.

Internamente transforma-se em Álgebra Relacional.

Por exemplo:

SELECT NOME
FROM CLIENTES
WHERE CIDADE='SP'

vira algo semelhante a:

σ Cidade='SP'

↓

π Nome

↓

CLIENTES

Ou seja:

primeiro seleciona.

Depois projeta.

O SQL desaparece.

Nasce um plano matemático.


Capítulo 9 — O Optimizer: O Verdadeiro Sr. Spock do IBM Z

Se existe um personagem que representa perfeitamente o Optimizer...

é o próprio Spock.

Ele nunca trabalha por emoção.

Somente lógica.

Ele calcula:

  • custo de CPU;

  • custo de I/O;

  • uso de Buffer Pools;

  • seletividade dos índices;

  • paralelismo;

  • volume esperado;

  • quantidade de páginas;

  • custo de SORT;

  • bloqueios.

Depois escolhe o menor custo possível.

Nem sempre será o caminho mais curto.

Será o mais eficiente.


Capítulo 10 — A Ordem Lógica da Consulta

Agora chegamos ao famoso diagrama.

Embora escrevamos:

SELECT

FROM

JOIN

ON

WHERE

GROUP BY

HAVING

ORDER BY

FETCH FIRST

O Db2 raciocina assim:

FROM

↓

JOIN

↓

ON

↓

WHERE

↓

GROUP BY

↓

HAVING

↓

SELECT

↓

ORDER BY

↓

FETCH FIRST

Mas cuidado.

Isto ainda não representa a ordem física.

Ela continua sendo decidida pelo Optimizer.


Capítulo 11 — O Access Path: A Rota Estelar

Aqui está o segredo.

O Db2 pode resolver exatamente a mesma SQL de dezenas de maneiras diferentes.

Ele escolhe entre:

  • Table Space Scan;

  • Index Scan;

  • Index Only Access;

  • List Prefetch;

  • Dynamic Prefetch;

  • Sequential Detection;

  • Nested Loop Join;

  • Merge Scan Join;

  • Hybrid Join;

  • Star Join;

  • Parallelism;

  • Materialized Query Table;

  • Sparse Index.

É como escolher diferentes rotas pelo Quadrante Alfa.

O destino é igual.

O caminho muda.


Capítulo 12 — O Buffer Pool: O Scotty da Memória

Scotty sempre dizia:

"Captain, I'm giving her all she's got!"

O Buffer Pool faz exatamente isso.

Antes de acessar o disco...

Ele pergunta:

"Essa página já está na memória?"

Se estiver...

Não existe I/O.

A resposta vem em microssegundos.

Grande parte do desempenho do Db2 depende da eficiência dos Buffer Pools.


Capítulo 13 — Os Predicados Stage 1 e Stage 2

Aqui existe uma armadilha clássica.

Observe:

WHERE YEAR(DATA)=2026

Parece bonito.

Mas destrói o uso do índice.

Muito melhor:

WHERE DATA BETWEEN
'2026-01-01'
AND
'2026-12-31'

No primeiro caso:

Stage 2.

No segundo:

Stage 1.

O primeiro costuma obrigar o Db2 a avaliar linha por linha.

O segundo permite filtrar diretamente pelo índice.

Dica Bellacosa: sempre que possível, escreva predicados que possam ser avaliados durante o acesso aos dados. Essa é uma das otimizações mais valiosas para quem desenvolve em COBOL com Db2.


Capítulo 14 — EXPLAIN: A Caixa-Preta da Enterprise

Nenhum engenheiro sério tenta descobrir um problema apenas olhando para a nave.

Ele consulta os sensores.

No Db2 fazemos exatamente isso.

Utilizamos:

EXPLAIN

Ele revela:

  • qual índice foi escolhido;

  • ordem dos JOINs;

  • tipo de acesso;

  • custo estimado;

  • necessidade de SORT;

  • paralelismo;

  • número estimado de linhas.

Nunca adivinhe.

Sempre consulte o plano.


Capítulo 15 — Locks: O Controle de Segurança da Federação

Enquanto tudo acontece...

O Db2 protege os dados.

Existem diversos tipos de bloqueio:

  • IS (Intent Share)

  • IX (Intent Exclusive)

  • S (Share)

  • U (Update)

  • X (Exclusive)

  • SIX (Share with Intent Exclusive)

Além disso, os níveis de isolamento (UR, CS, RS e RR) determinam o equilíbrio entre concorrência e consistência. Em sistemas bancários e de cartões de crédito, essa gestão é essencial para evitar leituras incorretas, perdas de atualização e conflitos entre milhares de transações simultâneas.


Capítulo 16 — Paralelismo: Quando a Enterprise Usa Toda a Tripulação

Em grandes consultas analíticas, o Db2 pode dividir o trabalho.

Imagine:

CPU 1 lê uma partição.

CPU 2 lê outra.

CPU 3 realiza o JOIN.

CPU 4 faz a agregação.

No IBM Z isso acontece utilizando múltiplos processadores e, em muitos cenários, explorando zIIPs para determinadas cargas elegíveis, reduzindo o impacto sobre os CPs tradicionais.


Capítulo 17 — Quando Fazer REBIND?

Imagine que a Enterprise recebeu um novo motor de dobra.

Você continuaria usando os cálculos antigos?

Claro que não.

No Db2 acontece o mesmo.

Após mudanças significativas, como:

  • criação de índices;

  • remoção de índices;

  • crescimento expressivo das tabelas;

  • execução de RUNSTATS;

  • alterações na distribuição dos dados;

vale analisar um REBIND PACKAGE ou REBIND PLAN, permitindo que o Optimizer recalcule um novo Access Path mais eficiente.


Capítulo 18 — O Programador COBOL Jedi... ou Vulcano?

Existe um momento em que o programador deixa de escrever SQL "que funciona".

E começa a escrever SQL "que escala".

Ele passa a pensar:

  • Meu predicado usa índice?

  • Meu JOIN é seletivo?

  • O EXPLAIN confirma minha hipótese?

  • As estatísticas estão atualizadas?

  • O SORT pode ser eliminado?

  • Estou lendo mais linhas do que preciso?

  • O FETCH FIRST pode reduzir trabalho?

  • Existe uma forma mais eficiente de escrever esta consulta?

Esse é o verdadeiro salto de maturidade.


Easter Egg Bellacosa ☕

No episódio "The Ultimate Computer", a Enterprise recebe o computador M-5, projetado para tomar decisões automaticamente.

No começo, tudo parece perfeito.

Depois surgem consequências inesperadas.

O Db2 Optimizer lembra um pouco essa história.

Ele toma decisões sozinho, mas depende da qualidade das informações que recebe.

Se as estatísticas estiverem desatualizadas, um índice importante não existir ou o modelo físico estiver inadequado, até um excelente otimizador poderá escolher um plano ruim.

A diferença é que, felizmente, o Optimizer não tenta assumir o comando da Enterprise nem entra em combate por conta própria.


Curiosidades

  • O Db2 for z/OS está entre os bancos de dados com os otimizadores mais sofisticados do mercado, evoluindo continuamente desde a década de 1980.

  • Um único SELECT pode gerar dezenas de operações internas invisíveis ao desenvolvedor.

  • Em ambientes de missão crítica, o mesmo SQL pode ser executado milhões de vezes por dia, tornando pequenas otimizações responsáveis por economias enormes de CPU e tempo.

  • Muitos problemas de desempenho atribuídos ao COBOL, na verdade, são consequência de SQL mal escrito ou de um plano de acesso inadequado.


Conclusão — A Lógica é a Maior Aliada do Programador

Ao final desta jornada, descobrimos que uma instrução SQL percorre um caminho muito maior do que imaginávamos. Ela nasce no programa COBOL, passa pelo pré-compilador, gera um DBRM, é ligada a PACKAGEs e PLANs durante o BIND, tem seu plano analisado pelo Optimizer, consulta estatísticas produzidas pelo RUNSTATS, escolhe um Access Path, utiliza Buffer Pools, controla bloqueios, decide estratégias de JOIN e somente então retorna os dados solicitados.

Para um programador COBOL Padawan, compreender essa sequência é um divisor de águas. Você deixa de enxergar o Db2 como uma simples "caixa-preta" e passa a entendê-lo como um verdadeiro computador da Frota Estelar: um sistema que utiliza lógica, estatística e otimização para tomar a melhor decisão possível a cada consulta.

Como diria o Sr. Spock, "A lógica é o começo da sabedoria, não o fim." No universo do IBM Z, essa lógica está presente em cada SELECT, em cada índice e em cada plano de acesso. Quanto melhor você compreender esse funcionamento, mais preparado estará para construir aplicações COBOL rápidas, escaláveis e confiáveis — dignas de uma missão de cinco anos explorando as fronteiras da computação corporativa.

sexta-feira, 18 de maio de 2018

SQL JOINs: O Que Todo Programador COBOL Padawan Precisa Saber Para Entender Como os Bancos de Dados Pensam

 

Bellacosa Mainframe e o uso dos sqljoins em SQL

☕ Um Café no Bellacosa Mainframe

SQL JOINs: O Que Todo Programador COBOL Padawan Precisa Saber Para Entender Como os Bancos de Dados Pensam

Você não está apenas aprendendo comandos SQL. Está aprendendo como bilhões de registros conversam entre si todos os dias.

Existem momentos na carreira de um programador em que um conceito muda completamente sua forma de enxergar a computação.

Para alguns, esse momento acontece ao aprender ponteiros em C.

Para outros, ao descobrir orientação a objetos.

Para quem trabalha com bancos de dados relacionais, esse momento geralmente acontece quando entende, de verdade, os JOINs.

À primeira vista, parecem apenas quatro comandos:

  • INNER JOIN

  • LEFT JOIN

  • RIGHT JOIN

  • FULL OUTER JOIN

Mas, por trás deles, existe uma das maiores invenções da Ciência da Computação moderna.

Para um programador COBOL, compreender JOINs é semelhante a descobrir que, em vez de navegar manualmente por dezenas de arquivos VSAM procurando registros relacionados, existe um mecanismo matemático capaz de fazer isso automaticamente, de forma otimizada, segura e extremamente rápida.

Pegue seu café.

Hoje vamos conversar sobre como os bancos de dados realmente pensam.


Antes do SQL

Imagine que estamos em 1975.

Você trabalha em um grande banco.

Os dados estão espalhados em arquivos.

Existe um arquivo de clientes.

Outro de contas.

Outro de cartões.

Outro de empréstimos.

Outro de movimentações.

Em COBOL, o processamento normalmente seria algo parecido com:

Ler Cliente

Para cada Cliente

    Abrir arquivo de Contas

    Procurar Conta

        Abrir arquivo de Movimentos

        Procurar Movimentos

            Gerar relatório

Nada de errado.

Foi assim durante décadas.

Mas existe um problema.

À medida que os arquivos crescem...

...o processamento cresce junto.

Às vezes de forma exponencial.

Era necessário pensar diferente.


Surge o Modelo Relacional

Em 1970, Edgar F. Codd publicou um artigo que mudou a história da informática.

Sua ideia era brilhante.

Em vez de navegar manualmente entre arquivos...

...o programador apenas declararia:

"Quero relacionar estas duas tabelas."

O banco descobriria o melhor caminho.

Foi o nascimento do SQL moderno.

E junto dele...

...os JOINs.


O que é um JOIN?

JOIN significa literalmente

Junção.

É a operação que une informações de duas ou mais tabelas utilizando algum relacionamento.

Imagine duas tabelas.

CLIENTE

IDNome
1João
2Maria
3Carlos
4Ana

PEDIDO

PedidoClienteValor
1011250
1021400
1033120
1045900

Observe.

O pedido possui um campo chamado CLIENTE.

Esse campo aponta para o ID da tabela CLIENTE.

Visualmente:

CLIENTE

1 João
2 Maria
3 Carlos
4 Ana

        │

        ▼

PEDIDO

101 Cliente 1

102 Cliente 1

103 Cliente 3

104 Cliente 5

Existe um relacionamento.

É justamente isso que o JOIN explora.


INNER JOIN

É o JOIN mais famoso.

Ele responde uma pergunta muito simples.

"Quais registros existem nos dois lados?"

SQL

SELECT
    C.NOME,
    P.VALOR
FROM CLIENTE C
INNER JOIN PEDIDO P
ON C.ID = P.CLIENTE_ID;

Resultado

ClienteValor
João250
João400
Carlos120

Perceba.

Maria desapareceu.

Ana desapareceu.

O pedido do cliente 5 também desapareceu.

Por quê?

Porque não existe correspondência.

O INNER JOIN trabalha exclusivamente com a interseção.

Imagine dois círculos.

CLIENTES

(1 2 3 4)

PEDIDOS

(1 3 5)

Resultado

(1 3)

Apenas aquilo que existe em ambos.


A mágica acontece automaticamente

Quando você escreve:

INNER JOIN

Você não está dizendo ao banco:

"Leia primeiro esta tabela."

Nem:

"Depois percorra aquela."

Nem:

"Faça um loop."

Você apenas declara o resultado desejado.

O banco escolhe como chegar nele.

Esse é o paradigma declarativo.


LEFT JOIN

Agora imagine outra pergunta.

"Quero todos os clientes."

Mesmo aqueles que nunca compraram.

É aqui que entra o LEFT JOIN.

SELECT
    C.NOME,
    P.VALOR
FROM CLIENTE C
LEFT JOIN PEDIDO P
ON C.ID=P.CLIENTE_ID;

Resultado

ClienteValor
João250
João400
MariaNULL
Carlos120
AnaNULL

Observe o NULL.

Ele não significa zero.

Não significa vazio.

Significa simplesmente:

"Não existe registro correspondente."

Esse pequeno detalhe causa milhares de erros em sistemas corporativos.


Descobrindo clientes inativos

Um dos usos mais comuns do LEFT JOIN.

SELECT C.*

FROM CLIENTE C

LEFT JOIN PEDIDO P

ON C.ID=P.CLIENTE_ID

WHERE P.CLIENTE_ID IS NULL;

Resultado.

Maria.

Ana.

São clientes cadastrados.

Mas nunca fizeram pedidos.

Esse tipo de consulta é extremamente comum em:

  • CRM

  • Bancos

  • Seguradoras

  • Telecom

  • E-commerce


RIGHT JOIN

É simplesmente o espelho do LEFT.

Mantém todos os registros da direita.

Na prática...

Poucos desenvolvedores utilizam RIGHT JOIN.

A maioria prefere inverter as tabelas e continuar usando LEFT JOIN.

É mais intuitivo.


FULL OUTER JOIN

Esse é o mais democrático.

Nada é descartado.

Tudo aparece.

Clientes com pedidos.

Clientes sem pedidos.

Pedidos sem clientes.

Tudo.

CLIENTES

1

2

3

4

PEDIDOS

1

3

5

Resultado

1

2

3

4

5

Muito utilizado em auditorias.

Migração de sistemas.

Comparação de bases.

Validação de integrações.


O papel do NULL

Uma das maiores dificuldades dos iniciantes.

Imagine.

Maria nunca comprou.

O resultado será

Maria

NULL

Não escreva

WHERE VALOR=0

Porque NULL não é zero.

Use

WHERE VALOR IS NULL

Parece detalhe.

Mas não é.


O problema da multiplicação de registros

Esse é um conceito que surpreende muitos programadores COBOL.

Imagine.

Um cliente.

Cinco pedidos.

CLIENTE

João
PEDIDO

101

102

103

104

105

Resultado do JOIN.

João

101

João

102

João

103

João

104

João

105

Um registro virou cinco.

Isso é perfeitamente normal.

É consequência da cardinalidade.


Cardinalidade

Existem quatro situações clássicas.

Um para Um

Pessoa

↓

CPF

Cada pessoa possui apenas um CPF.


Um para Muitos

Cliente

↓

Pedidos

Um cliente possui vários pedidos.

É o relacionamento mais comum.


Muitos para Um

Milhares de pedidos.

↓

Um cliente.

É apenas a visão inversa.


Muitos para Muitos

Aluno

↓

Disciplina

Um aluno cursa várias disciplinas.

Uma disciplina possui vários alunos.

Nesse caso normalmente existe uma terceira tabela intermediária.


O erro que derruba servidores

Todo DBA conhece essa história.

Um desenvolvedor escreve:

SELECT *

FROM CLIENTE,

PEDIDO;

Ou

JOIN

sem ON

Resultado.

Produto Cartesiano.

Se houver:

100.000 clientes

100.000 pedidos

O banco produzirá

10 bilhões de combinações.

Pode consumir CPU, memória e I/O de forma devastadora.

Por isso, nunca execute um JOIN sem uma condição de relacionamento bem definida.


Como o DB2 realmente executa um JOIN?

Aqui entramos no mundo do IBM Mainframe.

Você escreve SQL.

Mas quem decide o caminho é o Otimizador do DB2.

Ele analisa dezenas de fatores.

Quantidade de registros.

Índices.

Estatísticas.

Cardinalidade.

Distribuição dos valores.

Buffer Pool.

Espaço disponível.

Custo estimado.

No final...

Escolhe um plano de execução.

É semelhante ao GPS.

Você informa o destino.

Ele calcula a melhor rota.


Nested Loop Join

Imagine duas listas telefônicas.

Você pega um nome.

Procura na outra lista.

Repete.

Esse é o Nested Loop.

Cliente

↓

Índice

↓

Pedido

Excelente quando existe índice.

Muito utilizado em consultas seletivas.


Merge Join

Agora imagine duas listas ordenadas alfabeticamente.

Você percorre ambas ao mesmo tempo.

Sem voltar.

Sem pesquisar novamente.

Muito eficiente para grandes conjuntos já classificados.


Hash Join

Agora imagine uma tabela hash.

Os registros menores são colocados em memória.

Depois a outra tabela apenas consulta essa estrutura.

É extremamente rápido para determinadas situações.


O papel dos índices

Sem índices...

O banco precisa procurar registro por registro.

Com índices...

Ele encontra rapidamente os dados desejados.

Imagine um livro de 2.000 páginas.

Sem índice.

Você folheia página por página.

Com índice.

Vai diretamente ao assunto.

É exatamente isso que acontece.


RUNSTATS

No DB2 existe um utilitário extremamente importante.

RUNSTATS.

Ele atualiza as estatísticas do banco.

Quantidade de linhas.

Número de páginas.

Distribuição dos valores.

Percentual de registros.

Sem essas informações...

O otimizador pode escolher um caminho ruim.

É como dirigir sem GPS.


EXPLAIN

Todo desenvolvedor Mainframe deveria aprender EXPLAIN.

Ele responde perguntas como:

  • Qual índice será utilizado?

  • Quantas páginas serão lidas?

  • Haverá Tablespace Scan?

  • Será usado Hash Join?

  • Nested Loop?

  • Merge Join?

O EXPLAIN é uma janela para o cérebro do DB2.

Não basta escrever SQL correto.

É preciso entender como ele será executado.


JOIN não é apenas SQL

Muitos iniciantes acreditam que JOIN pertence exclusivamente ao SQL.

Na verdade...

JOIN é um conceito matemático.

Baseado em Álgebra Relacional.

Projetos.

Seleções.

Uniões.

Diferenças.

Interseções.

Produto Cartesiano.

Todos esses operadores são estudados muito antes do SQL existir.

SQL apenas transformou essas ideias em uma linguagem prática.


A evolução para Big Data

Mesmo tecnologias modernas continuam utilizando o conceito de JOIN.

Spark SQL.

Hive.

Snowflake.

BigQuery.

Databricks.

DuckDB.

PostgreSQL.

Oracle.

SQL Server.

Todos executam JOINs.

Mudam os algoritmos.

Mudam as otimizações.

Mas a teoria continua exatamente a mesma criada por Edgar Codd há mais de cinquenta anos.

Isso demonstra a força de uma boa ideia.


O que um Programador COBOL Padawan deve levar desta conversa?

Se você está começando sua jornada em informática, talvez pense que JOIN é apenas mais uma palavra da linguagem SQL.

Não é.

JOIN representa uma mudança de mentalidade.

No mundo procedural, típico de muitos programas COBOL tradicionais, você descreve passo a passo como localizar, ler e combinar registros. No mundo relacional, você descreve o que deseja obter, e o banco de dados decide a melhor estratégia para alcançar esse resultado.

Essa diferença parece sutil, mas muda completamente a forma de projetar sistemas.

Ao dominar JOINs, você deixa de enxergar tabelas como arquivos isolados e passa a vê-las como partes de uma grande rede de relacionamentos. É essa visão que permite construir consultas elegantes, sistemas escaláveis e aplicações capazes de responder rapidamente a perguntas complexas sobre milhões — ou até bilhões — de registros.

Da próxima vez que escrever um INNER JOIN, lembre-se de que não está apenas unindo duas tabelas. Está utilizando um dos conceitos mais elegantes da Álgebra Relacional, aperfeiçoado por décadas de pesquisa e otimizado continuamente pelos maiores bancos de dados do mundo.

E essa é uma das grandes lições da engenharia de software: as tecnologias evoluem, as linguagens mudam, o hardware se transforma, mas os fundamentos permanecem. Quem aprende esses fundamentos não está apenas estudando SQL; está construindo uma base sólida para compreender qualquer plataforma de dados, do IBM Z aos ambientes distribuídos em nuvem.

No Bellacosa Mainframe, costumamos dizer que um verdadeiro COBOL Padawan não coleciona apenas comandos. Ele coleciona maneiras diferentes de pensar. Porque, no fim das contas, programar nunca foi apenas escrever código. Programar é aprender a conversar com a lógica que organiza o mundo dos dados. E os JOINs são uma das linguagens mais poderosas dessa conversa.

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