Junte 3 tabelas em SQL

No SQL, você pode unir três tabelas ou mais adicionando outra junção após a primeira.

Você também pode executar junções aninhadas especificando uma junção como condição de junção para outra.

Sintaxe

A maneira mais comum de juntar três tabelas é mais ou menos assim:

SELECT *
FROM Table1 
INNER JOIN Table2
    ON Condition
INNER JOIN Table3
    ON Condition;

Isso usa uma junção interna, mas você pode especificar o tipo de junção desejado como em qualquer outra junção. Você também pode combinar tipos de junção, se necessário (exemplo abaixo).

Você também pode usar junções aninhadas especificando uma junção como a condição de junção para outra junção. Assim:

SELECT *
FROM Table1 
JOIN (Table2
            JOIN Table3
            ON Condition)
ON Condition;

Dados de Amostra – As 3 Tabelas

Suponha que temos as três tabelas a seguir.

Os Customers tabela:

+--------------+----------------+-------------- --+----------------+| ID do cliente | NomeDoCliente | PostalCityId | TelefoneNúmero ||--------------+----------------+--------------- -+----------------|| 1 | Homer McKenzie | 19586 | (308) 555-0100 || 2 | Marge Pratt | 33475 | (406) 555-0100 || 3 | Vlad Bernanke | NULO | (480) 555-0100 || 4 | Bart Pitt | 21692 | (316) 555-0100 || 5 | Lisa McQueen | 12748 | (212) 555-0100 || 6 | Steve Simpson | 17054 | (701) 555-0100 || 7 | Vin Allen | 12152 | (423) 555-0100 || 8 | Veejay Smith | 3673 | (303) 555-0100 || 9 | Kasey queixo | 23805 | (201) 555-0100 || 10 | Borat Lee | 37403 | (701) 555-0100 |+-----------------+----------------+---------- ------+----------------+(10 linhas afetadas)

As Cities tabela:

+----------+----------------+------------------ ---------------+| CityId | NomeCidade | StateProvinceId | População ||----------+----------------+------------------- +--------------|| 3673 | Arco Mar | 6 | 866 || 12152 | Frankewing | 44 | NULO || 12748 | Gasport | 33 | 1248 || 21692 | Loja de Medicina | 17 | 2009 || 26483 | Vale dos Peeples | 3 | 428 || 33475 | Sylvanita | 27 | 103 || 17054 | Jessie | 35 | 25 || 19586 | Lisco | 28 | NULO || 37403 | Wimbledon | 35 | 216 |+----------+----------------+---------------------- +--------------+(9 linhas afetadas)

As StateProvinces tabela:

+-------------------+---------------------+---- ---+-------------+--------------+| StateProvinceId | EstadoProvínciaCódigo | EstadoProvínciaNome | PaísId | População ||-------------------+---------------------+----- -----+-------------+--------------|| 3 | AZ | Arizona | 230 | 6891688 || 6 | CO | Colorado | 230 | 5698265 || 17 | KS | Kansas | 230 | 2893957 || 28 | NE | Nebrasca | 230 | 1943256 || 31 | NJ | Nova Jersey | 230 | 8899339 || 33 | NY | Nova York | 230 | 20437172 || 35 | ND | Dakota do Norte | 230 | 723393 || 44 | TN | Tennessee | 230 | 6495978 |+-------------------+---------------------+----- -----+-------------+--------------+(8 linhas afetadas )

Exemplo 1 – Inner Join 3 Tables

O tipo de junção mais popular é a junção interna, então vamos começar com isso.

Aqui está um exemplo de junção das três tabelas acima com duas junções internas.

SELECT
    s.StateProvinceName,
    ci.CityName,
    cu.CustomerName
FROM StateProvinces s
INNER JOIN Cities AS ci
ON ci.StateProvinceID = s.StateProvinceID
INNER JOIN Customers cu  
ON cu.PostalCityId = ci.CityId;

Resultado:

+---------------------+----------------+----------- ---------+| EstadoProvínciaNome | NomeCidade | NomeDoCliente ||----------+----------------+-------- --------|| Nebrasca | Lisco | Homer McKenzie || Kansas | Loja de Medicina | Bart Pitt || Nova York | Gasport | Lisa McQueen || Dakota do Norte | Jessie | Steve Simpson || Tennessee | Frankewing | Vinn Allen || Colorado | Arco Mar | Veejay Smith || Dakota do Norte | Wimbledon | Borat Lee |+---------------------+----------------+------- ---------+(7 linhas afetadas)

