Merge e Joins de Data Frames no R (merge, left_join)

Duas Tabelas, Uma Chave

Dados reais raramente vivem em uma única tabela. Os clientes ficam em um data frame, seus pedidos em outro, e a pergunta - "quanto cada cliente gastou?" - precisa dos dois. O que os conecta é uma chave: uma coluna presente em cada tabela que identifica a mesma entidade. Combinar tabelas por uma chave é um join (palavra do SQL) ou um merge (palavra do R base); mesma operação.

Aqui está o par de tabelas que o restante desta página usa. Repare que o cliente 5 fez um pedido mas não está na tabela de clientes, e os clientes 2 e 4 nunca pediram nada:

customers <- data.frame(
    id   = c(1, 2, 3, 4),
    name = c("Ana", "Ben", "Chen", "Dana")
)
orders <- data.frame(
    id     = c(1, 1, 3, 5),
    amount = c(250, 40, 120, 60)
)

print(customers)
print(orders)

As incompatibilidades são propositais - o que um join faz com as linhas sem correspondência é exatamente o que distingue os tipos de join.

merge(): Inner Join por Padrão

merge(x, y, by = "key") casa linhas com chaves iguais e cola suas colunas. Por padrão ele mantém apenas as chaves presentes nas duas tabelas - um inner join:

customers <- data.frame(
    id   = c(1, 2, 3, 4),
    name = c("Ana", "Ben", "Chen", "Dana")
)
orders <- data.frame(
    id     = c(1, 1, 3, 5),
    amount = c(250, 40, 120, 60)
)

print(merge(customers, orders, by = "id"))

Voltam três linhas. Ana aparece duas vezes - ela tem dois pedidos, e um join produz uma linha de saída por par correspondente. Ben e Dana sumiram (sem pedidos), assim como o pedido misterioso do cliente 5 (sem cliente). Um inner join descarta silenciosamente as linhas sem correspondência das duas tabelas - exatamente o certo quando você só se importa com pares completos, e um bug silencioso de perda de dados quando não.

Left, Right e Full Joins: all.x, all.y, all

Para manter as linhas sem correspondência, diga de qual tabela as linhas são sagradas. all.x = TRUE mantém todas as linhas da primeira tabela - o left join, o join mais usado na prática:

customers <- data.frame(
    id   = c(1, 2, 3, 4),
    name = c("Ana", "Ben", "Chen", "Dana")
)
orders <- data.frame(
    id     = c(1, 1, 3, 5),
    amount = c(250, 40, 120, 60)
)

print(merge(customers, orders, by = "id", all.x = TRUE))

Agora Ben e Dana sobrevivem, com NA em amount - "este cliente existe; nenhum pedido correspondeu." Esses NAs são informativos, não lixo: is.na(result$amount) é exatamente a lista de clientes que nunca pediram (o doc de valores ausentes cobre como trabalhar com eles). As variantes restantes são a mesma ideia apontada para outro lado: all.y = TRUE mantém todas as linhas da segunda tabela (right join - o pedido do cliente desconhecido 5 sobreviveria com NA em name), e all = TRUE mantém tudo dos dois lados (full join).

Escolha perguntando: quais linhas eu não posso perder? Enriquecer uma tabela-mestre com dados de consulta - left join, tabela-mestre primeiro. Auditar nas duas direções - full join.

Chaves com Nomes Diferentes: by.x e by.y

Tabelas raramente concordam nos nomes - id em uma, customer_id na outra. Não renomeie; informe os dois nomes ao merge():

customers <- data.frame(
    id   = c(1, 2, 3),
    name = c("Ana", "Ben", "Chen")
)
orders <- data.frame(
    customer_id = c(1, 3, 3),
    amount      = c(250, 120, 60)
)

print(merge(customers, orders, by.x = "id", by.y = "customer_id"))

A saída mantém o nome da primeira tabela para a chave. Relacionado: se as duas tabelas compartilham nomes de colunas que não são chave (ambas têm uma date, digamos), o merge as sufixa como date.x e date.y - renomeie-as logo, elas ficam péssimas de ler.

Os Joins do dplyr

O dplyr dá a cada tipo de join seu próprio verbo, de modo que a intenção fica no nome da função em vez de em argumentos-flag (estático; o sandbox roda apenas R base):

library(dplyr)

left_join(customers, orders, by = "id")
inner_join(customers, orders, by = "id")
full_join(customers, orders, by = "id")
left_join(customers, orders, by = c("id" = "customer_id"))  # different names

Além da legibilidade, left_join() preserva a ordem das linhas da primeira tabela (merge() reordena pela chave) e avisa em alto e bom som sobre correspondências muitos-para-muitos - veja a introdução ao dplyr para a família de verbos.

O membro subestimado é o anti_join(): ele retorna as linhas da primeira tabela que não têm correspondência na segunda - nenhuma coluna adicionada, só as sobras:

anti_join(customers, orders, by = "id")   # customers who never ordered

Essa pergunta - "quais linhas ficaram sem correspondência?" - aparece o tempo todo na limpeza de dados (IDs sem par, registros órfãos, consultas que falharam), e anti_join() a responde em uma chamada onde o R base precisa de customers[!(customers$id %in% orders$id), ].

Empilhando Linhas: rbind()

Um join combina as colunas de duas tabelas. Quando, em vez disso, você tem dois lotes do mesmo tipo de linhas - os pedidos de janeiro e os de fevereiro - você os empilha com rbind():

jan <- data.frame(id = c(1, 2), amount = c(250, 40))
feb <- data.frame(id = c(3, 4), amount = c(120, 60))

print(rbind(jan, feb))

O requisito é estrito: os dois data frames precisam ter os mesmos nomes de colunas (em qualquer ordem - rbind casa pelo nome). Uma coluna faltando ou sobrando é um erro, não um preenchimento com NA. Quando os lotes têm colunas divergentes, o bind_rows() do dplyr é mais tolerante - ele alinha pelo nome e preenche as lacunas com NA.

A Explosão de Chaves Duplicadas

O acidente clássico de join: chaves que você acreditava serem únicas, mas não são - nas duas tabelas. Cada correspondência se emparelha com cada correspondência, multiplicando as linhas:

a <- data.frame(id = c(1, 1), x = c("a1", "a2"))
b <- data.frame(id = c(1, 1), y = c("b1", "b2"))

merged <- merge(a, b, by = "id")
print(merged)
cat("rows:", nrow(merged), "\n")

Duas linhas juntadas com duas linhas rendem quatro - cada x pareado com cada y. Em dados reais, é assim que uma tabela de 10.000 linhas vira 3 milhões de linhas e um faturamento total dobrado. merge() faz isso em silêncio. A defesa é um hábito: antes de fazer o join, verifique a chave que você assume ser única - anyDuplicated(customers$id) deve ser 0 - e depois do join, confira nrow() contra o que você esperava.

O Que Você Leva

• merge(x, y, by = "key") é um inner join - linhas sem correspondência desaparecem silenciosamente.
• all.x = TRUE (left), all.y = TRUE (right), all = TRUE (full) mantêm as linhas sem correspondência, preenchendo com NA.
• Chaves com nomes diferentes: by.x / by.y no base, by = c("a" = "b") no dplyr.
• O dplyr nomeia cada join; anti_join() - as linhas que não corresponderam - é o subestimado.
• rbind() empilha tabelas de mesmo formato; as colunas precisam casar pelo nome.
• Chaves duplicadas multiplicam linhas em silêncio - verifique anyDuplicated() antes, nrow() depois.

A seguir: remodelando entre os formatos wide e long com pivot_longer() e pivot_wider().