Tamanho de fonte
Alto contraste
Altura de linha
Entrar Cadastrar
SQL JOIN

SQL Join: o que é, tipos, exemplos e como usar na prática

Avatar de Carolina Carvalho Carolina Carvalho
17 minutos de leitura 21/07/2025 • Atualizado 3 meses atrás 5xp

Em um banco de dados relacional, os dados geralmente estão distribuídos em várias tabelas, cada uma armazenando uma parte específica da informação. Para obter um conjunto completo e útil desses dados, você deve relacionar essas tabelas entre si. É aí que entra o SQL JOIN.

JOINs em SQL são operações que combinam linhas de duas ou mais tabelas com base em uma condição relacionada, geralmente envolvendo colunas com valores em comum. Essa funcionalidade permite integrar dados dispersos e realizar análises mais completas e inteligentes.

É como se cada tabela fosse uma peça de um quebra-cabeça e o JOIN, a chave que conecta essas peças, formando uma imagem clara e coerente dos dados.

Com essa conexão, você pode recuperar informações de forma eficiente, construir consultas complexas, gerar relatórios e análises que fazem sentido para o negócio, entre outras aplicações.

As possibilidades são infinitas! 

Principais tipos de JOINs SQL

Os JOINs são usados para recuperar dados relacionados de duas ou mais tabelas em um banco de dados relacional. Eles funcionam comparando valores comuns entre essas tabelas, geralmente chaves primárias e estrangeiras, para combinar as informações em uma única visualização.

Cada tipo de JOIN trata de maneira específica os dados que não possuem correspondência. Conheça os principais a seguir:

INNER JOIN

O INNER JOIN é o tipo de junção mais comum no SQL. Ele combina registros de duas tabelas, exibindo apenas aqueles que possuem valores correspondentes em ambas.

Ou seja, ele retorna somente os registros que têm correspondência nas tabelas envolvidas na consulta. Para isso, o banco de dados compara cada linha da primeira tabela com as da segunda, verificando se a condição de junção é satisfeita.

Quando há correspondência, ou seja, os valores das colunas relacionadas são iguais, o SQL cria uma nova linha no resultado, combinando colunas das duas tabelas.

Sintaxe de INNER JOIN

SELECT tabela1.coluna1, tabela2.coluna2
FROM tabela1
INNER JOIN tabela2
ON tabela1.coluna_em_comum = tabela2.coluna_em_comum;

Exemplo prático com INNER JOIN

Vamos supor que você tem duas tabelas: uma de pedidos e outra de clientes:

Tabela de clientes

id_cliente | nome
-----------|--------
1          | Ana
2          | João
3          | Carla

Tabela de pedidos

id_pedido | id_cliente | valor
----------|------------|-------
101       | 1          | 150.00
102       | 2          | 200.00

Ao aplicar um INNER JOIN entre essas tabelas, a consulta retornará apenas os pedidos com um cliente associado, excluindo automaticamente qualquer pedido sem cliente correspondente ou cliente que não tenha feito pedidos. 

SELECT clientes.nome, pedidos.valor
FROM clientes
INNER JOIN pedidos
ON clientes.id_cliente = pedidos.id_cliente;

E este é o resultado dessa operação:

nome  | valor
------|--------
Ana   | 150.00
João  | 200.00

Observe que Carla não aparece no resultado porque não tem nenhum pedido registrado. Afinal, conforme explicado, o INNER JOIN retorna apenas os registros que têm correspondência nas duas tabelas.

LEFT JOIN (ou LEFT OUTER JOIN)

Você deve usar a junção LEFT JOIN quando desejar retornar todos os registros da tabela da esquerda, mesmo que não existam correspondências na tabela da direita. 

Se houver correspondência, os dados da tabela à direita são adicionados ao resultado. Caso contrário, os campos correspondentes aparecem como NULL na saída da consulta.

