Database
 sql >> Base de Dados >  >> RDS >> Database

Associação Natural SQL


Este artigo fornece uma visão geral da junção natural no SQL, bem como alguns exemplos básicos.

O que é uma junção natural?


A junção natural SQL é um tipo de junção equitativa que combina implicitamente tabelas baseadas em colunas com o mesmo nome e tipo. O predicado de junção surge implicitamente comparando todas as colunas em ambas as tabelas que possuem os mesmos nomes de coluna nas tabelas unidas.

O conjunto de resultados contém apenas uma coluna para cada par de colunas com nomes iguais. Se nenhuma coluna com os mesmos nomes for encontrada, o resultado será uma junção cruzada.

Sintaxe


Uma junção natural pode ser aplicada a qualquer INNER , LEFT , RIGHT , ou FULL Junte-se. Você simplesmente prefixa o tipo de junção com o NATURAL palavra-chave.

Exemplo da sintaxe usada em uma junção interna:
SELECT *
FROM Table1 NATURAL INNER JOIN Table2 
ON Table1.Column = Table2.Column;

Vendo como INNER é o valor padrão, você também pode fazer assim:
SELECT *
FROM Table1 NATURAL JOIN Table2 
ON Table1.Column = Table2.Column;

O NATURAL palavra-chave coloca um USING implícito cláusula às restrições de junção. Ele forma um USING lista que consiste em todos os nomes de coluna que aparecem em ambas as tabelas de entrada. Obviamente, isso se aplica apenas a DBMSs que suportam a função USING cláusula.

Nem todos os DBMSs suportam junções naturais, portanto, verifique a documentação do seu DBMS.

Enquanto escrevo isso, as junções naturais são suportadas no PostgreSQL, MySQL, MariaDB, SQLite e Oracle. No entanto, as junções naturais não têm suporte no SQL Server (2019).

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.

Exemplo 1 – Junção Interna Natural


Aqui está um exemplo de execução de uma junção interna natural em duas dessas tabelas. 
SELECT 
    PetName,
    PetType
FROM Pets
NATURAL JOIN PetTypes;

Resultado:
 petname | pettype 
---------+---------
 Fluffy  | Cat
 Fetch   | Dog
 Scratch | Cat
 Wag     | Dog
 Tweet   | Bird
 Fluffy  | Dog
 Bark    | Dog
 Meow    | Cat
(8 rows)

Neste exemplo, a junção natural uniu implicitamente as tabelas nos dois PetTypeId colunas (ou seja, o Pets.PetTypeId coluna e o PetTypes.PetTypeId coluna).

Esta é uma maneira implícita de fazer o seguinte:
SELECT 
    PetName,
    PetType
FROM Pets
INNER JOIN PetTypes USING (PetTypeId);

Que realmente faz o seguinte. 
SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
INNER JOIN PetTypes pt 
ON p.PetTypeId = pt.PetTypeId;

Exemplo 2 – União de Direito Natural


Aqui está um exemplo de como realizar uma junção à direita natural em duas dessas tabelas. Desta vez temos que especificar o tipo de junção, visto que não queremos a junção interna (padrão). 
SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
NATURAL RIGHT JOIN PetTypes pt;

Resultado:
 petname | pettype 
---------+---------
 Fluffy  | Cat
 Fetch   | Dog
 Scratch | Cat
 Wag     | Dog
 Tweet   | Bird
 Fluffy  | Dog
 Bark    | Dog
 Meow    | Cat
         | Rabbit
(9 rows)

Nesse caso, é o mesmo que fazer o seguinte:
SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
RIGHT JOIN PetTypes pt 
ON p.PetTypeId = pt.PetTypeId;

Exemplo 3 – Junção completa natural em 3 mesas


Aqui está um exemplo de execução de uma junção completa natural em todas as três tabelas. 
SELECT 
    PetName,
    PetType,
    CONCAT(FirstName, ' ', LastName) AS PetOwner
FROM Owners NATURAL FULL JOIN Pets
NATURAL FULL JOIN PetTypes;

Resultado:
 petname | pettype |    petowner    
---------+---------+----------------
 Fluffy  | Cat     | Nancy Simpson
 Fetch   | Dog     | Nancy Simpson
 Scratch | Cat     | Bart Pitt
 Wag     | Dog     | Nancy Simpson
 Tweet   | Bird    | Homer Connery
 Fluffy  | Dog     | Boris Trump
 Bark    | Dog     | Bart Pitt
 Meow    | Cat     | Boris Trump
         |         | Woody Eastwood
         | Rabbit  |  
(10 rows)

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.

Exemplo 4 – Usando o Asterisco (* ) Caractere curinga


Aqui está um exemplo que usa o caractere curinga asterisco (*) para selecionar todas as colunas. 
SELECT *
FROM Pets
NATURAL JOIN PetTypes;

Resultado:
 pettypeid | petid | ownerid | petname |    dob     | pettype 
-----------+-------+---------+---------+------------+---------
         2 |     1 |       3 | Fluffy  | 2020-11-20 | Cat
         3 |     2 |       3 | Fetch   | 2019-08-16 | Dog
         2 |     3 |       2 | Scratch | 2018-10-01 | Cat
         3 |     4 |       3 | Wag     | 2020-03-15 | Dog
         1 |     5 |       1 | Tweet   | 2020-11-28 | Bird
         3 |     6 |       4 | Fluffy  | 2020-09-17 | Dog
         3 |     7 |       2 | Bark    |            | Dog
         2 |     8 |       4 | Meow    |            | Cat
(8 rows)

Observe que o pettypeid coluna é retornada apenas uma vez, embora existam duas colunas com esse nome (uma em cada tabela). É assim que as junções naturais lidam com colunas de mesmo nome nas tabelas.