INNER, CROSS, LEFT, RIGTH E FULL JOINS
Veja como juntar tabelas em SQL. O artigo mostra os diversos tipos de junção com exemplos simples e de fácil absorção.
As junções entre duas ou mais tabelas podem ser realizadas através de:
As questões são duas:
- O que são cada uma dessas junções (joins)?
- Como usar?
Para definir e exemplificar as junções acima citadas considere o modelo da figura 1 abaixo:
Podemos notar pelo modelo que pode existir no banco de dados funcionários sem cargos e cargos sem funcionários. Para exemplificar melhor, observe o conteúdo das tabelas na figura 2 abaixo:
Assim, fazemos:
CROSS JOIN
Quando queremos juntar duas ou mais tabelas por cruzamento. Ou seja, para cada linha da tabela FUNCIONARIO queremos todos os CARGOS ou vice-versa.
INNER JOIN
Quando queremos juntar duas ou mais tabelas por coincidência. Para cada linha da tabela FUNCINARIO queremos o CARGO correspondente que internamente (INNER), em seus valores de atributos, coincidam. No caso de FUNIONÁRIO e CARGO os atributos internos coincidentes são codigoCargo na tabela CARGO e codigoCargo na tabela FUNCIONARIO.
Veja também a Figura 1 e a Figura 2, lá você notará que codigoCargo é chave primária da tabela CARGO e chave estrangeira na tabela FUNCIONARIO. Para efetivarmos a junção das duas tabelas se fará necessário ligar (ON) as duas tabelas por seus atributos internos (INNER) coincidentes.
LEFT OUTER JOIN
Observando a tabela FUNCIONARIO notamos que o funcionário Tadeu não possui cargo associado a ele. Se desejarmos listar todos os funcionários com seus respectivos cargos, incluindo os funcionários sem cargos, a exemplo de Tadeu, poderíamos usar todo o poder da junção INNER JOIN adicionando ainda OUTER (EXTERNOS/OUTROS) Funcionários que não fazem parte do INNER JOIN, justamente àqueles sem cargos, como Tadeu.
Podemos conseguir esse feito com a junção FUNCIONARIO / CARGO através da declaração FUNCIONARIO OUTER LEFT JOIN CARGO, que promove a junção interna (INNER) de todos os funcionários a cargos e lista ainda outros (EXTERNOS/OUTER) não associados.
Uma observação importante é que a ordem da ligação (ON) não faz diferença, ou seja: “ON (F.codCargo = C.codCargo)” é exatamente igual a “ON (C.codCargo = F.codCargo)”
RIGHT OUTER JOIN
Observando a tabela CARGO notamos que o cargo GERENTE, com código C3, não é referenciado/associado por/a nenhum funcionário na tabela FUNCIONARIO.
Se desejarmos listar todos os CARGOS e seus respectivos FUNCIONARIOS, incluindo os CARGOS sem FUNCIONÁRIOS, poderíamos usar a junção RIGTH OUTER JOIN. Veja o exemplo da figura 6.
Uma observação importante é que a ordem da ligação (ON) não faz diferença, ou seja: “ON (F.codCargo = C.codCargo)” é exatamente igual a “ON (C.codCargo = F.codCargo)”.
OUTER FULL JOIN
Aqui juntamos o poder das junções (JOIN) internas(INNER), a listagem de todas as outras linhas não associadas, tanto do lado direito (RIGHT) da junção como do lado esquerdo (LEFT). Veja o exemplo abaixo:
Uma observação importante é que a ordem da ligação (ON) não faz diferença, ou seja: “ON (F.codCargo = C.codCargo)” é exatamente igual a “ON (C.codCargo = F.codCargo)”.
Abaixo segue o SCRIPT SQL de criação das tabelas, seus relacionamentos, seu povoamento e dos exemplos utilizados. Todos os exemplos deste artigo foram testados no SGBDR MS-SQL Server 2008 Express.
SCRIPT DE TESTES EM TRANSACT-SQL ( SQL SERVER )
-- Criando um dataBase para testes
CREATE DATABASE dbTESTE_JOINS
GO
-- Usando o DataBase para criar as tabelas e povoá-las
USE dbTESTE_JOINS
GO
-- Criando a tabela Cago
CREATE TABLE CARGO
(
CodCargo char(2) NOT NULL,
NomeCargo varchar(50) NULL,
ValorCargo money NULL,
PRIMARY KEY(CodCargo)
)
GO
-- Criando a tabela Funcionario
CREATE TABLE FUNCIONARIO
(
Matricula int,
NomeFuncionario varchar(50) NOT NULL,
CodCargo char(2) NULL,
PRIMARY KEY(Matricula),
FOREIGN KEY (CodCargo) REFERENCES CARGO (CodCargo)
)
GO
-- Povoando a tabela CARGO
INSERT CARGO (CodCargo, NomeCargo, ValorCargo) VALUES (''''''''C1'''''''',
''''''''CAIXA'''''''' , 800.00)
INSERT CARGO (CodCargo, NomeCargo, ValorCargo) VALUES (''''''''C2'''''''',
''''''''VENDEDOR'''''''', 1200.00)
INSERT CARGO (CodCargo, NomeCargo, ValorCargo) VALUES (''''''''C3'''''''',
''''''''GERENTE'''''''' , 2400.00)
GO
-- Povoando a tabela FUNCIONARIO
INSERT FUNCIONARIO (Matricula, NomeFuncionario, CodCargo) VALUES (100,
''''''''JOÃO'''''''' , ''''''''C1'''''''')
INSERT FUNCIONARIO (Matricula, NomeFuncionario, CodCargo) VALUES (110,
''''''''MARIA'''''''' , ''''''''C2'''''''')
INSERT FUNCIONARIO (Matricula, NomeFuncionario, CodCargo) VALUES (120,
''''''''CARLOS'''''''' , ''''''''C1'''''''')
INSERT FUNCIONARIO (Matricula, NomeFuncionario, CodCargo) VALUES (130,
''''''''TADEU'''''''' , NULL)
GO
-----------------------------------------
-- EXEMPLOS DE JOIN ABORDADOS NO ARTIGO
-----------------------------------------
-- Seleção Simples ( Todos os Cargos e Todos os Funcionario ) -
Veja Figura 2
SELECT * FROM CARGO AS C --> Apelidamos a tabelas
Cargo de C neste artigo
SELECT * FROM FUNCIONARIO AS F --> Apelidamos
funcionário de F neste artigo
GO
-- CROSS JOIN ( Junção Cruzada ) - Veja Figura 3
SELECT F.NomeFuncionario
,C.NomeCargo
FROM CARGO AS C
CROSS JOIN FUNCIONARIO AS F
-- INNER JOIN ( Junção Interna ) - Veja Figura 4
SELECT F.NomeFuncionario
,C.NomeCargo
FROM CARGO AS C
INNER JOIN FUNCIONARIO AS F ON (F.CodCargo = C.CodCargo)
-- LEFT OUTER JOIN ou simplesmente LEFT JOIN ( Junção Externa
Esquerda ) - Veja Figura 5
SELECT F.nomeFuncionario
,C.nomeCargo
FROM FUNCIONARIO AS F
LEFT OUTER JOIN CARGO AS C ON ( C.codCargo =
F.codCargo )
-- RIGHT OUTER JOIN ou simplesmente RIGHT JOIN ( Junção
Externa Direita) - Veja Figura 6
SELECT F.nomeFuncionario
,C.nomeCargo
FROM FUNCIONARIO AS F
RIGHT OUTER JOIN CARGO AS C ON ( F.codCargo
= C.codCargo )
-- FULL OUTHER JOIN ou simplesmente FULL JOIN (Junção
Externa Completa)
SELECT F.nomeFuncionario
,C.nomeCargo
FROM FUNCIONARIO AS F
FULL OUTER JOIN CARGO AS C ON ( C.codCargo
= F.codCargo )
Boas práticas
1. INNER JOIN
- Use condições de junção claras (ON) para evitar resultados incorretos.
- Evite SELECT * - prefira colunas específicas para melhorar performance e legibilidade.
- Garanta que haja índices nas colunas usadas para junção.
- Utilize aliases para facilitar a leitura.
2. LEFT OUTER JOIN
- Ideal para relatórios com dados opcionais.
- Use cláusulas como IS NULL após o JOIN para identificar dados faltantes.
- Evite LEFT JOINs desnecessários para não comprometer a performance.
3. RIGHT OUTER JOIN
- Menos comum, muitas vezes pode ser reescrito como LEFT JOIN invertendo as tabelas.
- Evite quando possível para manter a leitura clara.
4. FULL OUTER JOIN
- Útil para encontrar discrepâncias entre tabelas.
- Use COALESCE() para exibir dados consolidados.
- Evite em grandes volumes de dados sem índices apropriados.
5. CROSS JOIN
- Use com cautela e apenas quando o produto cartesiano for necessário.
- Nunca use sem WHERE se não tiver certeza da intenção.
- Comum em análises estatísticas ou testes de combinações.
A para aprendizado e aprimoramento
p> A utilização de JOINs é fundamental para combinar e cruzar dados em bancos relacionais, nesse contexto, a Inteligência Artificial surge como uma aliada poderosa para facilitar o aprendizado e aprimorar o uso desses operadores.Com o apoio de ferramentas baseadas em IA, é possível descrever consultas em linguagem natural e obter a versão equivalente em SQL, receber explicações detalhadas de trechos de código, analisar automaticamente a lógica de JOINs aplicados, e até gerar visualizações que ilustram o relacionamento entre tabelas.
- Explicação de consultas complexas.
- Correção e refatoração de SQL.
- Geração automática de consultas a partir de linguagem natural.
- Exercícios personalizados com feedback.
- Visualização gráfica de JOINs.
- Chatbots treinados para bancos de dados específicos.
Ao incorporar ferramentas baseadas em IA no processo de aprendizado, os usuários não apenas aceleram seu entendimento sobre INNER JOIN, LEFT JOIN, RIGHT JOIN, FULL OUTER JOIN e CROSS JOIN, mas também desenvolvem uma abordagem mais analítica, segura e eficiente para lidar com dados. Com isso, a IA se consolida como uma grande aliada na formação e evolução de profissionais em ciência de dados, análise de sistemas e desenvolvimento de software.
Saiu na DevMedia!
- Programe com o Node.js: Nessa série procuramos entender essa afirmação, conversando sobre o propósito do Node.js, qual é o seu modelo de programação e o que muda quando desejamos aprender essa tecnologia vindo de alguma linguagem orientada a objetos ou multiparadigma, como é o caso do PHP, C#, Python, entre outras.
Saiba mais sobre PHP ;)
- Guia Completo de SQL: Neste Guia Completo de SQL você encontrará todo o conteúdo que precisa para aprender sobre a SQL, linguagem de consulta estruturada utilizada por programadores e DBAs para a execução de consultas e comandos nos principais SGBDs do mercado.
Artigos relacionados
-
Artigo
-
Artigo
-
Artigo
-
Artigo
-
Artigo