Esse tipo de junção é muito útil para identificar lacunas ou dados ausentes em uma relação, como clientes que nunca fizeram pedidos ou produtos que ainda não foram vendidos.

Sintaxe de LEFT JOIN

SELECT tabela1.coluna1, tabela2.coluna2
FROM tabela1
LEFT JOIN tabela2
ON tabela1.coluna_em_comum = tabela2.coluna_em_comum;

Exemplo prático com LEFT JOIN

Vamos supor que você deseja listar todos os clientes mencionados no exemplo anterior, incluindo aqueles que não fizeram pedidos. Para isso, você precisa usar LEFT JOIN:

SELECT clientes.nome, pedidos.valor
FROM clientes
LEFT JOIN pedidos
ON clientes.id_cliente = pedidos.id_cliente;

E este é o resultado dessa operação:

nome  | valor
------|--------
Ana   | 150.00
João  | 200.00
Carla | NULL

Nesse caso, Carla aparece no resultado mesmo sem ter feito pedidos. Conforme explicado, como não há correspondência para ela na tabela pedidos, o SQL retorna NULL na coluna valor.

RIGHT JOIN (ou RIGHT OUTER JOIN)

O RIGHT JOIN é uma operação de junção que retorna todos os registros da tabela à direita da consulta, junto com os registros correspondentes da tabela à esquerda.

Quando não há correspondência entre as tabelas, as colunas da tabela da esquerda são preenchidas com NULL. Essa lógica é muito parecida com a do LEFT JOIN. A diferença é que, aqui, o foco está na preservação dos dados da tabela da direita.

Esse tipo de junção pode ser usada quando você quer garantir que todas as informações de uma tabela específica estejam no resultado, mesmo que não estejam relacionadas a registros da outra.

Sintaxe de RIGHT JOIN

SELECT tabela1.coluna1, tabela2.coluna2
FROM tabela1
RIGHT JOIN tabela2
ON tabela1.coluna_em_comum = tabela2.coluna_em_comum;

Exemplo prático com RIGHT JOIN

Vamos supor que você tem duas tabelas para analisar: uma de funcionários e outra de departamentos:

Tabela de funcionários

id_funcionario | nome
---------------|--------
1              | Lucas
2              | Marina

Tabela de departamentos

id_departamento | nome_departamento | id_funcionario
----------------|-------------------|----------------
10              | RH                | 1
20              | Financeiro        | NULL
30              | TI                | NULL

Para listar todos os departamentos, mesmo aqueles que ainda não têm funcionários atribuídos, você pode usar a junção RIGHT JOIN da seguinte forma:

SELECT funcionarios.nome, departamentos.nome_departamento
FROM funcionarios
RIGHT JOIN departamentos
ON funcionarios.id_funcionario = departamentos.id_funcionario;

E este é o resultado dessa operação:

nome   | nome_departamento
-------|-------------------
Lucas  | RH
NULL   | Financeiro
NULL   | TI

Observe que o SQL retornou todos os departamentos, mesmo os que não estão associados a nenhum funcionário. E como não há correspondência para os departamentos Financeiro e TI, a coluna nome (da tabela de funcionários) aparece como NULL.

FULL JOIN (ou FULL OUTER JOIN)

O FULL JOIN é um tipo de junção que retorna todas as linhas de ambas as tabelas envolvidas, independentemente de haver ou não correspondência entre elas. Ou seja, ele combina os comportamentos do LEFT JOIN e do RIGHT JOIN. 

Quando há correspondência entre os registros, os dados são combinados em uma única linha. Mas, quando não há, as colunas da tabela sem correspondência são preenchidas com NULL.

Esse tipo de JOIN é considerado uma junção externa completa porque retorna o conjunto total de dados. E essa facilidade é importante para detectar falhas, lacunas ou inconsistências no relacionamento entre as tabelas.

Sintaxe do FULL JOIN