Exemplo 2 – Combinando tipos de junção

Você pode combinar tipos de junção ao unir três ou mais tabelas.

Aqui está um exemplo de combinação de uma junção interna com uma junção esquerda.

SELECT
    s.StateProvinceName,
    ci.CityName,
    cu.CustomerName
FROM StateProvinces s
INNER JOIN Cities AS ci
ON ci.StateProvinceID = s.StateProvinceID
LEFT JOIN Customers cu  
ON cu.PostalCityId = ci.CityId;

Resultado:

----------+----------------+-------- --------+| EstadoProvínciaNome | NomeCidade | NomeDoCliente ||----------+----------------+-------- --------|| Colorado | Arco Mar | Veejay Smith || Tennessee | Frankewing | Vinn Allen || Nova York | Gasport | Lisa McQueen || Kansas | Loja de Medicina | Bart Pitt || Arizona | Vale dos Peeples | NULO || Dakota do Norte | Jessie | Steve Simpson || Nebrasca | Lisco | Homer McKenzie || Dakota do Norte | Wimbledon | Borat Lee |+---------------------+----------------+------- ---------+(8 linhas afetadas)

Neste caso, temos uma cidade (Peeples Valley) que ainda não possui clientes.

A razão pela qual agora podemos ver essas informações é porque a junção à esquerda retorna linhas que possuem dados na tabela à esquerda, mesmo que não haja linhas correspondentes na tabela à esquerda.

O exemplo anterior que combinou duas junções internas não retornou esta linha, porque as junções internas descartam linhas não correspondidas de ambas as tabelas. Ele só retorna linhas quando há pelo menos uma linha em ambas as tabelas que correspondam à condição de junção.

Novos dados de amostra - 3 tabelas diferentes

Para os exemplos restantes, usaremos as tabelas a seguir.

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 | [email protected] || 2 | Bart | Pitt | (231) 465-3497 | [email protected] || 3 | Nancy | Simpson | (489) 591-0408 | NULO || 4 | Bóris | Trump | (349) 611-8908 | NULO || 5 | Amadeirado | Eastwood | (308) 555-0112 | [email protected] |+-----------+-------------+------------+---- ------------+-------------------+

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.

Exemplo 3 – Unir 3 tabelas à esquerda

Vamos fazer uma junção de três tabelas usando duas junções à esquerda.

Aqui está um exemplo de execução de duas junções à esquerda nessas tabelas.

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Owners o LEFT JOIN Pets p
    ON p.OwnerId = o.OwnerId
LEFT 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 |+-----------+-----------+----------------+(9 linhas afetadas)

Aqui, temos um dono de animal de estimação que não tem um animal de estimação. Podemos verificar isso olhando para o Pets.OwnerId coluna e vendo que não há valor que corresponda ao OwnerId de Woody Eastwood em Owners tabela.

Exemplo 4 - Junção direita de 3 tabelas

A junção direita é o oposto da junção esquerda. Aqui está um exemplo usando as mesmas três tabelas.

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

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 | |+-----------+-----------+---------------+(9 linhas afetadas)

Desta vez temos um tipo de animal de estimação extra (Rabbit ), mas não o proprietário extra. Isso ocorre porque as junções à direita retornam linhas que possuem dados na tabela à direita, mesmo que não haja linhas correspondentes na tabela à esquerda.

A propósito, o motivo do ú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.

Exemplo 5 – Junção Completa de 3 Mesas

A junção completa é como ter uma junção esquerda e direita em uma. Ele retorna todas as linhas, desde que haja dados correspondentes em uma das 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, obtemos uma combinação dos resultados obtidos nos dois exemplos anteriores. 
 Exemplo 6 – Junções aninhadas
 
 Conforme mencionado, você também pode fazer junções aninhadas. 
 
 Aqui está um exemplo de uma junção aninhada. 
 SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Owners o 
LEFT JOIN    (Pets p
        LEFT JOIN PetTypes pt
        ON p.PetTypeId = pt.PetTypeId)
ON p.OwnerId = o.OwnerId; 
 
 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 |+-----------+-----------+----------------+(9 linhas afetadas)