Aula 12: Subqueries — consultas aninhadas e correlacionadas

Nesta Aula 12 do curso “MySQL — Do Zero ao Avançado”, vamos nos aprofundar no tema das Subqueries, também conhecidas como consultas aninhadas. Este é um tópico valioso para quem deseja realizar consultas complexas no MySQL, aproveitando o poder dos dados relacionais ao máximo. As subqueries permitem extrair dados de maneiras que apenas operações mais básicas não permitiriam, tornando-se uma ferramenta indispensável para analistas e desenvolvedores.

Você aprenderá a diferenciar entre subqueries simples e correlacionadas, entenderá quando e como utilizá-las, e verá exemplos práticos de implementação. Ao final desta aula, você estará habilitado a criar consultas avançadas, capaz de analisar dados de forma otimizada e eficiente. A importância disso reside na capacidade de responder a questões complexas de negócios e tecnologia, diretamente do banco de dados.

Antes de começarmos, é importante ter em mente os pré-requisitos. As aulas anteriores forneceram uma base sólida em consultas básicas e intermediárias no MySQL, que serão fundamentais para o entendimento pleno desta aula. Garanta que seu ambiente MySQL esteja configurado corretamente, pois executaremos exemplos que exigem funcionalidade total do banco de dados.

O que você vai aprender nesta aula

• O que são subqueries e como funcionam no MySQL
• Diferenciar subqueries simples de subqueries correlacionadas
• Implementar subqueries em consultas complexas
• Testar e verificar o comportamento das subqueries
• Solucionar erros comuns ao trabalhar com subqueries

Pré-requisitos e Ambiente

Para seguir esta aula, você deve ter o MySQL instalado e configurado em seu sistema. Certifique-se de estar usando uma versão compatível com os exemplos fornecidos (pelo menos MySQL 5.7). Você também deve ter acesso de administrador ao banco de dados para criar e manipular tabelas. Se você estiver em um ambiente corporativo, verifique se tem as permissões necessárias.

O que são Subqueries?

Subqueries, ou consultas aninhadas, são consultas SQL inseridas dentro de outra consulta SQL. Elas são usadas para retornar dados que serão utilizados pela consulta principal como uma condição para filtrar, combinar ou agregar dados de tabelas. Essa funcionalidade é extremamente poderosa, pois permite um nível avançado de customização e análise dos dados.

Em nossos projetos na JRT Technology Solutions, subqueries são frequentemente utilizadas para atender demandas complexas de extração de dados sem a necessidade de processamento adicional em outras camadas da aplicação.

Tipos de Subqueries

Subqueries podem ser divididas em dois tipos principais: subqueries simples e subqueries correlacionadas.

• Subqueries Simples: Executadas de maneira independente. Após executadas, seus resultados são passados para a consulta externa. Por exemplo, podemos buscar um conjunto de IDs em uma tabela e usá-los para filtrar outra tabela.
• Subqueries Correlacionadas: Dependem de dados de uma ou mais tabelas da consulta externa. Elas são executadas repetidamente, uma vez para cada linha da tabela pai. Essa técnica é poderosa, mas pode ser menos eficiente em termos de desempenho.

Passo a Passo — Criando e Usando Subqueries

Vamos agora criar uma série de subqueries para entender seu comportamento e aplicação prática. Este exemplo usará duas tabelas simples, employees e departments, que você deve ter acesso no seu ambiente MySQL.

1. Primeiro, vamos criar uma base simples de dados para os exemplos.

  CREATE TABLE departments (
      department_id INT PRIMARY KEY,
      name VARCHAR(50)
  );

  CREATE TABLE employees (
      employee_id INT PRIMARY KEY,
      name VARCHAR(50),
      department_id INT,
      salary DECIMAL(10, 2),
      FOREIGN KEY (department_id) REFERENCES departments(department_id)
  );
  

2. Insira alguns registros em ambas as tabelas.

  INSERT INTO departments VALUES (1, 'Engineering'), (2, 'HR'), (3, 'Marketing');
  INSERT INTO employees VALUES (1, 'Alice', 1, 70000), (2, 'Bob', 1, 80000), (3, 'Charlie', 2, 40000), (4, 'Diana', 3, 45000);
  

