Associação completa SQL

Este artigo fornece uma visão geral do FULL JOIN em SQL, bem como alguns exemplos básicos.

O SQL FULL JOIN (ou FULL OUTER JOIN ) retorna todas as linhas, desde que haja dados correspondentes em uma das tabelas.

É como ter uma junção esquerda direita em uma junção.

Sintaxe

Você especifica uma junção completa no FROM cláusula. Você pode usar o FULL JOIN ou FULL OUTER JOIN sintaxe.

Usando o FULL JOIN sintaxe:

SELECT *
FROM Table1 FULL JOIN Table2 
ON Table1.Column = Table2.Column;

Usando o FULL OUTER JOIN sintaxe:

SELECT *
FROM Table1 FULL OUTER JOIN Table2 
ON Table1.Column = Table2.Column;

Ambos fazem exatamente a mesma coisa. É só que o OUTER palavra-chave é opcional.

Exemplos

Aqui estão alguns exemplos para demonstrar.

Dados de amostra

Primeiro, aqui estão as tabelas que usaremos para os exemplos.

Os PetTypes tabela:

+-------------+-----------+| PetTypeId | PetType ||-------------+-----------|| 1 | Pássaro || 2 | Gato || 3 | Cão || 4 | Coelho |+-------------+-----------+(4 linhas afetadas)

Os Pets tabela:

+---------+-------------+-----------+---------- -+------------+| PetId | PetTypeId | Proprietário | PetName | DOB ||---------+-------------+-----------+----------- +------------|| 1 | 2 | 3 | Fofo | 20-11-2020 || 2 | 3 | 3 | Buscar | 16-08-2019 || 3 | 2 | 2 | Raspe | 01-10-2018 || 4 | 3 | 3 | Wag | 15-03-2020 || 5 | 1 | 1 | Tweet | 28-11-2020 || 6 | 3 | 4 | Fofo | 17-09-2020 || 7 | 3 | 2 | Casca | NULO || 8 | 2 | 4 | Miau | NULL |+---------+-------------+-----------+----------- +------------+(8 linhas afetadas)

Os Owners tabela:

+-----------+-------------+------------+------- ---------+-------------------+| Proprietário | Nome | Sobrenome | Telefone | E-mail ||-----------+-------------+------------+-------- --------+-------------------|| 1 | Homero | Connery | (308) 555-0100 | exemplo@sqldat.com || 2 | Bart | Pitt | (231) 465-3497 | exemplo@sqldat.com || 3 | Nancy | Simpson | (489) 591-0408 | NULO || 4 | Bóris | Trump | (349) 611-8908 | NULO || 5 | Amadeirado | Eastwood | (308) 555-0112 | example@sqldat.com |+-----------+-------------+------------+---- ------------+-------------------+

Observe que:

O PetTypeId coluna dos Pets table é uma chave estrangeira do PetTypeId dos PetTypes table (que é a chave primária dessa tabela).
O OwnerId coluna dos Pets table é uma chave estrangeira do OwnerId coluna dos Owners tabela.

A consulta de associação completa

Aqui está um exemplo de como realizar uma junção completa em duas dessas tabelas.

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
FULL JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;

Resultado:

+-----------+-----------+| PetName | PetType ||-----------+-----------|| Tweet | Pássaro || Fofo | Gato || Raspe | Gato || Miau | Gato || Buscar | Cão || Wag | Cão || Fofo | Cão || Casca | Cão || NULO | Coelho |+-----------+-----------+(9 linhas afetadas)

Neste exemplo, obtemos um PetType valor que não corresponde a um PetName . Isso ocorre porque não há coelhos como animais de estimação. Mas a junção completa faz com que Rabbit a ser devolvido, mesmo que não haja nenhum animal de estimação no Pets mesa desse tipo. Isso resulta em um NULL valor no PetName coluna contra Rabbit .

Este é o mesmo resultado que teríamos se tivéssemos usado uma junção correta, porque os PetTypes A tabela está à direita do JOIN palavra-chave. Isso não teria acontecido com uma junção à esquerda, porque PetTypes a tabela não está à esquerda do JOIN palavra-chave. Se quiséssemos recriá-lo com uma junção à esquerda, teríamos que mudar a ordem das tabelas, para que os PetTypes a tabela estava à esquerda do JOIN palavra-chave.

