SQL Inner Join

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

O SQL INNER JOIN retorna linhas quando há pelo menos uma linha em ambas as tabelas que correspondem à condição de junção. Ele descarta as linhas não correspondidas de ambas as tabelas. Este é o tipo de junção padrão.

Sintaxe

Existem duas maneiras de especificar uma junção interna:no FROM cláusula (usando a cláusula INNER JOIN sintaxe), ou usando o WHERE cláusula.

Para especificar uma junção interna no FROM cláusula:

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

Para especificar uma junção interna no WHERE cláusula:

SELECT *
FROM Table1, Table2 
WHERE Table1.Column = Table2.Column;

Abaixo estão exemplos de cada um.

Exemplos

Aqui, temos exemplos para cada método de especificação de uma junção interna.

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

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 usando a sintaxe INNER JOIN

Aqui está um exemplo básico de especificação de uma junção interna usando o INNER JOIN sintaxe.

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

Resultado:

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

Para especificar uma junção interna no FROM cláusula, usamos INNER JOIN . Também usamos o ON palavra-chave para definir o predicado a ser avaliado para cada par de linhas unidas.

Independentemente do tipo de junção, qualificamos nossos nomes de coluna com os nomes de tabela. O motivo pelo qual fazemos isso é para evitar qualquer ambiguidade em relação aos nomes das colunas entre as tabelas. Ambas as tabelas podem ter colunas com o mesmo nome (como em nosso exemplo) e, nesses casos, o DBMS não saberá a qual coluna você está se referindo. Prefixar os nomes das colunas com seus nomes de tabela garante que você esteja referenciando a coluna correta e evita erros que possam resultar de qualquer ambiguidade sobre a coluna à qual você está se referindo.

Neste exemplo, ambas as tabelas têm um PetTypeId coluna. O Pets.PetTypeId coluna é uma chave estrangeira para o PetTypes.PetTypeId coluna, que é a chave primária para essa tabela.

Neste exemplo, podemos ver que todos os animais de estimação são retornados, mas nem todos os tipos de animais de estimação são retornados. Não há coelhos nos Pets tabela, e assim os Rabbits tipo de animal de estimação não é retornado.

A razão pela qual os Rabbits tipo não é retornado é porque o INNER JOIN só retorna linhas quando há pelo menos uma linha em ambas as tabelas que correspondam à condição de junção. Neste caso, Rabbits está apenas em uma tabela (o PetTypes tabela).

O tipo de associação é opcional

Observe que o tipo de junção é opcional. Portanto, a maioria (se não todos) DBMSs permite que você omita o INNER palavra-chave. Quando você omitir isso (ou seja, especificar apenas JOIN ), supõe-se que seja uma junção interna.

Portanto, poderíamos reescrever o exemplo acima para isso:

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

Formatação

Como em qualquer instrução SQL, você pode usar espaços em branco e recuos, etc., para formatar suas consultas.

Por exemplo, o FROM cláusula pode estar em uma linha inteira, se você preferir:

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

Quando você escreve tabelas maiores que unem várias tabelas, o recuo pode ajudar muito.

Exemplo usando a cláusula WHERE

A junção acima também pode ser chamada de equi-join . Uma junção equi é uma junção que contém apenas comparações de igualdade no predicado de junção.

Aqui está um exemplo de especificação de uma junção interna usando o WHERE cláusula:

SELECT
    p.PetName,
    pt.PetType
FROM 
    Pets p, 
    PetTypes pt
WHERE p.PetTypeId = pt.PetTypeId;

Resultado:

+-----------+-----------+| PetName   | PetType   ||-----------+-----------|| Fofo    | Gato       || Buscar     | Cachorro       || Rascunho   | Gato       || Wag       | Cachorro       || Tweet     | Pássaro      || Fofo    | Cachorro       || Latido      | Cachorro       || Miau      | Cat       |+-----------+-----------+(8 linhas afetadas)

Isso retornou o mesmo resultado do exemplo anterior.

Aqui, simplesmente fornecemos uma lista separada por vírgulas das tabelas e, em seguida, um WHERE doença. Se tivéssemos omitido o WHERE condição, teríamos acabado com um CROSS JOIN .

Muitos iniciantes acham a sintaxe acima muito mais fácil de entender do que o INNER JOIN sintaxe. Sinta-se à vontade para usar esta sintaxe se preferir, no entanto, esteja ciente de que a maioria dos profissionais de SQL prefere usar o INNER JOIN sintaxe do exemplo anterior.

Inner Join em 3 mesas

Aqui está um exemplo de execução de uma junção interna em 3 tabelas.

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

Resultado:

+-----------+-----------+---------------+| PetName   | PetType   | PetOwner      ||-----------+-----------+---------------|| Fofo    | Gato       | Nancy Simpson || Buscar     | Cão       | Nancy Simpson || Rascunho   | Gato       | Bart Pitt     || Wag       | Cão       | Nancy Simpson || Tweet     | Pássaro      | Homer Connery || Fofo    | Cão       | Boris Trump   || Latido      | Cão       | Bart Pitt     || Miau      | Gato       | Boris Trump   |+-----------+-----------+---------------+(8 linhas afetadas) 
 Neste exemplo, trouxemos os Owners table no mix porque precisávamos dessa consulta para retornar informações sobre o proprietário. 
 
 Para usar uma terceira tabela, tudo o que fizemos foi adicionar outro INNER JOIN... ON argumento junto com os detalhes relevantes da tabela/coluna. 
 
 Neste caso, usei o CONCAT() do T-SQL função para concatenar duas colunas, mas isso é irrelevante para a junção.