SELECT tabela1.coluna1, tabela2.coluna2
FROM tabela1
FULL JOIN tabela2
ON tabela1.coluna_em_comum = tabela2.coluna_em_comum;

Exemplo prático com FULL JOIN

Vamos supor que você precisa analisar e correlacionar as tabelas de alunos e de notas de uma escola.

Tabela de alunos

id_aluno | nome
---------|--------
1        | Alice
2        | Bruno
3        | Carla

Tabela de notas

id_nota | id_aluno | nota
--------|----------|------
101     | 1        | 8.5
102     | 4        | 7.0

Além de cruzar os dados dos alunos com suas respectivas notas, o objetivo é identificar alunos que ainda não receberam nota e notas associadas a alunos não cadastrados. Para isso, você precisa usar a cláusula FULL JOIN:

SELECT alunos.nome, notas.nota
FROM alunos
FULL JOIN notas
ON alunos.id_aluno = notas.id_aluno;

E este é o resultado dessa operação:

nome  | nota
------|------
Alice | 8.5
Bruno | NULL
Carla | NULL
NULL  | 7.0

Nesse resultado, Alice é a única aluna com nota registrada, pois há correspondência nas duas tabelas. Já Bruno e Carla aparecem com NULL na coluna nota, indicando que ainda não receberam avaliação.

Além disso, a nota 7.0, associada ao id_aluno = 4, aparece com NULL na coluna nome, porque esse aluno não está cadastrado na tabela de alunos.

CROSS JOIN

O CROSS JOIN é um tipo especial de junção em SQL que produz o produto cartesiano entre duas ou mais tabelas. Isso significa que cada linha da primeira tabela é combinada com todas as linhas da segunda, mesmo sem nenhuma correspondência entre elas.

O número total de linhas no resultado será o número de linhas da tabela A multiplicado pelo número de linhas da tabela B.

Ele simplesmente gera todas as combinações possíveis entre os registros. Esse tipo de operação pode ser útil em cenários específicos, como simulações, testes, combinações de categorias ou geração de pares entre conjuntos de dados.

No entanto, é importante usar o CROSS JOIN com cautela, já que ele pode gerar uma explosão no volume de resultados, especialmente quando envolve tabelas grandes. 

Por exemplo, se cada tabela tiver 100 linhas, o resultado conterá 10.000 combinações, o que pode comprometer o desempenho do sistema e a eficiência da consulta.

Sintaxe do CROSS JOIN

SELECT tabela1.coluna1, tabela2.coluna2
FROM tabela1
CROSS JOIN tabela2;

Exemplo prático com CROSS JOIN

Vamos supor que você precisa gerar todas as combinações possíveis entre a tabela de funcionários e de cargos de uma empresa.

Tabela de funcionários

id_funcionario | nome
---------------|--------
1              | Aline
2              | Bruno

Tabela de cargos

id_cargo | nome_cargo
---------|-------------
1        | Analista
2        | Coordenador

Para fazer essas combinações, você precisa usar a cláusula CROSS JOIN:

SELECT funcionarios.nome, cargos.nome_cargo
FROM funcionarios
CROSS JOIN cargos;

E este é o resultado dessa operação:

nome   | nome_cargo
--------|-------------
Aline  | Analista
Aline  | Coordenador
Bruno  | Analista
Bruno  | Coordenador

Conforme explicado, o resultado apresenta todas as combinações possíveis entre os registros das duas tabelas, sem necessidade de uma condição de junção.

Comparando os tipos de JOINs SQL 

O conjunto de diagramas de Venn abaixo ajuda a visualizar como cada tipo de JOIN funciona:

Diagramas de Venn com comparação de diferentes tipos de JOINs SQL

Esses diagramas ilustram, de forma intuitiva, como os dados de duas ou mais tabelas se combinam em uma consulta.

Cada círculo representa uma tabela, e a área de interseção entre os círculos indica os registros que estão presentes em ambas as tabelas, ou seja, aqueles que satisfazem a condição de junção.

