Tutorial de joins em SQL

SQL Server é um sistema de gerenciamento de banco de dados relacional. Um dos princípios básicos de um banco relacional é que os dados ficam distribuídos em várias tabelas.

Para extrair os dados de que precisamos, vamos precisar juntar tabelas. Usamos chaves primary e foreign para relacioná-las.

Primary Key

Uma chave primária é uma coluna usada para identificar de forma única cada linha de uma tabela. Essa exclusividade pode ser obtida usando um inteiro sequencial como coluna de identidade. Ou, às vezes, colunas existentes já contêm valores únicos e podem ser usadas.

No exemplo abaixo, vemos as primeiras linhas da tabela artist. Ela tem duas colunas, artist_id e name. A coluna artist_id funciona como chave primária dessa tabela: é uma coluna inteira e cada valor é diferente.

+-----------+-------------------+
| artist_id | name              |
|-----------+-------------------|
| 1         | AC/DC             |
| 2         | Accept            |
| 3         | Aerosmith         |
| 4         | Alanis Morissette |
| 5         | Alice In Chains   |
+-----------+-------------------+
Tecnologia

Agora vamos olhar a tabela album. Consegue identificar a chave primária? Sim, é a coluna album_id. É comum a chave primária seguir o padrão "nome-da-tabela" + "underline" + "id". Mas você também deve ter notado a coluna artist_id. Ela também é composta por inteiros e tem o mesmo nome da coluna artist_id na tabela artist. O que isso significa?

+----------+-------------------------+-----------+
| album_id | title                   | artist_id |  
|----------+-------------------------+-----------|
| 1        | For Those About To Rock | 1         |
| 2        | Balls to the Wall       | 2         |
| 3        | Restless and Wild       | 2         |
| 4        | Let There Be Rock       | 1         |
| 5        | Big Ones                | 3         |
+----------+-------------------------+-----------+
Tecnologia

Foreign Keys

Pelo resultado anterior, fica claro que o artist_id na tabela artist atua como uma Foreign_key para a tabela album. A restrição FOREIGN KEY é usada para evitar ações que quebrem os vínculos entre tabelas.

• tabela artist

+-----------+-------------------+
| artist_id | name              |
|-----------+-------------------|
| 1         | AC/DC             |
| 2         | Accept            |
| 3         | Aerosmith         |
| 4         | Alanis Morissette |
| 5         | Alice In Chains   |
+-----------+-------------------+
Tecnologia

• tabela album

+----------+-------------------------+-----------+
| album_id | title                   | artist_id |  
|----------+-------------------------+-----------|
| 1        | For Those About To Rock | 1         |
| 2        | Balls to the Wall       | 2         |
| 3        | Restless and Wild       | 2         |
| 4        | Let There Be Rock       | 1         |
| 5        | Big Ones                | 3         |
+----------+-------------------------+-----------+
Tecnologia

Isso significa que, quando o artist_id na tabela album coincide com o artist_id na tabela artist, essas linhas podem ser vinculadas com um JOIN.

Juntando album e artist

As linhas 1 e 4 da tabela artist têm artist_id igual a 1. O artist_id 1 na tabela artist é AC/DC. Então, quando juntamos as duas tabelas, retornamos os detalhes do álbum a partir da tabela album e os detalhes correspondentes do artista a partir da tabela artist — unidos pelo campo artist_id, que é comum às duas tabelas.

Isso é conhecido como um inner join.

SELECT
  album_id,
  title,
  album.artist_id,
  name AS artist_name
FROM album
INNER JOIN artist ON artist.artist_id = album.artist_id
WHERE album.artist_id = 1;
Tecnologia

+----------+-------------------------+-----------+-------------+
| album_id | title                   | artist_id | artist_name |
|----------+---------------------------------------+-----------|
| 1        | For Those About To Rock | 1         | AC/DC       |
| 4        | Let There Be Rock       | 1         | AC/DC       |
+----------+-------------------------+-----------+-------------+
Tecnologia

Juntamos as tabelas album e artist igualando o artist_id da tabela artist ao artist_id da tabela album.

Ao selecionar colunas com o mesmo nome em tabelas diferentes, você precisa qualificar totalmente o nome da coluna. Caso contrário, o SQL Server não saberá de qual tabela deve SELECT a coluna.

Para qualificar uma coluna, basta prefixá-la com o nome da tabela correspondente, seguido de um ponto.

Sintaxe de inner join

Aqui vai um exemplo genérico para relembrar a sintaxe. Primeiro selecionamos as colunas relevantes da tabela principal, neste caso a table_A, e depois qualquer coluna adicional que queremos juntar, aqui da table_B. Em seguida, definimos o join usando as palavras-chave INNER JOIN e ON, informando as colunas-chave necessárias de ambas as tabelas.

SELECT
    table_A.columnX,
    table_A.columnY,
    table_B.columnZ,
FROM table_A
INNER JOIN table_B ON table_B.foreign_key = table_A.primary_key;
Tecnologia

Sem usar a cláusula WHERE

Neste exemplo, não especificamos uma cláusula WHERE, então retornamos TODAS as combinações de TODOS os matches entre as tabelas artist e album, novamente com base na coluna artist_id, que é comum às duas.

SELECT
  album_id,
  title,
  album.artist_id,
  name AS artist_name
FROM album
INNER JOIN artist on artist.artist_id = album.artist_id;
Tecnologia

+----------+---------------------------------------+-----------+
| album_id | title                   | artist_id | artist_name |
|----------+---------------------------------------+-----------|
| 1        | For Those About To Rock | 1         | AC/DC       |
| 4        | Let There Be Rock       | 1         | AC/DC       |
| 2        | Balls To The Wall       | 2         | Accept      |
| 3        | Restless and Wild       | 2         | Accept      |
+----------+---------------------------------------+-----------+
Tecnologia

Vários inner joins

Você também pode juntar mais de duas tabelas usando INNER JOINS. Basta adicionar um INNER JOIN extra para cada combinação de tabelas. No código abaixo, juntamos as tabelas A e B e também B e C.

SELECT
  table_A.columnX,
  table_A.columnY,
  table_B.columnZ table_C columnW
FROM table_A
INNER JOIN table_B ON table_B.foreign_key = table_A.primary_key
INNER JOIN table_C ON table_C.foreign_key = table_B.primary_key;
Tecnologia

Para saber mais sobre como juntar tabelas, veja este vídeo do nosso curso Introduction to SQL Server.

Este conteúdo foi extraído do curso Introduction to SQL Server da DataCamp, por John MacKintosh.