3. Agora, execute uma subquery simples. Queremos encontrar o nome de todos os departamentos que têm pelo menos um funcionário com salário acima de 75000.

  SELECT name FROM departments WHERE department_id IN (
      SELECT department_id FROM employees WHERE salary > 75000
  );
  

+-------------+
| name        |
+-------------+
| Engineering |
+-------------+

Configuração Detalhada — Parametrizando Consultas

Ao trabalhar com subqueries, é comum ajustá-las para que aceitem parâmetros dinâmicos, tornando suas consultas mais eficientes e personalizáveis. Abaixo, oferece-se um exemplo de como isso pode ser realizado adicionando uma cláusula de parâmetro ao exemplo anterior.

SELECT name FROM departments WHERE department_id IN (
    SELECT department_id FROM employees WHERE salary > ?
);

Neste caso, o ponto de interrogação (?) representa um parâmetro que pode ser substituído por um valor específico durante a execução da consulta. Isso é amplamente utilizado em aplicações que executam SQL dinâmico via linguagens de programação.

Verificando a Instalação / Testando a Configuração

Após implementar suas consultas com subqueries, é essencial verificar que as mesmas foram configuradas e estão funcionando corretamente.

EXPLAIN SELECT name FROM departments WHERE department_id IN (
    SELECT department_id FROM employees WHERE salary > 75000
);

+----+--------------------+------------+-------+---------------+---------+---------+-------+------+-------------+
| id | select_type        | table      | type  | possible_keys | key     | key_len | ref   | rows | Extra       |
+----+--------------------+------------+-------+---------------+---------+---------+-------+------+-------------+
|  1 | PRIMARY            | departments| ALL   | NULL          | NULL    | NULL    | NULL  |    3 | Using where |
|  2 | DEPENDENT SUBQUERY | employees  | index | NULL          | dept_id | 4       | NULL  |    4 | Using where |
+----+--------------------+------------+-------+---------------+---------+---------+-------+------+-------------+

Erros Comuns e Como Resolver

• Erro: Subquery returns more than 1 row: Isso acontece quando a subquery está fornecendo mais de um resultado para um contexto que só aceita um. Usar “IN” ao invés de “=” é uma solução comum.
• Erro: Unknown column in ‘where clause’: Normalmente indicado por uma column_name na subquery que não é visível no contexto pretendido. Certifique-se de que todas as colunas referenciadas existam e sejam alcançáveis pelas subqueries.
• Erro de desempenho: Subqueries correlacionadas podem ser lentas em conjunto com grandes volumes de dados. Preste atenção à otimização do índice e considere reescrever a consulta para modos mais eficientes.
• Erro de sintaxe: Muito comum com parênteses e clausulas de subqueries. Verifique o SQL para garantir que cada abertura de parênteses tenha um fechamento correspondente.

Boas Práticas e Dicas Avançadas

Subqueries podem ser ferramentas poderosas, mas é crucial usá-las de maneira otimizada. Algumas dicas incluem o uso de índices apropriados para acelerar subqueries correlacionadas, evitar subqueries aninhadas excessivamente profundas que podem impactar o desempenho, e utilizar JOINs quando a situação permitir, pois eles podem às vezes substituir subqueries de forma mais eficiente.

Em nossos projetos na JRT Technology Solutions, asseguramos que consultas com subqueries sejam revisadas para eficiência, garantindo que estamos obtendo dados de forma rápida e eficaz sem sobrecarregar o servidor de banco de dados.

Resumo da Aula 12

Nesta aula, aprendemos sobre a aplicação de Subqueries no MySQL, explorando desde conceitos básicos até consultas mais avançadas. Compreendemos quando utilizar subqueries simples e correlacionadas, como parametrizar consultas para maior flexibilidade e resolvemos erros comuns que surgem neste contexto. Aumentamos significativamente nossa capacidade de executar consultas complexas e realizar análises de dados precisas e otimizadas. Na próxima aula, continuaremos a avançar em operações SQL, explorando tópicos de otimização de consulta e uso de índices.

Junte-se a nós na próxima aula e continue se desenvolvendo e se aperfeiçoando em MySQL, sempre com o suporte e expertise da JRT Technology Solutions.