Essa representação visual facilita bastante o entendimento do comportamento de cada JOIN, principalmente para quem está começando a aprender SQL.

Ficou em dúvida sobre o que cada diagrama representa? Veja a explicação abaixo:

  • INNER JOIN: considera apenas a área de interseção, retornando apenas os registros que existem nas duas tabelas;
  • LEFT JOIN: inclui todos os registros da tabela da esquerda, com ou sem correspondência na da direita;
  • RIGHT JOIN: retorna todos os registros da tabela da direita, mesmo que não tenham correspondência na esquerda;
  • FULL JOIN: representa a união completa das duas tabelas, incluindo os dados que não possuem correspondência;
  • CROSS JOIN: exibe todas as combinações possíveis entre os registros das tabelas, sem considerar uma condição de junção.

Aplicações práticas dos SQL JOIN em análise de dados

Quando você aprende a usar os JOINs de forma correta, passa a integrar dados dispersos, conectar informações relevantes e montar análises mais avançadas. Isso permite aplicar essa técnica em diversos cenários, como projetos de análise, automação, visualização e ciência de dados. Confira abaixo alguns exemplos de aplicações práticas dos JOINs em diferentes contextos da análise de dados:

Aplicações de JOINs em SQL

Dashboards

Os JOINs são fundamentais na construção de dashboards, já que permitem combinar diferentes tabelas para apresentar uma visão completa dos dados. Você pode usar essa técnica no cruzamento de dados entre vendas realizadas e metas estabelecidas, por exemplo.

Vamos supor que você tenha uma tabela com os valores mensais de vendas e outra com metas definidas por equipe ou por período, por exemplo. Com um JOIN, você pode unir essas informações e calcular o percentual de alcance dessas metas, exibindo tudo em um painel interativo.

E se você estiver trabalhando com Python, pode fazer esse cruzamento diretamente no SQL (antes de carregar os dados) ou usando a biblioteca pandas, com o método merge(). 

Depois disso, você pode alimentar ferramentas como Streamlit ou Plotly para gerar gráficos dinâmicos com base nesses dados relacionados.

ETL

No processo de ETL, os JOINs são usados principalmente na etapa de transformação, quando os dados extraídos de diferentes fontes precisam ser limpos, organizados e combinados. 

Por exemplo, você pode extrair uma tabela de produtos de um ERP e outra de fornecedores de um sistema diferente. Com um JOIN, fica mais fácil relacionar os produtos aos seus respectivos fornecedores, gerando uma base consolidada e pronta para análise.

Esse tipo de operação é comum em pipelines de dados desenvolvidos com ferramentas como Airflow e scripts em Python, utilizando SQLAlchemy e pandas. Sem o uso de JOINs, reunir essas informações de forma estruturada e confiável seria muito mais difícil.

Python + SQL

JOINs também são utilizados em análises exploratórias e projetos de ciência de dados que combinam Python e SQL. Você pode executar os JOINs diretamente em SQL e importar os resultados com pandas.read_sql(), ou realizar a junção dentro do próprio pandas, usando o método merge().

Essa integração é ideal para quem trabalha com Jupyter Notebooks, análise exploratória de dados ou criação de modelos de machine learning baseados em dados combinados. 

BI e automações

Soluções de Business Intelligence (BI) e automações de marketing, vendas ou operações também podem usar JOINs para otimizar a integração de dados de diferentes tabelas. Sem os JOINs, essas ferramentas não conseguiriam relacionar eventos, ações e resultados de forma eficiente. 

Por exemplo, vamos supor que você usa uma automação que envia alertas sempre que uma filial não atinge a meta de vendas. Para isso, o sistema utiliza um JOIN entre as tabelas de vendas, metas e filiais. 

Quando identifica um desempenho abaixo do esperado, ele aciona automaticamente o alerta. Tudo isso com base em dados integrados por meio de JOINs. 

Quais são os cuidados ao usar JOIN no SQL?

