Introdução às junções SQL

Tradicionalmente, você extrai dados de duas ou mais tabelas usando um WHERE cláusula em uma consulta. Mas em um sistema de banco de dados relacional (RDBMS), isso pode ser feito usando um único SELECT inquerir. Este é o verdadeiro poder dos sistemas de banco de dados relacionais. Neste guia, você aprenderá sobre SQL Joins, uma maneira poderosa de comparar e selecionar linhas e tabelas.

O que é uma associação SQL?

No SQL, uma join cláusula estende a capacidade de comparar e selecionar linhas de tabelas. Ele usa um processo algébrico de combinar linhas de duas ou mais tabelas com base em uma coluna relacionada nessas tabelas. Pela definição SQL padrão ANSI, existem cinco tipos de junções –junções cruzadas , junções internas , Uniões Esquerdas (Externas) , Uniões Direitas (Externas) , e junções completas (externas) . Essas junções são implementadas em todos os sistemas de banco de dados relacionais e são abordadas nas seções abaixo.

Observação As junções podem ser executadas em qualquer número de tabelas em uma determinada consulta. Por questões de brevidade e clareza, este guia discute Joins aplicadas a duas tabelas.

Este guia usa duas tabelas, Employees e Address , respectivamente, para demonstrar junções SQL. Cada uma dessas tabelas contém as seguintes definições e dados de coluna:

Tabela de funcionários

EmployeeId NomeFuncionário

1 João

2 Maria

3 Roberto
Tabela de endereços

ID Estado

1 Nova York

2 Nova Jersey

3 Idaho

4 Havaí

EmployeeId	NomeFuncionário
1	João
2	Maria
3	Roberto

ID	Estado
1	Nova York
2	Nova Jersey
3	Idaho
4	Havaí

Observação Salvo menção em contrário, todos os comandos neste guia funcionam bem em MySQL e PostgreSQL bancos de dados.

Uniões cruzadas de SQL

Também conhecido como União Cartesiana , as junções cruzadas ocorrem quando você especifica várias tabelas como origem para seu SELECT lista de colunas. Neste caso, você deixa de fora o WHERE cláusula join expressão para corresponder as linhas. O conjunto de resultados contém uma linha para cada combinação de linhas entre as tabelas. Em um cenário de duas tabelas, cada linha em uma tabela é emparelhada com cada linha da outra tabela. O produto resultante é conhecido como Produto Cartesiano das duas tabelas. A sintaxe para uma junção cruzada é a seguinte:

