LQRS: Learned Query Re-optimization Framework for Spark SQL

Each language version is independently generated for its own context, not a direct translation.

Imagine que você é o chefe de uma grande cozinha de restaurante (o Spark SQL) e precisa preparar um banquete complexo para centenas de pessoas. O seu trabalho é decidir a ordem em que os pratos serão feitos para que tudo saia pronto o mais rápido possível.

Aqui está a história do LQRS, explicado de forma simples:

1. O Problema: O Chef que Adivinha

Antigamente, os cozinheiros (os otimizadores de banco de dados tradicionais) usavam uma receita antiga e fórmulas manuais para adivinhar quanto tempo cada prato levaria.

O erro: Eles achavam que o "prato A" levaria 10 minutos, então o colocavam por último. Mas, na hora de cozinhar, descobriam que o "prato A" na verdade só tinha 1 ingrediente e levava 1 segundo! Como eles não podiam mudar a ordem depois de começar a cozinhar, o restaurante ficava parado esperando, e o cliente ficava com fome.

Depois, vieram os "Chefes Inteligentes" (os otimizadores aprendizados ou LQO). Eles usavam inteligência artificial para estudar receitas antigas e prever melhor o tempo.

O novo erro: Mesmo sendo inteligentes, eles ainda tinham que decidir tudo antes de acender o fogão. Se a previsão deles estivesse errada (porque os ingredientes mudaram de tamanho no dia), eles não podiam mudar o plano no meio da execução. Era como tentar dirigir um carro olhando apenas para um mapa antigo, sem olhar pela janela.

2. A Solução: O Chef que Olha pela Janela (LQRS)

O LQRS é como um novo tipo de chef que combina a inteligência de um robô com a capacidade de olhar para a panela enquanto o cozimento acontece.

Ele funciona em duas etapas:

Planejamento Inicial: Ele usa a IA para fazer uma boa estimativa antes de começar.
Reajuste em Tempo Real (O Pulo do Gato): Assim que o primeiro prato sai da panela e ele vê que ficou pronto em 1 segundo (e não 10), ele grita para a equipe: "Esqueçam o plano! Vamos mudar a ordem dos próximos pratos agora!".

Ele não espera o banquete todo acabar para aprender; ele aprende e corrige a cada passo.

3. Como ele faz isso? (A Analogia da Montanha-Russa)

Pense na execução de uma consulta de banco de dados como uma montanha-russa cheia de curvas (junções de tabelas).

O sistema antigo (Spark SQL padrão): O trem sai da estação com um roteiro fixo. Se ele perceber que uma curva está muito lenta, ele só pode trocar o tipo de freio (estratégia de junção), mas não pode mudar a ordem das curvas.
O LQRS: É como ter um controlador de trem que está sentado ao lado do maquinista.
- Ele vê que o trem passou por uma curva rápida (uma tabela pequena).
- Ele diz: "Ei, como essa parte foi rápida, vamos pular direto para a próxima parte do trilho que estava lá atrás!".
- Ele pode reorganizar o trem enquanto ele está em movimento, sem precisar parar a montanha-russa inteira e começar do zero.

4. O "Treinamento" (Aprendizado por Curriculum)

O LQRS não aprende tudo de uma vez, o que seria assustador. Ele usa uma estratégia chamada "Aprendizado Curricular":

Fase 1 (Bebê): Ele só aprende a escolher o melhor ponto de partida (qual receita usar).
Fase 2 (Criança): Ele aprende a fazer pequenos ajustes, como trocar a ordem de dois ingredientes.
Fase 3 (Adulto): Ele aprende a fazer grandes mudanças, como reorganizar toda a cozinha se necessário.

Isso evita que ele cometa erros bobos no início e o torna mais estável.

5. O Resultado: O Banquete Mais Rápido

O artigo mostra que, ao usar esse sistema:

