R Academy · Aula

Junções de várias tabelas no dplyr

Domine inner_join, left_join, right_join, full_join e anti_join.

Junções de várias tabelas no dplyr é uma aula grátis de R Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de R Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de R Academy inclui 4 aulas no total.

Por que unir tabelas?

Dados reais raramente ficam em uma única tabela. Bancos de dados relacionais dividem as informações entre várias tabelas para evitar repetição. As junções permitem combinar tabelas com base em chaves compartilhadas. O dplyr fornece funções de junção no estilo SQL, com uma sintaxe clara e legível.

library(dplyr)

# Two related tables
orders <- data.frame(
  order_id = 1:4,
  customer_id = c(1, 2, 1, 3),
  amount = c(250, 180, 320, 90)
)

customers <- data.frame(
  customer_id = 1:3,
  name = c('Alice','Bob','Carol'),
  city = c('NYC','LA','Chicago')
)

print(orders)
print(customers)

inner_join() — Somente linhas correspondentes

inner_join(x, y, by='key') retorna apenas as linhas em que a chave existe em ambas as tabelas. As linhas sem correspondência na outra tabela são descartadas. Esse é o tipo de junção mais comum.

library(dplyr)

orders <- data.frame(
  order_id = 1:4,
  customer_id = c(1, 2, 1, 99),
  amount = c(250, 180, 320, 90)
)

customers <- data.frame(
  customer_id = c(1, 2, 3),
  name = c('Alice','Bob','Carol')
)

# customer_id = 99 in orders has no match => dropped
# customer_id = 3 in customers has no match => dropped
inner_join(orders, customers, by = 'customer_id')

left_join() — Manter todas as linhas da esquerda

left_join(x, y, by='key') mantém todas as linhas de x e preenche os dados correspondentes de y. As linhas de x sem correspondência em y recebem NA nas colunas de y. A tabela da esquerda determina o resultado.

library(dplyr)

orders <- data.frame(
  order_id = 1:4,
  customer_id = c(1, 2, 1, 99),
  amount = c(250, 180, 320, 90)
)

customers <- data.frame(
  customer_id = c(1, 2, 3),
  name = c('Alice','Bob','Carol')
)

# Order with customer_id=99 is kept, name = NA
left_join(orders, customers, by = 'customer_id')

right_join() — Manter todas as linhas da direita

right_join(x, y, by='key') mantém todas as linhas de y. As linhas de y sem correspondência em x recebem NA nas colunas de x. É o espelho de left_join() — é menos comum, pois é possível trocar a ordem das tabelas.

library(dplyr)

orders <- data.frame(
  order_id = c(1, 2),
  customer_id = c(1, 2),
  amount = c(250, 180)
)

customers <- data.frame(
  customer_id = c(1, 2, 3),
  name = c('Alice','Bob','Carol')
)

# Carol (customer_id=3) has no orders => NA for order columns
right_join(orders, customers, by = 'customer_id')

full_join() — Manter todas as linhas

full_join(x, y, by='key') mantém todas as linhas das duas tabelas. As linhas sem correspondência de qualquer um dos lados recebem NA nas colunas da outra tabela. Use essa função quando não puder perder nenhum dado.

library(dplyr)

q1 <- data.frame(product = c('A','B','C'), q1_sales = c(100, 200, 150))
q2 <- data.frame(product = c('A','C','D'), q2_sales = c(120, 160, 90))

# D appears only in q2, B only in q1 => both kept
full_join(q1, q2, by = 'product')

anti_join() — Encontrar não correspondências

anti_join(x, y, by='key') retorna as linhas de x que não têm correspondência em y. Nenhuma coluna de y é incluída. É ideal para encontrar registros órfãos, pedidos sem correspondência ou itens ausentes em uma tabela de referência.

library(dplyr)

all_employees <- data.frame(
  id = 1:5,
  name = c('Alice','Bob','Carol','Dave','Eve')
)

trained <- data.frame(id = c(1, 3, 5))

# Who has NOT completed training?
anti_join(all_employees, trained, by = 'id')

semi_join() — Filtrar por correspondência

semi_join(x, y, by='key') retorna as linhas de x que têm uma correspondência em y, mas NÃO adiciona as colunas de y. É semelhante a inner_join(), mas retorna apenas as colunas de x — útil como etapa de filtragem.

library(dplyr)

products <- data.frame(
  id = 1:5,
  name = c('Widget','Gadget','Donut','Gizmo','Sprocket'),
  price = c(9.99, 24.99, 1.99, 14.99, 4.99)
)

ordered_products <- data.frame(id = c(1, 3, 5))