Aqui está o que acontece se mudarmos a ordem da tabela em nossa consulta ao usar uma junção completa.

SELECT 
    p.PetName,
    pt.PetType
FROM PetTypes pt
FULL JOIN Pets p
ON p.PetTypeId = pt.PetTypeId;

Resultado:

+-----------+-----------+| PetName | PetType ||-----------+-----------|| Tweet | Pássaro || Fofo | Gato || Raspe | Gato || Miau | Gato || Buscar | Cão || Wag | Cão || Fofo | Cão || Casca | Cão || NULO | Coelho |+-----------+-----------+(9 linhas afetadas)

Obtemos exatamente o mesmo resultado. Isso ocorre porque a junção completa retorna todas as linhas, desde que haja dados correspondentes em uma das tabelas. Como mencionado, é como ter uma junção esquerda e direita em uma junção.

Full Join em 3 Mesas

Aqui está um exemplo de como realizar uma junção completa em todas as três tabelas.

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Owners o FULL JOIN Pets p
    ON p.OwnerId = o.OwnerId
FULL JOIN PetTypes pt
    ON p.PetTypeId = pt.PetTypeId;

Resultado:

+-----------+-----------+----------------+| PetName | PetType | PetOwner ||-----------+-----------+----------------|| Tweet | Pássaro | Homer Connery || Raspe | Gato | Bart Pitt || Casca | Cão | Bart Pitt || Fofo | Gato | Nancy Simpson || Buscar | Cão | Nancy Simpson || Wag | Cão | Nancy Simpson || Fofo | Cão | Boris Trump || Miau | Gato | Boris Trump || NULO | NULO | Woody Eastwood || NULO | Coelho | |+-----------+-----------+----------------+(10 linhas afetadas) 
 Desta vez, temos um dono de animal de estimação que não possui um animal de estimação, bem como um tipo de animal de estimação que não é atribuído a um animal de estimação. 
 
 Se embaralharmos a ordem das tabelas, obteremos o mesmo resultado, embora as linhas sejam listadas em uma ordem diferente. 
 SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM PetTypes pt FULL JOIN Pets p
    ON p.PetTypeId = pt.PetTypeId
FULL JOIN Owners o 
    ON p.OwnerId = o.OwnerId; 
 
 Resultado:
 -----------+-----------+----------------+| PetName | PetType | PetOwner ||-----------+-----------+----------------|| Tweet | Pássaro | Homer Connery || Fofo | Gato | Nancy Simpson || Raspe | Gato | Bart Pitt || Miau | Gato | Boris Trump || Buscar | Cão | Nancy Simpson || Wag | Cão | Nancy Simpson || Fofo | Cão | Boris Trump || Casca | Cão | Bart Pitt || NULO | Coelho | || NULO | NULO | Woody Eastwood |+-----------+-----------+----------------+(10 linhas afetadas) 
 
 E se os embaralharmos mais uma vez, ainda obteremos o mesmo resultado. 
 SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Pets p FULL JOIN Owners o
    ON p.OwnerId = o.OwnerId
FULL JOIN PetTypes pt
    ON p.PetTypeId = pt.PetTypeId; 
 
 Resultado:
 +-----------+-----------+----------------+| PetName | PetType | PetOwner ||-----------+-----------+----------------|| Fofo | Gato | Nancy Simpson || Buscar | Cão | Nancy Simpson || Raspe | Gato | Bart Pitt || Wag | Cão | Nancy Simpson || Tweet | Pássaro | Homer Connery || Fofo | Cão | Boris Trump || Casca | Cão | Bart Pitt || Miau | Gato | Boris Trump || NULO | NULO | Woody Eastwood || NULO | Coelho | |+-----------+-----------+----------------+(10 linhas afetadas) 
 Se você está se perguntando por que o último PetOwner não é NULL (como por último o PetName is), é porque é resultado de uma concatenação de strings. Eu usei o T-SQL CONCAT() função para concatenar o nome e sobrenome do proprietário.