DEV Community: José Leal

Como escalar um sistema legado com arquitetura orientada a eventos (sem reescrevê-lo)

José Leal — Mon, 28 Sep 2026 17:13:01 +0000

Primeiro post de uma série sobre arquitetura orientada a eventos (EDA),
construída em público a partir de um case fictício: a Faculdade Leal. Este
post fica em nível de arquitetura — a implementação (Apache Camel, código
dos consumers, etc.) vem nos posts seguintes, conforme for sendo construída.

O problema

Imagine que você é responsável pelo financeiro de uma faculdade grande.
Todo mês, o sistema precisa gerar a fatura de milhares de alunos — calculando
matérias cursadas, dependências e taxas de serviço — e hoje isso leva cerca
de 4 dias.

Paralelamente, quando um aluno entra no site pra pegar o boleto, o sistema
aciona outra procedure (GeraFaturaFinal), que lê o resultado já
calculado — guardado na TbFatura — e, na mesma execução síncrona,
chama duas APIs externas em sequência: primeiro o Sistema de Pagamentos,
pra gerar o boleto; depois a Prefeitura, pra emitir a nota fiscal (NFS-e).
Se a segunda falhar, o processo inteiro retorna erro — mesmo o boleto que
já tinha sido gerado é descartado. Funciona bem com pouco acesso e os dois
terceiros no ar. Perto do vencimento, com muito acesso simultâneo e qualquer
instabilidade da Prefeitura, o site fica lento, cai, ou devolve erro em
pedidos que já tinham, na prática, dado certo.

A arquitetura atual está desta forma:

Fluxo em lote — cálculo da fatura

Fluxo sob demanda — boleto no clique do usuário