Pequenos descuidos durante o uso de JOINS podem gerar resultados incorretos, lentidão nas consultas ou até comprometer a análise dos dados. Veja abaixo alguns cuidados essenciais para evitar erros:

Defina sempre a condição de junção

Um erro clássico é esquecer de definir a condição do JOIN com a cláusula ON. Quando isso acontece, o SQL executa um CROSS JOIN implícito, retornando o produto cartesiano entre as tabelas.

Isso significa que o sistema cria todas as combinações possíveis de linhas, o que pode gerar milhares (ou até milhões) de resultados desnecessários e travar o banco de dados.

-- ERRO! Produto cartesiano indesejado
SELECT * FROM clientes JOIN vendas;

Por isso, sempre defina a condição de junção de forma clara:

-- CORRETO
SELECT * FROM clientes
JOIN vendas ON clientes.id_cliente = vendas.id_cliente;

Use aliases para melhorar a legibilidade

Em JOINs que envolvem várias tabelas ou nomes longos, utilizar apelidos temporários (aliases) torna o código mais limpo e fácil de entender:

SELECT c.nome, v.valor
FROM clientes c
JOIN vendas v ON c.id_cliente = v.id_cliente;

Além de facilitar a leitura, isso reduz o risco de erros ao lidar com nomes de colunas repetidas ou semelhantes.

Verifique se a chave de junção está indexada

Em grandes bases de dados, JOINs entre colunas não indexadas podem gerar consultas lentas e ineficientes. Portanto, certifique-se de que a coluna usada na cláusula ON (como id_cliente, id_produto etc.) tenha um índice criado, especialmente em relacionamentos 1:N e em tabelas com muitos registros.

Cuidado com duplicidade de linhas

Quando você usa o JOIN entre tabelas que têm relacionamentos 1:N ou N:N, pode gerar linhas duplicadas no resultado, o que pode distorcer totais e análises.

Por isso, avalie se você precisa:

  • GROUP BY para agrupar os resultados;
  • DISTINCT para eliminar repetições;
  • Funções como SUM e COUNT para agregar valores corretamente.

Teste suas consultas com subsets

Antes de rodar JOINs pesados em produção, teste a consulta com subconjuntos de dados. Isso ajuda a identificar erros lógicos, problemas de performance ou resultados inesperados, sem impactar o ambiente real.

Qual a melhor forma de aprender SQL?

A melhor forma de aprender SQL é colocando a mão na massa: praticando com projetos reais, criando consultas e enfrentando desafios que simulam o dia a dia de quem trabalha com dados. Ler a teoria é importante, mas é na prática que o conhecimento se consolida de verdade.

E o melhor caminho para isso é fazer a Trilha de Análise e Visualização de Dados da Asimov Academy!

Pensada especialmente para iniciantes, essa trilha vai te ajudar a dominar SQL passo a passo, aplicando o que aprende em projetos reais, automações e dashboards interativos.

Tudo isso com aulas dinâmicas, exercícios práticos e suporte para tirar dúvidas, acelerando sua jornada no universo dos dados.

Comece agora e transforme o seu futuro!

Trilha Análise e Visualização de Dados

Manipule dados e construa visualizações interativas com as ferramentas mais utilizadas por analistas de dados do mundo.

Comece agora

​

Você também pode gostar:

Imagem de um notebook

Cursos de programação gratuitos com certificado

Aprenda a programar e desenvolva soluções para o seu trabalho com Python para alcançar novas oportunidades profissionais. Aqui na Asimov você encontra:

  • Conteúdos gratuitos
  • Projetos práticos
  • Certificados
  • +20 mil alunos e comunidade exclusiva
  • Materiais didáticos e download de código
Inicie agora

Comentários

30xp
Comentar
Faça parte da discussão Crie sua conta gratuita e compartilhe
sua opinião nos comentários Entre para a Asimov
Edite seu comentário: