União completa de dados com FULL OUTER JOIN

Hoje a gente vai entender a forma mais democrática de juntar dados — o FULL OUTER JOIN. Aqui, todo mundo entra no resultado, mesmo se não tiver par.

FULL OUTER JOIN é um tipo de união de dados onde retorna todas as linhas das duas tabelas. Se uma linha de uma tabela não tem correspondente na outra, os valores ausentes no resultado vão ser NULL. É tipo fazer a lista de todo mundo que foi em duas festas diferentes: mesmo quem foi só em uma delas vai aparecer na lista.

Visualmente, fica assim:

Tabela A                     Tabela B
+----+----------+             +----+----------+
| id | nome     |             | id | curso    |
+----+----------+             +----+----------+
| 1  | Alice    |             | 2  | Math     |
| 2  | Bob      |             | 3  | Physics  |
| 4  | Charlie  |             | 5  | History  |
+----+----------+             +----+----------+

FULL OUTER JOIN RESULTADO:
+----+----------+----------+
| id | nome     | curso    |
+----+----------+----------+
| 1  | Alice    | NULL     |
| 2  | Bob      | Math     |
| 3  | NULL     | Physics  |
| 4  | Charlie  | NULL     |
| 5  | NULL     | History  |
+----+----------+----------+

As linhas sem correspondência continuam, mas os dados das colunas que faltam vão ser NULL.

Sintaxe do FULL OUTER JOIN

A sintaxe é simples, mas poderosa:

SELECT
    colunas
FROM 
    tabela1
FULL OUTER JOIN 
    tabela2
ON tabela1.coluna_comum = tabela2.coluna_comum;

A parte chave aqui é o FULL OUTER JOIN, que faz o PostgreSQL pegar todas as linhas das duas tabelas. Se faltar par pelo critério do ON, os valores vão ser NULL.

Exemplos de uso

Bora ver exemplos reais usando o banco university com as tabelas students e enrollments.

Exemplo 1: lista de todos os estudantes e cursos

Imagina que temos duas tabelas:

Tabela students:

Tabela enrollments:

Nosso objetivo é montar a lista completa de estudantes e cursos, incluindo quem não está em nenhum curso e cursos sem estudantes.

Olha a query:

SELECT
    s.student_id, 
    s.nome, 
    e.curso
FROM 
    students s
FULL OUTER JOIN 
    enrollments e
ON 
    s.student_id = e.student_id;

Resultado:

Viu só? Todos os estudantes e todos os cursos aparecem. O estudante Charlie não está em nenhum curso, então o campo curso dele é NULL. E o curso History não tem estudante, então student_id e nome são NULL.

Exemplo 2: Análise de vendas e produtos

Agora pensa numa loja. Temos duas tabelas:

Tabela products:

Tabela sales:

A gente quer ver a lista completa de produtos e vendas, incluindo produtos que não foram vendidos e vendas com product_id inválido.

Query:

SELECT
    p.product_id,
    p.nome AS nome_produto,
    s.quantidade
FROM 
    products p
FULL OUTER JOIN 
    sales s
ON 
    p.product_id = s.product_id;

Resultado:

Aqui dá pra ver que o Smartphone não teve venda (quantidade = NULL) e a venda com product_id = 4 não bate com nenhum produto.

Exercício prático

Tenta escrever uma query pras tabelas departments e employees:

Tabela departments:

Tabela employees:

Faz um FULL OUTER JOIN pra pegar a lista completa de departamentos e funcionários. Preenche os dados que faltam com NULL.

Como lidar com valores NULL

O lance dos valores NULL é que eles sempre aparecem quando você usa FULL OUTER JOIN. Em situações reais, pode ser que você queira trocar o NULL por algo mais amigável. No PostgreSQL, dá pra fazer isso com a função COALESCE().

Exemplo:

SELECT
    COALESCE(s.nome, 'Sem Estudante') AS nome_estudante,
    COALESCE(e.curso, 'Sem Curso') AS nome_curso
FROM 
    students s
FULL OUTER JOIN 
    enrollments e
ON 
    s.student_id = e.student_id;

Resultado:

Agora, em vez de NULL, aparecem valores mais claros, deixando os relatórios bem mais legíveis.

Quando usar FULL OUTER JOIN

FULL OUTER JOIN é útil quando você precisa ver todos os dados das duas tabelas, mesmo se não estiverem totalmente ligados. Exemplos:

• Relatórios de vendas e produtos — pra ver tanto os produtos vendidos quanto os não vendidos.
• Análise de estudantes e cursos — pra checar se tem dados faltando.
• Comparação de listas — tipo pra achar diferenças entre dois conjuntos de dados.

Espero que essa aula tenha te dado uma boa noção de FULL OUTER JOIN. Agora é só explorar o mundo das uniões mais avançadas e manipulação de dados!