O tempo total para servir o banquete (executar a consulta) caiu em até 90% em comparação com os outros sistemas.
Em alguns casos, o que levava 300 segundos (5 minutos) passou a levar apenas 30 segundos.
Ele evita que o sistema "trave" (estoure a memória) ao perceber cedo que um prato está ficando gigante demais e mudar a estratégia imediatamente.

Resumo em uma Frase

O LQRS é um sistema inteligente que não apenas planeja a melhor rota antes de sair, mas que tem a coragem e a inteligência de mudar a rota no meio da viagem assim que vê que o trânsito mudou, garantindo que você chegue ao destino muito mais rápido do que os outros.

Each language version is independently generated for its own context, not a direct translation.

Título: LQRS: Framework de Re-otimização de Consultas Aprendida para Spark SQL

Autores: Jiahao He, Yutao Cui, Cuiping Li, Jikang Jiang, Yuheng Hou, Hong Chen (Universidade Renmin da China).

1. O Problema

Os otimizadores de consultas são componentes fundamentais dos sistemas de gerenciamento de banco de dados (SGBDs). Embora os otimizadores baseados em aprendizado (Learned Query Optimizers - LQOs) tenham superado os otimizadores tradicionais baseados em custo em muitos cenários, eles compartilham uma limitação crítica: operam sob o paradigma "otimizar-então-executar".

Limitação da Otimização Pré-execução: Os LQOs atuais (como o Lero) geram um plano de execução estático baseado em estatísticas estimadas antes da execução começar.
Falha em Aproveitar Observações em Tempo Real: Eles não conseguem utilizar observações valiosas geradas durante a execução (como a cardinalidade real de tabelas ou o tamanho dos dados intermediários) para re-otimizar dinamicamente o plano.
Consequência: Se as estimativas iniciais estiverem erradas ou se os dados se comportarem de maneira inesperada durante a execução, o plano permanece subótimo, resultando em tempos de execução longos e ineficiência. Exemplos práticos mostram que ajustar a ordem de junção (join) com base em dados reais pode reduzir o tempo de execução em mais de 30%, algo que os otimizadores estáticos não conseguem fazer.

2. Metodologia: O Framework LQRS

Para resolver isso, os autores propõem o LQRS (Learned Query Re-optimization Framework), um sistema que integra aprendizado de máquina ao framework de Execução Adaptativa de Consultas (AQE) do Spark SQL. O LQRS permite que as decisões de otimização sejam adiadas para o tempo de execução e guiadas por observações reais.

Arquitetura e Componentes Principais:

O sistema é composto por dois módulos principais que interagem durante a execução da consulta:

Extensão do Planejador (Planner Extension):
- Construído sobre as interfaces de extensibilidade do Spark SQL.
- Atua como um intermediário que intercepta o plano de execução em pontos de sincronização naturais (finais de query stages, onde os dados são materializados).
- Extrai estatísticas de tempo de execução (cardinalidade real, tamanho em bytes) e o plano parcialmente executado.
- Aplica ações de otimização (como reordenar junções ou alterar estratégias de join) diretamente no plano em execução, sem reiniciar a consulta.
Modelo de Decisão (Decision Model):
- Utiliza uma arquitetura de Aprendizado por Reforço (Reinforcement Learning - RL) baseada no framework Actor-Critic.
- Estado ( $s$ ): Representado pelo plano parcialmente executado e suas estatísticas reais (cardinalidade e tamanho).
- Ações ( $a$ ): O modelo pode escolher entre cinco tipos de ações:
  - init: Selecionar a estratégia de inicialização do plano.
  - swap: Trocar a ordem de dois nós folha (tabelas) no plano.
  - lead: Promover uma tabela específica para ser juntada mais cedo.
  - broadcast: Forçar uma junção por difusão (broadcast join) em um nó específico.
  - no-op: Não realizar ação (esperar por mais informações).