(# Rows in Table A) TIMES (# of Rows in Table B)

Observação
Na teoria dos conjuntos, o Produto Cartesiano é uma operação de multiplicação que gera todos os pares ordenados dos conjuntos dados. Por exemplo, considere definir A com elementos {a,b} e defina B com elementos {1,2,3} . O produto cartesiano de A e B é indicado por AxB e o resultado é o seguinte:
AxB ={(a,1), (a,2), (a,3), (b,1), (b,2), (b,3)}

A sintaxe SQL para uma junção cruzada é a seguinte:

SELECT ColumnName_1,
       ColumnName_2,
       ColumnName_N
FROM [Table_1]
     CROSS JOIN [Table_2]

Da sintaxe acima, Column_1 , Column_2 , Column_N representam as colunas em uma tabela e o CROSS JOIN cláusula serve para combinar as duas tabelas, Table_1 e Table_2 . Nas tabelas de exemplo acima, se você precisar realizar uma junção cruzada em Employees e Address tabelas, use o seguinte código SQL:

SELECT EmployeeName, State
FROM Employees
CROSS JOIN Address

A saída do código SQL acima é semelhante ao seguinte:

+--------------+--------------+
| EmployeeName | State        |
+---------------+-------------+
| John         |   New York   |
| John         |   New Jersey |
| John         |   Idaho      |
| John         |   Hawaii     |
| John         |   New York   |
| Mary         |   New York   |
| Mary         |   New Jersey |
| Mary         |   Idaho      |
| Mary         |   Hawaii     |
| Robert       |   New York   |
| Robert       |   New Jersey |
| Robert       |   Idaho      |
| Robert       |   Hawaii     |
+------------+----------------+

SQL Inner Join

Um Inner Join retorna linhas que possuem valores correspondentes em ambas as tabelas. Se não houver registros correspondentes, nenhuma linha será retornada nos resultados.

A sintaxe SQL para Inner Join é a seguinte:

SELECT ColumnName_1,
       ColumnName_2,
       ColumnName_N
FROM Table_1
INNER JOIN Table_2
ON Table_1.key = Table_2.key;

No exemplo acima, key é a respectiva chave das tabelas. Se você precisar realizar uma junção interna em Employees e Address tabelas, use o seguinte código SQL:

SELECT EmployeeName, State
FROM Employees
INNER JOIN Address
ON Employees.EmployeeId = Address.Id

A saída do código SQL acima é semelhante ao seguinte:

+--------------+--------------+
| EmployeeName | State        |
+---------------+-------------+
| John         |   New York   |
| Mary         |   New Jersey |
+------------+----------------+

União SQL esquerda (externa)

Uma Junção Esquerda retorna um conjunto completo de linhas da tabela da esquerda junto com as linhas correspondentes da tabela da direita. Se não houver registros correspondentes, NULL os valores são retornados da tabela à direita.

Observação Algumas implementações de banco de dados relacional usam as palavras-chave “Left Outer Join”, em oposição a “Left Join”, mas são funcionalmente equivalentes.

A sintaxe SQL para Left Join é a seguinte:

SELECT * FROM Table_1
LEFT JOIN Table_2
ON Table_1.key = Table_2.key

No exemplo acima, key é a respectiva chave das tabelas. Se você precisar realizar uma junção à esquerda em Employees e Address tabelas, use o seguinte código SQL:

SELECT EmployeeName, State
FROM Employees
LEFT JOIN Address
ON Employees.EmployeeId = Address.Id

A saída do código SQL acima é a seguinte:

+--------------+--------------+
| EmployeeName | State        |
+---------------+-------------+
| John         |   New York   |
| Mary         |   New Jersey |
| Robert       |   NULL       |
+------------+----------------+

SQL Right (Outer) Join

Uma Junção Direita retorna um conjunto completo de linhas da tabela da direita e as linhas correspondentes da tabela da esquerda. Isso também é conhecido como Junção Externa Direita. Se não houver registros correspondentes, NULL os valores são retornados da tabela direita, para as linhas afetadas na tabela esquerda.

Observação Algumas implementações de banco de dados relacional usam as palavras-chave “Right Outer Join”, em oposição a “Right Join”, mas são funcionalmente equivalentes.

A sintaxe SQL para um Right Join é a seguinte:

SELECT * FROM Table_1
RIGHT JOIN Table_2
ON Table_1.key = Table_2.key

Do código acima, key é a respectiva chave das tabelas. Se você precisar realizar uma associação à direita em Employees e Address tabelas, use o seguinte código SQL:

SELECT EmployeeName, State
FROM Employees
RIGHT JOIN Address
ON Employees.EmployeeId = Address.Id

A saída do código SQL acima é a seguinte:

+--------------+--------------+
| EmployeeName | State        |
+---------------+-------------+
| John         |   New York   |
| Mary         |   New Jersey |
| NULL         |   Idaho      |
| NULL         |   Hawaii     |
+------------+----------------+

SQL Full (Outer) Join

Uma Junção Completa retorna todas as linhas da tabela à esquerda, todas as linhas da tabela à direita. Isso também é conhecido como Full Outer Join. Uma Junção Completa também retorna todos os registros correspondentes de ambas as tabelas, quando disponíveis. Se não houver registros correspondentes, NULL os valores são retornados da tabela esquerda. Ele também retorna NULL valores da tabela direita.

Observação Algumas implementações de banco de dados relacional usam as palavras-chave “Full Outer Join”, em oposição a “Full Join”, mas são funcionalmente equivalentes.

A sintaxe SQL para Full Join é a seguinte:

SELECT * FROM Table1
FULL JOIN Table2
ON Table1.key = Table2.key

No código acima, key é a respectiva chave das tabelas. Se você precisar realizar uma junção completa em Employees e Address tabelas, use o seguinte código SQL:

SELECT EmployeeName, State
FROM Employees
FULL JOIN Address
ON Employees.EmployeeId = Address.Id

A saída do código SQL acima é a seguinte:

+--------------+--------------+
| EmployeeName | State        |
+---------------+-------------+
| John         |   New York   |
| Mary         |   New Jersey |
| Robert       |   NULL       |
| NULL         |   Idaho      |
| NULL         |   Hawaii     |
+------------+----------------+

Observação Durante os cálculos de junção, se você comparar os dados da tabela com NULL valores, eles não combinam entre si. Portanto, NULL os valores são retornados apenas como parte dos resultados do Join e são ignorados durante os cálculos do Join.

Comparação de desempenho de junções SQL

Considerando as tabelas de exemplo acima, o Inner Join é normalmente a mais rápida das cinco cláusulas Join em termos de desempenho do banco de dados. O Left Join e o Right Join são os próximos mais rápidos dependendo do tamanho das duas tabelas. A Junção Completa é normalmente mais lenta que a Junção Esquerda ou a Junção Direita. O Cross Join, dependente do produto cartesiano das duas tabelas, é normalmente o mais lento em termos de desempenho do banco de dados. A hierarquia de desempenho especificada pode diferir dependendo do comprimento da coluna da tabela, do tipo de dados da coluna e das definições de chave.

Conclusão

O uso de SQL Joins estende a funcionalidade de poder comparar linhas de tabela, sobre o tradicional WHERE consultas de cláusulas. As junções são um mecanismo valioso para aplicar lógica algébrica a duas ou mais tabelas.