# Products that appear in at least one order
semi_join(products, ordered_products, by = 'id')

Unir tabelas com nomes de colunas diferentes

Quando as colunas de chave têm nomes diferentes em x e y, use a sintaxe by = c('x_col' = 'y_col'). Ela associa o nome da coluna da tabela da esquerda à coluna correspondente da tabela da direita.

library(dplyr)

orders <- data.frame(
  order_id = 1:3,
  user_id = c(10, 20, 10),
  amount = c(100, 200, 150)
)

users <- data.frame(
  id = c(10, 20, 30),
  username = c('alice','bob','carol')
)

# orders.user_id matches users.id
left_join(orders, users, by = c('user_id' = 'id'))

Unir tabelas por várias chaves

Você pode fazer a junção por várias colunas passando um vetor para by. Todas as colunas especificadas precisam corresponder para que uma linha seja incluída na junção. Isso trata chaves compostas, nos casos em que nenhuma coluna isolada é exclusiva.

library(dplyr)

actual <- data.frame(
  year = c(2023, 2023, 2024, 2024),
  quarter = c('Q1','Q2','Q1','Q2'),
  sales = c(100, 120, 130, 150)
)

target <- data.frame(
  year = c(2023, 2023, 2024, 2024),
  quarter = c('Q1','Q2','Q1','Q2'),
  target = c(110, 115, 125, 145)
)

inner_join(actual, target, by = c('year', 'quarter'))

Encadear várias junções

Você pode encadear várias junções em um único pipeline usando o operador de pipe. Construa uma visualização desnormalizada adicionando, uma etapa de cada vez, informações de várias tabelas de consulta.

library(dplyr)

orders <- data.frame(order_id=1:3, cust_id=c(1,2,1), prod_id=c(10,10,20))
customers <- data.frame(cust_id=1:2, name=c('Alice','Bob'))
products <- data.frame(prod_id=c(10,20), product=c('Widget','Gadget'))

orders %>%
  left_join(customers, by = 'cust_id') %>%
  left_join(products, by = 'prod_id')

Tratar colunas duplicadas

Quando as duas tabelas têm colunas com o mesmo nome (além da chave de junção), o dplyr adiciona os sufixos .x e .y. Você pode personalizá-los com o argumento suffix e, depois, selecionar ou renomear as colunas conforme necessário.

library(dplyr)

current <- data.frame(id=1:3, value=c(10,20,30), date=Sys.Date())
historic <- data.frame(id=1:3, value=c(8,22,28), date=Sys.Date()-365)

# Both have 'value' and 'date' columns
result <- inner_join(current, historic, by='id',
                     suffix=c('_current','_historic'))
print(names(result))

Verificação rápida

Qual junção do dplyr retorna apenas as linhas da tabela da esquerda que não têm uma linha correspondente na tabela da direita?

Recapitulação: junções do dplyr

Principais pontos sobre junções de várias tabelas no dplyr:

inner_join() — apenas linhas correspondentes das duas tabelas
left_join() — todas as linhas da esquerda; NA quando não há correspondência na direita
right_join() — todas as linhas da direita; NA quando não há correspondência na esquerda
full_join() — todas as linhas das duas tabelas; NA quando não há correspondência
anti_join() — linhas de x SEM correspondência em y (ferramenta de filtragem)
semi_join() — linhas de x COM correspondência em y (ferramenta de filtragem)
Use by = c('x_col' = 'y_col') para nomes de colunas diferentes
Use um vetor para chaves compostas: by = c('year', 'quarter')

library(dplyr)

# Chain of joins: the typical real-world pattern
orders <- data.frame(oid=1:3, cid=c(1,2,1), pid=c(10,20,10))
customers <- data.frame(cid=1:2, name=c('Alice','Bob'))
products <- data.frame(pid=c(10,20), name=c('Widget','Gadget'), price=c(9.99,19.99))

orders %>%
  inner_join(customers, by='cid') %>%
  inner_join(products, by='pid', suffix=c('','_product')) %>%
  select(oid, name, name_product, price)

Perguntas Frequentes

A aula “Junções de várias tabelas no dplyr” é grátis?

Sim — o texto completo de “Junções de várias tabelas no dplyr” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de R Academy, atualize para CoddyKit PRO. O curso de R Academy inclui 4 aulas no total.

O que vou aprender em “Junções de várias tabelas no dplyr”?

Domine inner_join, left_join, right_join, full_join e anti_join. Você pratica R Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar R Academy?

Nenhuma experiência prévia é necessária. R Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Junções de várias tabelas no dplyr”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de R Academy?

Sim. Cada aula de R Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para R Academy