(desenho original: https://github.com/lealnetosena/faculdade-leal/blob/master/diagramas/arquitetura-atual.drawio; versão em
Mermaid equivalente em https://github.com/lealnetosena/faculdade-leal/blob/master/diagramas/01-arquitetura-atual.md)

Os problemas, resumidos:

As tabelas TbLancamentos e TbFatura têm dados acumulados de anos, sem processo de expurgo ou limpeza, e faltam alguns índices.
O processamento é feito linha a linha, aluno por aluno, e não em lote.
O usuário pede a fatura e ela executa diversas chamadas síncronas, tanto para o sistema legado quanto para as APIs externas.

Soluções propostas e nova arquitetura

Três frentes resolvem os problemas acima. As duas primeiras são ajustes
pontuais no banco de dados; a terceira é a decisão arquitetural central
deste post, e é ela que o resto do texto detalha:

Criação de índices.
Criação de processo de expurgo no banco de dados.
Vamos implantar arquitetura orientada a eventos (EDA): cada etapa — cálculo da fatura, geração do boleto, emissão da nota fiscal — passa a reagir a um evento, em vez de depender de uma chamada síncrona encadeada. Isso desacopla as etapas entre si e do legado.

A implantação consiste em criar um broker de mensageria (Kafka) com eventos
bem definidos.

1. Producer — fatura pronta

O legado não muda nada — continua realizando o processo de cálculo do jeito
que já faz. Quem avisa que uma fatura ficou pronta é um componente novo, e
aqui existem duas soluções possíveis, porque nem todo ambiente vai
permitir a ideal.

Solução A — Polling (mais simples, acesso padrão)
Um projeto lê a TbFatura a cada 30 minutos e publica as faturas prontas no
evento fatura.pronta. Não exige nenhuma permissão especial no banco — só
uma conexão de leitura comum, do tipo que qualquer aplicação já tem. Em
troca, aceita até 30 minutos de atraso e uma consulta periódica na tabela.

Solução B — CDC / Debezium (ideal, mas exige acesso de replicação)
Um conector lê o log de transação do banco diretamente — o registro
interno que todo banco já mantém, pra recuperação e réplica — e reage em
milissegundos, sem tocar na tabela nem no legado. O problema: isso exige que
o time de banco de dados libere uma permissão especial (usuário de
replicação), e nem toda empresa concede isso com facilidade, ou já tem a
infraestrutura (Kafka Connect) pronta.

Por enquanto, seguimos com a Solução A, documentando a B como evolução
possível se o acesso existir ou se o atraso de 30 min virar uma dor real.

2. Consumer — finaliza fatura

Em vez de finalizar a fatura no momento em que o usuário clica, isso passa a
acontecer antes: como o processo de geração já demora até 4 dias, durante
essa janela, conforme as faturas vão ficando prontas (fatura.pronta), já
rodamos o cálculo final que hoje é feito no clique (o passo 1.2 de
GeraFaturaFinal). Ao terminar, publica fatura.finalizada — só isso, sem
gravar nada. Persistir é responsabilidade de outro componente.

3. Consumer — persiste fatura (atômico)

Um componente com uma responsabilidade só: ouvir fatura.finalizada e
gravar o resultado num banco de dados próprio (não o do legado — um
armazenamento novo, dono desse dado). A gravação é insert-only: cada
cálculo vira uma linha nova, com data e hora, nunca sobrescrevendo a
anterior. Isso dá dois resultados de graça — uma consulta rápida (a linha
mais recente de um aluno) e um histórico completo, útil pra auditoria,
inclusive se um valor foi recalculado depois, e quando. É esse banco que o
Consumer gerar boleto vai consultar mais tarde, no clique do usuário.

4. Consumer — gerar boleto

Também usa fila, mas dispara no clique do usuário (boleto.solicitado),
não de forma proativa: gerar o boleto com antecedência pode ficar errado se
o aluno pagar via PIX, que não aplica o mesmo desconto. O PIX em si não é o
problema hoje, está funcional — mas ainda assim ele isola o boleto do
fornecedor de pagamento usado: a mensagem carrega um campo dizendo qual é o
fornecedor, e mantém o design plugável pra escalar com mais projetos
conectados. (PIX fica fora do escopo do resto da série — citado aqui só como
o motivo de design por trás do boleto ser gerado no clique, não de forma
proativa.) Ao final, publica boleto.gerado, que aciona o Consumer de
Nota Fiscal e também devolve o boleto pro usuário.

5. Consumer — Nota Fiscal

Verifica o evento boleto.gerado e aciona a API da Prefeitura. Esta é a
etapa mais problemática hoje, então aqui entra retry em caso de erro, com
uma fila própria (notafiscal.erro) pra tratar o que esgotar as tentativas.
Em caso de sucesso, publica notafiscal.pronta.

6. Consumer — nota fiscal pronta

Conectado à API de notificação e ao site — o site terá um local pra
consultar a nota, e ela também será enviada por e-mail ao usuário.

Por que isso escala naturalmente

Com esses componentes isolados, temos possibilidade de escalar
horizontalmente, e isso vai acontecer naturalmente, por dois motivos:

O sistema legado tem uma pendência de expurgo e manutenção de índice e
performance (existe até oportunidade de melhorar a procedure). Como é
algo crítico e exige bastante validação, isso vai acontecer ao longo dos
meses. Conforme a velocidade do processamento das faturas for melhorando,
a capacidade dos consumers pode ser expandida — e isso pode até ser feito
de forma automática, usando Kubernetes.
Na aquisição de uma nova unidade, ela também vai precisar inserir no
consumer de fatura pronta (ou de fatura final), e, caso tenha um volume
maior, os consumers também podem crescer automaticamente.

Eventos — quem publica, quem consome

Evento	Publica	Consome	Quando
`fatura.pronta`	Producer (polling 30min)	Consumer finaliza fatura	`CalculaFatura` terminou pra 1 aluno
`fatura.finalizada`	Consumer finaliza fatura	Consumer persiste fatura — grava insert-only num banco próprio (não o do legado)	Cálculo final rodou, proativo
`boleto.solicitado`	Consumer gerar boleto (dispara com o clique do usuário no Site)	Consumer gerar boleto — consulta o banco (não consome `fatura.finalizada` de novo)	Aluno clicou pedindo o boleto
`boleto.gerado`	Consumer gerar boleto	Consumer Nota Fiscal (e o próprio Consumer gerar boleto usa a resposta pra devolver o boleto ao usuário)	Sistema de Pagamentos respondeu
`notafiscal.pronta`	Consumer Nota Fiscal	Consumer nota fiscal pronta (site/e-mail)	Prefeitura respondeu
`notafiscal.erro`	Consumer Nota Fiscal	Fila de erro / alerta	Esgotou retry

A nova arquitetura

(diagramas: ver https://github.com/lealnetosena/faculdade-leal/blob/master/diagramas/02-arquitetura-proposta.md — a arquitetura
completa com os componentes descritos acima, além do detalhamento
completo com os nomes concretos de tecnologia em
https://github.com/lealnetosena/faculdade-leal/blob/master/diagramas/arquitetura-atual.drawio)

flowchart LR
    Legado["Sistema Acadêmico<br/>(legado, sem mudança)"] --> Producer["Producer<br/>fatura pronta"]
    Producer -->|fatura.pronta| CF["Consumer<br/>finaliza fatura"]
    CF -->|fatura.finalizada| CP["Consumer<br/>persiste fatura<br/>(atômico)"]
    CP --> Banco[("Banco próprio<br/>insert-only")]

    Aluno(["Aluno<br/>clica no site"]) -->|boleto.solicitado| CB["Consumer<br/>gerar boleto"]
    Banco --> CB
    CB --> Pagamentos["Sistema de<br/>Pagamentos"]
    CB -->|boleto entregue| Recebido(["Aluno recebe<br/>o boleto"])
    CB -->|boleto.gerado| CNF["Consumer<br/>Nota Fiscal"]

    CNF --> Prefeitura["Sistema Prefeitura<br/>NFS-e"]
    CNF -->|notafiscal.erro| ErroFila[("Fila de erro")]
    CNF -->|notafiscal.pronta| CNP["Consumer<br/>nota fiscal pronta"]
    CNP --> Aviso(["Aluno é avisado<br/>site / e-mail"])

    classDef novo fill:#d5e8d4,stroke:#82b366
    class Producer,CF,CP,CB,CNF,CNP novo

Versão detalhada, com os nomes concretos de tecnologia (Spring Batch, Spring
Boot, Apache Camel) e a numeração passo a passo — desenhada no draw.io:

Fluxo de cálculo — fatura pronta e persistida

Fluxo de boleto — request-reply sobre Kafka + nota fiscal isolada

Bala de prata?

A arquitetura orientada a eventos (EDA) é uma ferramenta importante para
resolver problemas complexos e grandes. Este cenário hipotético é bem
simplificado, mas dá um gosto de um contexto maior, expandido com diversas
áreas. E "bala de prata" é bem a palavra errada pra usar aqui — como toda
decisão de arquitetura, ela troca um conjunto de problemas por outro. Abaixo,
os prós e os contras de implantar essa arquitetura, de forma mais técnica:

Prós

Desacoplamento entre times e sistemas — quem publica e quem consome não precisam se conhecer, nem fazer deploy juntos, nem compartilhar banco.
Isolamento de falha — se um consumer cai ou fica lento, não derruba quem publicou nem os outros consumers.
Escala independente — aumenta instâncias de um consumer sem tocar no publicador, e vice-versa.
Um fato, várias reações (fan-out) — quando algo precisa disparar N ações independentes, o publicador não precisa saber nem orquestrar quem são elas.
Desacoplamento no tempo — publicador e consumidor não precisam estar no ar ao mesmo tempo.
Trilha de auditoria e replay — com um log como o Kafka, existe histórico do que aconteceu, e dá pra reprocessar.
Ponte entre legado e novo sem reescrever o legado — o sistema antigo só publica um evento, o resto reage sem tocar nele (Strangler Fig).

Contras

Complexidade operacional — de um sistema só, passamos a ter 6+ processos independentes, cada um com seu próprio deploy, log e monitoramento.
Consistência eventual, por design — o aluno pode ver o boleto pronto e a nota ainda "em processamento"; o site precisa saber lidar com estados intermediários, algo que não existia no fluxo síncrono de hoje.
Falha parcial vira um estado real — sem retry e fila de erro bem pensados, uma mensagem perdida é pior do que o erro síncrono de hoje, porque ninguém percebe na hora.
Depuração mais difícil — em vez de olhar um log só, é preciso correlacionar eventos entre vários serviços pra entender o que aconteceu com uma fatura específica.
Curva de aprendizado — o time precisa entender conceitos que não existiam no mundo síncrono: mensageria, consumer groups, idempotência.
Atraso da Solução A — o polling ainda deixa até 30 minutos de defasagem; não é tempo real de verdade até evoluir pra CDC.

Eu me considero um eterno estudante. Esse artigo foi criado por mim, com
auxílio de inteligência artificial. Caso encontre algum erro ou alguma
melhoria, fique à vontade para me enviar.

Configuração Simples para rodar servidor PHP. (sem senha ADM)

José Leal — Mon, 02 Jan 2023 20:36:01 +0000

Hoje precisei configurar um ambiente de desenvolvimento para rodar script's PHP e consegui de forma simples seguindo os passos abaixo:

1- Baixe a versão mais recente no site oficial php

2- Descompacte e deixe os arquivos em um pasta que possa usar depois (pode ser em qualquer pasta do Windows) no meu caso coloquei no C:\php

3- Você já pode subir um servidor executando o seguinte comando no prompt de comando(cmd):
C:\php\php.exe -S localhost:8888

4- Observe que o caminho do meu CMD é C:\Git\php_projeto e nesse local que tem que está seus arquivos php:

5- Para facilitar você pode adicionar o php as variaveis de ambientes para que não precise passar o caminho do php todas as vezes

Escolha a segunda opção para nível usuário(sem senha ADM)

6- Agora pode digitar o comando para iniciar o servidor da seguinte forma:
php -S localhost:8888

Scripts (.bat)

José Leal — Thu, 17 Feb 2022 19:56:31 +0000

Configuração Arquivo Imagem Scanner

O programa que realiza o escaneamento das impressoras Brother define por padrão o formato .bmp que com as resoluções necessárias cada arquivo ocupava em média 24 MB de espaço em disco.

Sempre tínhamos problemas de armazenamento nos computadores(120 onde eu atuava) devido a essa configuração.

Foi encontrado as chaves de registros do windows onde eram armazenadas estas configurações.

Realizamos uma configuração padrão exportamos e desenvolvemos o script abaixo que adicionamos idle-time para que funcionasse corretamente

@ping 127.0.0.1 -n 10 -w 1000 > nul
taskkill /F /IM BrccMCtl.exe
taskkill /F /IM brctrcen.exe
@ping 127.0.0.1 -n 2 -w 1000 > nul
REG ADD "HKCU\Software\Brother\ControlCenter\3.0\MFC-8890DW LAN\Tabs\0000\Button0\HardBtn\BtnAction" /v "FileType" /t REG_DWORD /d "0x00000003" /f
REG ADD "HKCU\Software\Brother\ControlCenter\3.0\MFC-8890DW LAN\Tabs\0000\Button0\HardBtn\BtnAction" /v "FileComp" /t REG_DWORD /d "0x00000003" /f
REG ADD "HKCU\Software\Brother\ControlCenter\3.0\MFC-8890DW LAN\Tabs\0000\Button0\HardBtn\ScanSetting" /v "Resolution" /t REG_DWORD /d "0x00000064" /f
REG ADD "HKCU\Software\Brother\ControlCenter\3.0\MFC-8890DW LAN\Tabs\0000\Button0\SoftBtn\BtnAction" /v "FileType" /t REG_DWORD /d "0x00000003" /f
REG ADD "HKCU\Software\Brother\ControlCenter\3.0\MFC-8890DW LAN\Tabs\0000\Button0\SoftBtn\BtnAction" /v "FileComp" /t REG_DWORD /d "0x00000003" /f
REG ADD "HKCU\Software\Brother\ControlCenter\3.0\MFC-8890DW LAN\Tabs\0000\Button0\SoftBtn\ScanSetting" /v "Resolution" /t REG_DWORD /d "0x00000064" /f
REG ADD "HKCU\Software\Brother\ControlCenter\3.0\MFC-8890DW LAN\Tabs\0000\Button3\HardBtn\BtnAction" /v "FileType" /t REG_DWORD /d "0x0000000e" /f
REG ADD "HKCU\Software\Brother\ControlCenter\3.0\MFC-8890DW LAN\Tabs\0000\Button3\HardBtn\BtnAction" /v "FileComp" /t REG_DWORD /d "0x00000003" /f
REG ADD "HKCU\Software\Brother\ControlCenter\3.0\MFC-8890DW LAN\Tabs\0000\Button3\HardBtn\ScanSetting" /v "Resolution" /t REG_DWORD /d "0x00000064" /f
REG ADD "HKCU\Software\Brother\ControlCenter\3.0\MFC-8890DW LAN\Tabs\0000\Button3\SoftBtn\BtnAction" /v "FileType" /t REG_DWORD /d "0x0000000e" /f
REG ADD "HKCU\Software\Brother\ControlCenter\3.0\MFC-8890DW LAN\Tabs\0000\Button3\SoftBtn\BtnAction" /v "FileComp" /t REG_DWORD /d "0x00000003" /f
REG ADD "HKCU\Software\Brother\ControlCenter\3.0\MFC-8890DW LAN\Tabs\0000\Button3\SoftBtn\ScanSetting" /v "Resolution" /t REG_DWORD /d "0x00000064" /f
REG ADD "HKCU\Software\Brother\ControlCenter\3.0\MFC-8860DN LAN\Tabs\0000\Button0\HardBtn\BtnAction" /v "FileType" /t REG_DWORD /d "0x00000003" /f
REG ADD "HKCU\Software\Brother\ControlCenter\3.0\MFC-8860DN LAN\Tabs\0000\Button0\HardBtn\BtnAction" /v "FileComp" /t REG_DWORD /d "0x00000003" /f
0000\Button0\HardBtn\ScanSetting" /v "Resolution" /t REG_DWORD /d "0x00000064" /f
REG ADD "HKCU\Software\Brother\ControlCenter\2.0\MFC-8890DW LAN\Tabs\0000\Button0\SoftBtn\BtnAction" /v "FileType" /t REG_DWORD /d "0x00000003" /f
REG ADD "HKCU\Software\Brother\ControlCenter\2.0\MFC-8890DW LAN\Tabs\0000\Button0\SoftBtn\ScanSetting" /v "Resolution" /t REG_DWORD /d "0x00000064" /f
REG ADD "HKCU\Software\Brother\ControlCenter\2.0\MFC-8890DW LAN\Tabs\0000\Button3\HardBtn\BtnAction" /v "FileType" /t REG_DWORD /d "0x0000000e" /f
REG ADD "HKCU\Software\Brother\ControlCenter\2.0\MFC-8890DW LAN\Tabs\0000\Button3\HardBtn\ScanSetting" /v "Resolution" /t REG_DWORD /d "0x00000064" /f
REG ADD "HKCU\Software\Brother\ControlCenter\2.0\MFC-8890DW LAN\Tabs\0000\Button3\SoftBtn\BtnAction" /v "FileType" /t REG_DWORD /d "0x0000000e" /f
REG ADD "HKCU\Software\Brother\ControlCenter\2.0\MFC-8890DW LAN\Tabs\0000\Button3\SoftBtn\ScanSetting" /v "Resolution" /t REG_DWORD /d "0x00000064" /f
REG ADD "HKCU\Software\Brother\ControlCenter\2.0\MFC-8480DN LAN\Tabs\0000\Button0\HardBtn\BtnAction" /v "FileType" /t REG_DWORD /d "0x00000003" /f
REG ADD "HKCU\Software\Brother\ControlCenter\2.0\MFC-8480DN LAN\Tabs\0000\Button0\HardBtn\ScanSetting" /v "Resolution" /t REG_DWORD /d "0x00000064" /f
REG ADD "HKCU\Software\Brother\ControlCenter\2.0\MFC-8480DN LAN\Tabs\0000\Button0\SoftBtn\BtnAction" /v "FileType" /t REG_DWORD /d "0x00000003" /f
REG ADD "HKCU\Software\Brother\ControlCenter\2.0\MFC-8480DN LAN\Tabs\0000\Button0\SoftBtn\ScanSetting" /v "Resolution" /t REG_DWORD /d "0x00000064" /f
REG ADD "HKCU\Software\Brother\ControlCenter\2.0\MFC-8480DN LAN\Tabs\0000\Button3\HardBtn\BtnAction" /v "FileType" /t REG_DWORD /d "0x0000000e" /f
REG ADD "HKCU\Software\Brother\ControlCenter\2.0\MFC-8480DN LAN\Tabs\0000\Button3\HardBtn\ScanSetting" /v "Resolution" /t REG_DWORD /d "0x00000064" /f
REG ADD "HKCU\Software\Brother\ControlCenter\2.0\MFC-8480DN LAN\Tabs\0000\Button3\SoftBtn\BtnAction" /v "FileType" /t REG_DWORD /d "0x0000000e" /f
REG ADD "HKCU\Software\Brother\ControlCenter\2.0\MFC-8480DN LAN\Tabs\0000\Button3\SoftBtn\ScanSetting" /v "Resolution" /t REG_DWORD /d "0x00000064" /f

@ping 127.0.0.1 -n 2 -w 1000 > nul
"C:\Program Files (x86)\Brother\ControlCenter3\BrccMCtl.exe"
"c:\Program Files (x86)\Brother\ControlCenter2\brctrcen.exe"
"C:\Program Files\Brother\ControlCenter3\BrccMCtl.exe"
"c:\Program Files\Brother\ControlCenter2\brctrcen.exe"

Gestão/Automação Processos

José Leal — Thu, 17 Feb 2022 18:49:03 +0000

Solicitação de Arquivo em Servidor

Para iniciar um processamento de uma planilha era necessário pedir os arquivos em TXT em um servidor que só disponibilizava esses arquivos após as 18h.

E esse arquivo deve ser pedido todo 1° dia útil do mês. Porém como o prazo de entrega desse processamento tem que ser o mais rápido possível, foi cogitado por mim um teste as 6h da manhã já que dava a entender que o arquivo só era gerado fora do horário comercial.
Foi desenvolvido um robô utilizando VBA/Excel, Script(.Bat),Outlook, e Agendador de tarefas do Windows.
Esse robô realizava os seguinte passos

Disparo realizado pelo Agendador de tarefa do windows

Abrir o sistema ERP da empresa(.Bat)

Abrir a planilha de pedido(.Bat)

Realizar o Login e pedido do arquivo (vba)

Salva a planilha e envia o um e-mail utilizando o Outlook com o status do pedido para meu email pessoal(vba)

Caso houvesse algum erro eu já recebia a informação e já atuava.

Após testes foi implementado e os arquivos eram disponibilizados no horário solicitado(pela manhã antes do expediente)

Ao iniciar o dia de trabalho já estava com os arquivos ganhando 1 dia no prazo

Python

José Leal — Thu, 17 Feb 2022 17:27:45 +0000

Sumário
- Consulta CEP
- Editor PDF

Consulta CEP

O código abaixo interage com o navegador Chrome ao relizar a consulta do CEP dentro do site dos correios, colando e clicando nos botões da página.

E com o Resultado as informações são inseridas em uma planilha.

Nesse exemplo consulto 25 cep's, que trouxe o resultado em 18s

from playwright.sync_api import sync_playwright
import openpyxl

# Carregando arquivo
book = openpyxl.load_workbook('base_cep.xlsx')
# Selecionando uma página
planilha = book['Planilha1']
cep = []

for rows in planilha.iter_rows(min_row=2,max_row=26,min_col=1,max_col=1):
    cep.append(rows[0].value)


with sync_playwright() as p:
    browser = p.chromium.launch(headless=False)
    page = browser.new_page()
    j = 2
    for i in cep: 

        page.goto("https://buscacepinter.correios.com.br/app/endereco/index.php")
        # page.wait_for_timeout(1000)
        # Colar o CEP name = "endereco"
        page.fill("input[name='endereco']",i)
        # page.wait_for_timeout(1000)
        # Clicar no botão buscar name="btn_pesquisar"
        page.click("button[name='btn_pesquisar']")
        # page.wait_for_timeout(1000)
        planilha['B' + str(j)] = page.text_content("td[data-th='Logradouro/Nome']")
        planilha['C' + str(j)] = page.text_content("td[data-th='Bairro/Distrito']")
        planilha['D' + str(j)] = page.text_content("td[data-th='Localidade/UF']")

        print(page.text_content("td[data-th='Logradouro/Nome']"))
        print(page.text_content("td[data-th='Bairro/Distrito']"))
        print(page.text_content("td[data-th='Localidade/UF']"))

        j = j + 1
book.save('base2.xlsx')

Planilha que é utilizada:

VBA

José Leal — Thu, 17 Feb 2022 17:27:00 +0000

Transformação de TXT em Excel

Existia um código vba que realizava o tratamento de arquivo TXT e transformava em Excel. Porém como existiam vários TXT denominados com UF era necessário executar o código em cada UF repetindo os passos cerca de 15 vezes.

Foi aproveitado e modificado de outro código vba que realizava o mesmo trabalho só que para estrutura de arquivos diferentes.

Em resumo o arquivo TXT em análise era separado por quantidade de caracteres já ou outro separado por ;. Então modifiquei a estrutura do código e adicionei também os formatos de colunas.

Com isso o código agora com um loop já faz o trabalho nos 15 arquivos e já empilha.

Veja como o código ficou:

Técnicas Avançadas Excel

José Leal — Thu, 17 Feb 2022 17:10:36 +0000

Essas dicas e alterações são para que melhore a produtividade e você ganhe tempo em cada tarefa fazendo que no fim você ganhe horas.

Sumário
- Consulta Binária
- Cálculo Manual

Consulta binária
Solução: Retorna o resultado de uma consulta de uma tabela(procv/corresp) muito rapidamente.

Nas formulas do excel PROCV e CORRESP existe um argumento que altera a forma que a consulta é realizada.
Normalmente utilizamos a consulta exata:

PROCV(A2;B:D;2;FALSO) / CORRESP(A2;B:B;1)

que traz o resultado normalmente porém caso você queria fazer muitas consultas ao mesmo tempo (no meu caso 100.000) vai demorar bastante para concluir.

Nos testes as consultas dessa planilha ai (a dos 100.000 consultas) demorava cerca de 5 minutos. E como tinha que fazer essas consultas pelo menos umas 20 vezes no período de 2 horas ficava inviável.

A solução foi fazer duas alterações:
1- Alterar o argumento das fórmulas para correspondência aproximada, ficando assim:

PROCV(A2;B:D;2;VERDADEIRO) / CORRESP(A2;B:B;0)

2- Ordenar a base com a coluna de consulta/índice em ordem alfabética ou do maior para o menor

Pronto!!

Agora tem um porém devido a característica da consulta é necessário um mudança da formula:

SE(PROCV(A2;B:D;1;VERDADEIRO)=A2;PROCV(A2;B:D;3;VERDADEIRO); NÃO.DISP())

SE(ÍNDICE(B:B;CORRESP(A2;B:D;1))=A2;ÍNDICE(D:D;CORRESP(A2;B:D;1)); NÃO.DISP())

Isso se faz necessário pois como essa consulta utiliza o algoritmo binária ou seja divide o intervalo em partes
o valor que pesquisamos é comparado com o elemento no meio da lista e se não corresponder vai dividindo a tabela que ficam no intervalo fora da pesquisa até chegar ao valor mais próximo do valor que procuramos.

Conceito bastante utilizado em bancos de dados chamado de índice(http://www.linhadecodigo.com.br/artigo/3620/indices-mysql-otimizacao-de-consultas.aspx)

O Resultado dessa consulta nesse case de 100.000 consultas, hoje é concluído em cerca 10 segundos considerando um processador Core i5-4570 - 3.20 Ghz - 8Gb Ram - HDD disco magnético (não ssd)

Cálculo Manual

Por padrão o excel ao criar uma fórmula ele realiza o cálculo da fórmula automaticamente, por exemplo
Se criou a fórmula abaixo

=SOMA(A2;A3)

E depois disso alterar os valores de A2 e A3 o excel realiza esse calculo automaticamente.

Porém se tiver planilhas grandes e com muitas fórmulas pode começar a observar o excel travando ou lento, porém ele dá um sinal do por que está assim:

Isso mostra que por algum motivo o excel está realizando os cálculos que as vezes você não pediu.

Uma solução para este problema é alterar a configuração padrão para calcular manualmente. Que agora para calcular a planilha atual utiliza-se F9 e toda a pasta de trabalho Ctrl+F9.

Com essa alteração você ganha bastante tempo e o Excel só vai calcular quando solicitado.

Atenção: Se abrir alguma planilha depois dessa alteração todas elas irão absorver essa característica e com isso ao salvar e outras pessoas abrirem podem cometer erros ao achar que está automático. Ou seja use essa dica com cuidado