Associação à direita do SQL

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

Também conhecido como RIGHT OUTER JOIN , o RIGHT JOIN retorna as linhas que possuem dados na tabela à direita (à direita do JOIN palavra-chave), mesmo que não haja linhas correspondentes na tabela à esquerda.

Sintaxe

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

Usando o RIGHT JOIN sintaxe:

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

Usando o RIGHT OUTER JOIN sintaxe:

SELECT *
FROM Table1 RIGHT 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 | example@sqldat.com |
| 2         | Bart        | Pitt       | (231) 465-3497 | example@sqldat.com  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
| 5         | Woody       | 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 certa

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

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
RIGHT JOIN PetTypes pt
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 correta nos faz obter um PetType valor que não corresponde a um PetName . Especificamente, não há coelhos como animais de estimação. Mas a junção correta 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 .

Isso só aconteceu porque Rabbit estava na tabela certa (ou seja, à direita do RIGHT JOIN palavras-chave).

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

SELECT 
    p.PetName,
    pt.PetType
FROM PetTypes pt
RIGHT JOIN Pets p
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 esquerdo da junção.

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

Juntar à direita em 3 mesas

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

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

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 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     | 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.