SQL Left Join

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

O LEFT JOIN , ou LEFT OUTER JOIN , retorna as linhas que contêm dados na tabela à esquerda (à esquerda de JOIN palavra-chave), mesmo que não haja linhas correspondentes na tabela correta.

Sintaxe

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

Usando o LEFT JOIN sintaxe:

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

Usando o LEFT OUTER JOIN sintaxe:

SELECT *
FROM Table1 LEFT 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           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)

Os Pets tabela:

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 1       | 2           | 3         | Fluffy    | 2020-11-20 |
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
| 4       | 3           | 3         | Wag       | 2020-03-15 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
| 6       | 3           | 4         | Fluffy    | 2020-09-17 |
| 7       | 3           | 2         | Bark      | NULL       |
| 8       | 2           | 4         | Meow      | NULL       |
+---------+-------------+-----------+-----------+------------+
(8 rows affected)

Os Owners tabela:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
| 5         | Woody       | 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.

A consulta de junção à esquerda

Aqui está um exemplo de execução de uma junção à esquerda em duas dessas tabelas.

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

Resultado:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Tweet     | Bird      |
| Fluffy    | Cat       |
| Scratch   | Cat       |
| Meow      | Cat       |
| Fetch     | Dog       |
| Wag       | Dog       |
| Fluffy    | Dog       |
| Bark      | Dog       |
| NULL      | Rabbit    |
+-----------+-----------+
(9 rows affected)

A junção esquerda nos faz obter um PetType valor que não corresponde a um PetName . Não existem coelhos como animais de estimação. Mas a junção esquerda causa 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 .

Isso só aconteceu porque Rabbit estava na tabela à esquerda (ou seja, à esquerda do LEFT JOIN palavras-chave). OK, minha formatação torna mais “acima” do que “esquerda”, mas você entendeu.

Aqui está o que acontece se mudarmos a ordem da tabela em nossa consulta.

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

Resultado:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+
(8 rows affected)

Desta vez Rabbits não foi devolvido. Isso porque sua tabela (PetTypes ) estava no lado direito da junção.

Precisaríamos alterá-lo para uma junção direita ou uma junção completa se quiséssemos Rabbits a ser retornado usando esta ordem de tabela.

Juntar à esquerda em 3 mesas

Aqui está um exemplo de execução de uma junção à esquerda em todas as três 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     | Bird      | Homer Connery  |
| Scratch   | Cat       | Bart Pitt      |
| Bark      | Dog       | Bart Pitt      |
| Fluffy    | Cat       | Nancy Simpson  |
| Fetch     | Dog       | Nancy Simpson  |
| Wag       | Dog       | Nancy Simpson  |
| Fluffy    | Dog       | Boris Trump    |
| Meow      | Cat       | Boris Trump    |
| NULL      | NULL      | Woody Eastwood |
+-----------+-----------+----------------+
(9 rows affected)

Desta vez, temos um dono de animal de estimação que não tem um animal de estimação.

Poderíamos novamente embaralhar a ordem das mesas e obteríamos um resultado diferente.

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

Resultado:

+-----------+-----------+---------------+
| PetName   | PetType   | PetOwner      |
|-----------+-----------+---------------|
| Tweet     | Bird      | Homer Connery |
| Fluffy    | Cat       | Nancy Simpson |
| Scratch   | Cat       | Bart Pitt     |
| Meow      | Cat       | Boris Trump   |
| Fetch     | Dog       | Nancy Simpson |
| Wag       | Dog       | Nancy Simpson |
| Fluffy    | Dog       | Boris Trump   |
| Bark      | Dog       | Bart Pitt     |
| NULL      | Rabbit    |               |
+-----------+-----------+---------------+
(9 rows affected)

Desta vez temos o tipo de animal de estimação extra (Rabbit ), mas não o proprietário extra.

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.