- Recompensa ( $r$ ): Baseada no tempo total de execução e no número de operações de shuffle adicionais introduzidas pelas re-otimizações. O modelo é penalizado por causar rearranjos desnecessários de dados.

Estratégias de Aprendizado:

Aprendizado de Currículo (Curriculum Learning): Para garantir estabilidade, o modelo começa aprendendo decisões simples (como apenas a inicialização do plano) e gradualmente aumenta a complexidade, permitindo ações de reordenação em tempo real apenas em fases posteriores do treinamento.
Codificação de Características: Utiliza uma arquitetura TreeCNN (Rede Neural Convolucional em Árvores) para codificar a estrutura da árvore de consulta e suas estatísticas em vetores, permitindo que o modelo generalize bem mesmo com mudanças de esquema ou distribuição de dados.
Feedback Denso: Diferente de métodos que avaliam apenas o resultado final, o LQRS recebe feedback a cada etapa de decisão (a cada query stage), permitindo correções imediatas.

3. Contribuições Chave

Primeiro Otimizador Aprendido Unificado no Spark SQL: O LQRS é o primeiro framework que suporta simultaneamente a otimização pré-execução e durante a execução (in-execution) em um único processo de aprendizado.
Integração com AQE: Aproveita o mecanismo nativo de AQE do Spark 3.0+ para coletar estatísticas precisas e permitir a modificação online do plano, algo que otimizadores puramente estáticos não conseguem fazer.
Extensão Plug-and-Play: Desenvolveu uma extensão do planejador que permite a modificação dinâmica de planos (como a exploração de junções "bushy" ou não lineares) sem violar a semântica da consulta.
Modelo de Decisão Eficiente: Utiliza uma arquitetura simplificada (TreeCNN) que, combinada com dados reais de cardinalidade, supera modelos mais complexos e otimizações baseadas apenas em estimativas.

4. Resultados Experimentais

Os autores avaliaram o LQRS em quatro benchmarks públicos (JOB, ExtJOB, STACK e TPC-H) no Spark SQL, comparando-o com o Spark SQL padrão (com AQE), Lero, AutoSteer e SSA (QuerySplit).

Desempenho Geral: O LQRS reduziu o tempo de execução de ponta a ponta em até 90% em comparação com outros otimizadores aprendidos e métodos de re-otimização. Em média, houve uma redução de 16,3% a 73,3% em relação ao Spark SQL padrão.
Comparação com Lero: O LQRS superou o Lero, especialmente em consultas complexas, evitando a sobrecarga de enumeração de planos e corrigindo planos subóptimos durante a execução.
Robustez: O sistema demonstrou robustez a mudanças na distribuição de dados e na carga de trabalho, adaptando-se melhor do que métodos puramente baseados em treinamento offline.
Custo de Otimização: O LQRS apresentou o menor custo de sobrecarga de otimização (overhead) entre os métodos aprendidos, pois toma decisões baseadas em dados reais e evita re-otimizações redundantes através da ação no-op.

5. Significado e Impacto

O trabalho do LQRS representa um avanço significativo na interseção entre aprendizado de máquina e processamento de consultas adaptativo.

Mudança de Paradigma: Demonstra que a otimização de consultas não deve ser um processo estático, mas sim um ciclo contínuo onde o aprendizado e a execução se alimentam mutuamente.
Viabilidade Prática: Prova que é possível integrar modelos de IA complexos em motores de dados de produção (como o Spark) de forma segura e eficiente, utilizando as interfaces de extensão existentes.
Potencial de Aplicação: A abordagem de usar observações de tempo de execução para refinar planos pode ser aplicada a outros sistemas de banco de dados que possuam mecanismos de materialização de resultados intermediários, indo além do ecossistema Spark.

Em resumo, o LQRS preenche a lacuna entre a otimização teórica baseada em aprendizado e a realidade dinâmica da execução de consultas, oferecendo ganhos substanciais de desempenho através da re-otimização inteligente e adaptativa.