8  Dados organizados e combinação de tabelas

Pré-requisitos: Capítulo 7 · Pacotes: tidyr e dplyr (carregados com o tidyverse), readxl, here

Objetivos de aprendizagem

Ao final deste capítulo, espera-se que o estudante seja capaz de explicar o que são dados organizados (tidy data); converter tabelas entre os formatos longo e largo e reconhecer quando cada um é útil; separar e unir colunas; empilhar tabelas com a mesma estrutura; combinar tabelas por meio de chaves, escolhendo o tipo de junção adequado; conferir o resultado de uma junção; e reconhecer problemas de chaves comuns nos dados de saúde brasileiros.

Até aqui, cada análise usou uma única tabela. Mas muitos indicadores de saúde exigem informações que estão em fontes diferentes. A taxa de natalidade, por exemplo, precisa do número de nascidos vivos, que vem do SINASC, e da população, que vem das estimativas populacionais. Para combinar essas fontes, as tabelas precisam estar bem organizadas e precisam ter uma coluna em comum. Este capítulo trata das duas coisas.

library(tidyverse)
library(readxl)
library(here)
source(here("scripts", "preparar-sinasc.R"))

8.1 O que são dados organizados

Os mesmos dados podem ser dispostos em uma tabela de várias formas. Observe a planilha com a população dos municípios de Rondônia, importada no Capítulo 5.

populacao_anos <- read_excel(here("dados", "populacao_ro_2015_2024.xlsx"))
populacao_anos
#> # A tibble: 52 × 12
#>    cod_municipio municipio      `2015` `2016` `2017` `2018` `2019` `2020` `2021`
#>    <chr>         <chr>           <dbl>  <dbl>  <dbl>  <dbl>  <dbl>  <dbl>  <dbl>
#>  1 1100015       Alta Floresta…  24540  24396  24238  24068  23910  23752  23546
#>  2 1100379       Alto Alegre d…  12983  12927  12864  12790  12723  12658  12569
#>  3 1100403       Alto Paraíso    17696  17712  17718  17704  17697  17680  17640
#>  4 1100346       Alvorada D'Oe…  16223  15964  15699  15436  15187  14938  14657
#>  5 1100023       Ariquemes       98956 100316 101559 102718 103895 105044 105986
#>  6 1100452       Buritis         32969  32810  32606  32368  32152  31915  31633
#>  7 1100031       Cabixi           6293   6235   6186   6117   6059   5995   5922
#>  8 1100601       Cacaulândia      5347   5218   5090   4967   4854   4745   4620
#>  9 1100049       Cacoal          86910  88323  89662  90912  92203  93443  94502
#> 10 1100700       Campo Novo de…  11709  11412  11110  10805  10514  10241   9952
#> # ℹ 42 more rows
#> # ℹ 3 more variables: `2022` <dbl>, `2023` <dbl>, `2024` <dbl>

Cada linha é um município, e cada ano está em uma coluna. É um formato confortável para ler na tela, mas pouco prático para analisar. Como calcular, por exemplo, a população média de cada município no período, ou fazer um gráfico da população ao longo do tempo? A informação “ano” está espalhada nos nomes das colunas, e não em uma variável.

O conceito de dados organizados (tidy data), formalizado por WICKHAM (2014), propõe três regras simples. Cada variável fica em uma coluna. Cada observação fica em uma linha. Cada valor fica em uma célula. Na planilha acima, há três variáveis (município, ano e população), mas o ano não ocupa uma coluna própria. Organizá-la significa transformá-la em uma tabela com uma linha para cada combinação de município e ano. As ferramentas do tidyverse, incluindo o ggplot2, foram pensadas para trabalhar com dados nesse formato.

8.2 Do formato largo para o longo

A função pivot_longer(), do pacote tidyr, transforma colunas em linhas. Ela precisa de três informações: quais colunas serão empilhadas (cols), o nome da nova coluna que vai receber os antigos nomes de coluna (names_to) e o nome da coluna que vai receber os valores (values_to).

populacao_longa <- populacao_anos |>
  pivot_longer(
    cols = `2015`:`2024`,
    names_to = "ano",
    values_to = "populacao"
  )
populacao_longa
#> # A tibble: 520 × 4
#>    cod_municipio municipio             ano   populacao
#>    <chr>         <chr>                 <chr>     <dbl>
#>  1 1100015       Alta Floresta D'Oeste 2015      24540
#>  2 1100015       Alta Floresta D'Oeste 2016      24396
#>  3 1100015       Alta Floresta D'Oeste 2017      24238
#>  4 1100015       Alta Floresta D'Oeste 2018      24068
#>  5 1100015       Alta Floresta D'Oeste 2019      23910
#>  6 1100015       Alta Floresta D'Oeste 2020      23752
#>  7 1100015       Alta Floresta D'Oeste 2021      23546
#>  8 1100015       Alta Floresta D'Oeste 2022      23309
#>  9 1100015       Alta Floresta D'Oeste 2023      23081
#> 10 1100015       Alta Floresta D'Oeste 2024      22853
#> # ℹ 510 more rows

Os nomes das colunas começam com números, e por isso foram escritos entre crases. A tabela passou de 52 linhas e 12 colunas para 520 linhas e 4 colunas, uma para cada município em cada ano. Repare, porém, que a nova coluna ano é do tipo texto, porque veio dos nomes das colunas. O argumento names_transform converte o tipo no próprio pivot_longer().

populacao_longa <- populacao_anos |>
  pivot_longer(
    cols = `2015`:`2024`,
    names_to = "ano",
    values_to = "populacao",
    names_transform = list(ano = as.integer)
  )

Com os dados organizados, perguntas que antes eram difíceis ficam simples. Por exemplo, a variação percentual da população de cada município entre 2015 e 2024.

populacao_longa |>
  group_by(municipio) |>
  summarise(
    pop_2015 = populacao[ano == 2015],
    pop_2024 = populacao[ano == 2024],
    variacao_perc = (pop_2024 / pop_2015 - 1) * 100
  ) |>
  arrange(desc(variacao_perc)) |>
  head(5)
#> # A tibble: 5 × 4
#>   municipio          pop_2015 pop_2024 variacao_perc
#>   <chr>                 <dbl>    <dbl>         <dbl>
#> 1 Vilhena               88151   108528          23.1
#> 2 Nova Mamoré           25003    28496          14.0
#> 3 Cacoal                86910    97637          12.3
#> 4 Rolim de Moura        55815    62559          12.1
#> 5 Candeias do Jamari    21769    24163          11.0

8.3 Do formato longo para o largo

O caminho inverso é feito com pivot_wider(), que espalha os valores de uma coluna em várias colunas. Ele é usado principalmente para montar tabelas de apresentação, que ficam mais fáceis de ler no formato largo. Os argumentos principais são names_from, a coluna cujos valores viram nomes de colunas, e values_from, a coluna cujos valores preenchem a tabela.

nascidos |>
  filter(!is.na(parto)) |>
  count(faixa_idade_mae, parto) |>
  pivot_wider(names_from = parto, values_from = n)
#> # A tibble: 3 × 3
#>   faixa_idade_mae Vaginal Cesáreo
#>   <fct>             <int>   <int>
#> 1 Menos de 20        2192    2359
#> 2 20 a 34            6062   13234
#> 3 35 ou mais          689    2443

O resultado é uma tabela de dupla entrada, com as faixas de idade nas linhas e os tipos de parto nas colunas. Quando alguma combinação não existe nos dados, a célula correspondente fica com NA; o argumento values_fill = 0 permite preenchê-la com zero, o que costuma ser o correto para contagens.

8.4 Separando e unindo colunas

As tabelas exportadas pelo TabNet trazem o código e o nome do município em uma única coluna, como 110001 Alta Floresta D'Oeste. Para combinar essa tabela com outras, precisamos do código em uma coluna própria. A função separate_wider_delim() divide uma coluna em várias a partir de um delimitador.

populacao_sexo <- read_csv2(
  here("dados", "tabnet_populacao_ro_2019.csv"),
  locale = locale(encoding = "latin1"),
  skip = 4, n_max = 52
)

populacao_sexo <- populacao_sexo |>
  separate_wider_delim(
    cols = Município,
    delim = " ",
    names = c("codigo", "nome"),
    too_many = "merge"
  )
populacao_sexo
#> # A tibble: 52 × 5
#>    codigo nome                  Masculino Feminino  Total
#>    <chr>  <chr>                     <dbl>    <dbl>  <dbl>
#>  1 110001 Alta Floresta D'Oeste     12239    11671  23910
#>  2 110002 Ariquemes                 52140    51755 103895
#>  3 110003 Cabixi                     3091     2968   6059
#>  4 110004 Cacoal                    45744    46459  92203
#>  5 110005 Cerejeiras                 8662     8622  17284
#>  6 110006 Colorado do Oeste          8881     8821  17702
#>  7 110007 Corumbiara                 4436     3976   8412
#>  8 110008 Costa Marques              7335     6646  13981
#>  9 110009 Espigão D'Oeste           16246    15764  32010
#> 10 110010 Guajará-Mirim             22176    21665  43841
#> # ℹ 42 more rows

O delimitador é o espaço. Como os nomes dos municípios também têm espaços, usamos too_many = "merge", que divide a coluna apenas no primeiro espaço e mantém o resto junto. A operação inversa, juntar colunas em uma só, é feita com unite().

8.5 Empilhando tabelas

Quando duas tabelas têm as mesmas colunas e queremos colocar uma embaixo da outra, usamos bind_rows(). É o que acontece, por exemplo, quando os dados de cada ano ou de cada estado chegam em arquivos separados. O argumento .id cria uma coluna que identifica a origem de cada linha.

populacao <- read_csv(here("dados", "populacao_ro_2019.csv"),
                      col_types = cols(cod_municipio = col_character()))

feminina <- populacao |> filter(sexo == "Feminino") |> select(-sexo)
masculina <- populacao |> filter(sexo == "Masculino") |> select(-sexo)

bind_rows(Feminino = feminina, Masculino = masculina, .id = "sexo") |>
  count(sexo)
#> # A tibble: 2 × 2
#>   sexo          n
#>   <chr>     <int>
#> 1 Feminino    884
#> 2 Masculino   884

O exemplo é um pouco artificial, porque separamos uma tabela só para juntá-la de novo, mas mostra a lógica. As colunas são combinadas pelo nome, de modo que a ordem delas em cada tabela não importa.

8.6 Combinando tabelas por chaves

Chaves

Para combinar duas tabelas lado a lado, precisamos de uma ou mais colunas que identifiquem, nas duas tabelas, a mesma unidade. Essas colunas são chamadas de chaves. Em dados de saúde, as chaves mais comuns são o código do município, o código do estabelecimento de saúde e, em bases com identificação, o número do registro. Uma boa chave identifica cada linha de forma única em pelo menos uma das tabelas.

Vamos preparar as duas tabelas que queremos combinar. A primeira tem o número de nascidos vivos por município, calculado a partir do SINASC.

nv_municipio <- nascidos |>
  count(codmunres, munresnome, name = "nascidos_vivos")
nv_municipio
#> # A tibble: 53 × 3
#>    codmunres munresnome              nascidos_vivos
#>    <chr>     <chr>                            <int>
#>  1 110000    Município ignorado - RO              1
#>  2 110001    Alta Floresta D'Oeste              367
#>  3 110002    Ariquemes                         1729
#>  4 110003    Cabixi                              80
#>  5 110004    Cacoal                            1374
#>  6 110005    Cerejeiras                         237
#>  7 110006    Colorado do Oeste                  214
#>  8 110007    Corumbiara                         127
#>  9 110008    Costa Marques                      233
#> 10 110009    Espigão D'Oeste                    450
#> # ℹ 43 more rows

A segunda tem a população total e a população feminina de 15 a 49 anos de cada município, calculadas a partir das estimativas populacionais.

pop_municipio <- populacao |>
  group_by(cod_municipio) |>
  summarise(
    mulheres_15_49 = sum(populacao[sexo == "Feminino" &
                                   faixa_etaria %in% c("15 a 19 anos", "20 a 24 anos",
                                                       "25 a 29 anos", "30 a 34 anos",
                                                       "35 a 39 anos", "40 a 44 anos",
                                                       "45 a 49 anos")]),
    populacao = sum(populacao)
  )
pop_municipio
#> # A tibble: 52 × 3
#>    cod_municipio mulheres_15_49 populacao
#>    <chr>                  <dbl>     <dbl>
#>  1 1100015                 6374     23910
#>  2 1100023                29807    103895
#>  3 1100031                 1453      6059
#>  4 1100049                26391     92203
#>  5 1100056                 4661     17284
#>  6 1100064                 4627     17702
#>  7 1100072                 2198      8412
#>  8 1100080                 3600     13981
#>  9 1100098                 8755     32010
#> 10 1100106                11465     43841
#> # ℹ 42 more rows

A ordem das duas linhas dentro do summarise() não é um detalhe. As medidas são calculadas em sequência, e uma medida criada pode ser usada pelas seguintes. Se populacao = sum(populacao) viesse primeiro, a coluna populacao seria substituída pelo total do município, e o cálculo das mulheres de 15 a 49 anos passaria a usar esse total, e não os valores por sexo e faixa etária. O resultado estaria errado sem nenhum aviso. Por isso, quando uma medida reutiliza o nome de uma coluna, ela deve vir por último, ou receber outro nome, como pop_total.

Tipos de junção

O dplyr oferece quatro funções de junção que acrescentam colunas de uma tabela a outra. Elas diferem no que fazem com as linhas que não encontram correspondência.

Tabela 8.1: Junções de mutação do dplyr.
Função Linhas mantidas
left_join(x, y) Todas as linhas de x; as de y que não encontram par são descartadas
right_join(x, y) Todas as linhas de y; as de x sem par são descartadas
inner_join(x, y) Apenas as linhas que existem nas duas tabelas
full_join(x, y) Todas as linhas das duas tabelas

A mais usada é left_join(), porque preserva a tabela principal da análise. As colunas que servem de chave são informadas no argumento by, com a função join_by(). Quando as chaves têm nomes diferentes nas duas tabelas, a correspondência é escrita com ==.

Vamos tentar combinar as duas tabelas.

nv_municipio |>
  left_join(pop_municipio, by = join_by(codmunres == cod_municipio))
#> # A tibble: 53 × 5
#>    codmunres munresnome              nascidos_vivos mulheres_15_49 populacao
#>    <chr>     <chr>                            <int>          <dbl>     <dbl>
#>  1 110000    Município ignorado - RO              1             NA        NA
#>  2 110001    Alta Floresta D'Oeste              367             NA        NA
#>  3 110002    Ariquemes                         1729             NA        NA
#>  4 110003    Cabixi                              80             NA        NA
#>  5 110004    Cacoal                            1374             NA        NA
#>  6 110005    Cerejeiras                         237             NA        NA
#>  7 110006    Colorado do Oeste                  214             NA        NA
#>  8 110007    Corumbiara                         127             NA        NA
#>  9 110008    Costa Marques                      233             NA        NA
#> 10 110009    Espigão D'Oeste                    450             NA        NA
#> # ℹ 43 more rows

A junção foi feita, mas a população veio toda como NA. Nenhum município encontrou correspondência. O motivo está na próxima seção.

8.7 Chaves em dados de saúde no Brasil

Compare os códigos das duas tabelas.

head(nv_municipio$codmunres, 3)
#> [1] "110000" "110001" "110002"
head(pop_municipio$cod_municipio, 3)
#> [1] "1100015" "1100023" "1100031"

O SINASC usa o código do município com seis dígitos, enquanto as estimativas populacionais usam o código com sete dígitos, definido pelo IBGE. O sétimo dígito é um dígito verificador. Essa diferença é uma das armadilhas mais comuns na combinação de bases de saúde brasileiras: muitos arquivos do DATASUS usam o código de seis dígitos, e a maior parte das bases do IBGE usa o de sete. A solução é criar, na tabela de população, uma coluna com os seis primeiros dígitos, usando str_sub() do pacote stringr (que será apresentado no Capítulo 9).

pop_municipio <- pop_municipio |>
  mutate(codmun6 = str_sub(cod_municipio, start = 1, end = 6))

indicadores <- nv_municipio |>
  left_join(pop_municipio, by = join_by(codmunres == codmun6))
indicadores
#> # A tibble: 53 × 6
#>    codmunres munresnome    nascidos_vivos cod_municipio mulheres_15_49 populacao
#>    <chr>     <chr>                  <int> <chr>                  <dbl>     <dbl>
#>  1 110000    Município ig…              1 <NA>                      NA        NA
#>  2 110001    Alta Florest…            367 1100015                 6374     23910
#>  3 110002    Ariquemes               1729 1100023                29807    103895
#>  4 110003    Cabixi                    80 1100031                 1453      6059
#>  5 110004    Cacoal                  1374 1100049                26391     92203
#>  6 110005    Cerejeiras               237 1100056                 4661     17284
#>  7 110006    Colorado do …            214 1100064                 4627     17702
#>  8 110007    Corumbiara               127 1100072                 2198      8412
#>  9 110008    Costa Marques            233 1100080                 3600     13981
#> 10 110009    Espigão D'Oe…            450 1100098                 8755     32010
#> # ℹ 43 more rows

Agora a combinação funcionou. Outros problemas frequentes com chaves são a diferença de tipo (o código guardado como número em uma tabela e como texto na outra, o que faz o dplyr interromper a junção com um erro) e o uso de nomes como chave. Nomes de municípios não devem ser usados para combinar tabelas, porque a grafia varia entre fontes, com e sem acentos, com abreviações ou com apóstrofos diferentes, como em “Alta Floresta D’Oeste”.

Conferindo o resultado de uma junção

Toda junção deve ser conferida. Três perguntas ajudam. O número de linhas mudou? Se a tabela de destino tem mais linhas depois da junção, alguma chave estava repetida na outra tabela, e os registros foram duplicados. Há linhas sem correspondência? E, se há, por quê?

As junções de filtragem ajudam a responder à segunda pergunta. A função anti_join() devolve as linhas da primeira tabela que não têm par na segunda, e semi_join() devolve as que têm.

nrow(nv_municipio)
#> [1] 53
nrow(indicadores)
#> [1] 53

nv_municipio |>
  anti_join(pop_municipio, by = join_by(codmunres == codmun6))
#> # A tibble: 1 × 3
#>   codmunres munresnome              nascidos_vivos
#>   <chr>     <chr>                            <int>
#> 1 110000    Município ignorado - RO              1

O número de linhas se manteve, e apenas um registro ficou sem correspondência: o código 110000, de residência ignorada, que de fato não tem população associada. A junção está correta.

8.8 Estudo de caso: natalidade e fecundidade nos municípios de Rondônia

Com as duas tabelas combinadas, podemos calcular dois indicadores demográficos clássicos. A taxa bruta de natalidade é o número de nascidos vivos dividido pela população total, multiplicado por mil. A taxa de fecundidade geral é o número de nascidos vivos dividido pelo número de mulheres de 15 a 49 anos, também multiplicado por mil. A segunda é mais específica, porque relaciona os nascimentos apenas às mulheres em idade reprodutiva.

indicadores <- indicadores |>
  filter(codmunres != "110000") |>
  mutate(
    taxa_natalidade = nascidos_vivos / populacao * 1000,
    taxa_fecundidade_geral = nascidos_vivos / mulheres_15_49 * 1000
  )

indicadores |>
  select(munresnome, nascidos_vivos, populacao, taxa_natalidade, taxa_fecundidade_geral) |>
  arrange(desc(taxa_fecundidade_geral)) |>
  head(6)
#> # A tibble: 6 × 5
#>   munresnome     nascidos_vivos populacao taxa_natalidade taxa_fecundidade_geral
#>   <chr>                   <int>     <dbl>           <dbl>                  <dbl>
#> 1 Guajará-Mirim             781     43841            17.8                   68.1
#> 2 Pimenteiras d…             40      2346            17.1                   67.1
#> 3 Buritis                   583     32152            18.1                   66.3
#> 4 Costa Marques             233     13981            16.7                   64.7
#> 5 São Francisco…            303     17379            17.4                   64.2
#> 6 Campo Novo de…            166     10514            15.8                   62.3

Para o estado como um todo, somamos numeradores e denominadores, como aprendemos no capítulo anterior. Os nascimentos com residência ignorada são de mães residentes em Rondônia e, por isso, entram no numerador estadual.

tibble(
  nascidos_vivos = nrow(nascidos),
  populacao = sum(pop_municipio$populacao),
  mulheres_15_49 = sum(pop_municipio$mulheres_15_49)
) |>
  mutate(
    taxa_natalidade = nascidos_vivos / populacao * 1000,
    taxa_fecundidade_geral = nascidos_vivos / mulheres_15_49 * 1000
  )
#> # A tibble: 1 × 5
#>   nascidos_vivos populacao mulheres_15_49 taxa_natalidade taxa_fecundidade_geral
#>            <int>     <dbl>          <dbl>           <dbl>                  <dbl>
#> 1          27028   1712560         475419            15.8                   56.9

Por fim, uma tabela de apresentação dos municípios mais populosos, com os indicadores arredondados.

indicadores |>
  slice_max(populacao, n = 5) |>
  transmute(
    Município = munresnome,
    `Nascidos vivos` = nascidos_vivos,
    `Taxa de natalidade (por mil hab.)` = round(taxa_natalidade, 1),
    `Taxa de fecundidade geral (por mil mulheres de 15 a 49 anos)` = round(taxa_fecundidade_geral, 1)
  ) |>
  knitr::kable()
Município Nascidos vivos Taxa de natalidade (por mil hab.) Taxa de fecundidade geral (por mil mulheres de 15 a 49 anos)
Porto Velho 8437 17.1 59.4
Ji-Paraná 2182 16.3 57.6
Ariquemes 1729 16.6 58.0
Vilhena 1590 16.2 56.3
Cacoal 1374 14.9 52.1

A função transmute() funciona como mutate(), mas mantém apenas as colunas criadas. Os nomes entre crases permitem usar espaços e acentos nos títulos das colunas, o que é aceitável em tabelas de apresentação, mas deve ser evitado nas colunas usadas para análise.

Saúde Pública em foco

A qualidade de um indicador depende da qualidade do numerador e do denominador. Onde parte dos nascimentos não é registrada no SINASC, as taxas calculadas diretamente dos dados subestimam a realidade, e por isso a cobertura do sistema em cada local deve ser considerada antes de comparar indicadores. As estimativas populacionais, por sua vez, são projeções revisadas periodicamente, sobretudo depois de cada censo. Ao comparar indicadores de anos diferentes, convém verificar se as populações usadas vêm da mesma série de estimativas.

8.9 Exercícios

Fixação

  1. Transforme a tabela populacao_anos para o formato longo e calcule a população total de Rondônia em cada ano.

  2. A partir da base nascidos, construa uma tabela com o número de nascimentos por mês (nas linhas) e por sexo (nas colunas), usando count() e pivot_wider().

  3. Use anti_join() para listar os municípios da tabela de população que não aparecem na tabela de nascidos vivos. Há algum? Interprete o resultado.

Aplicação

  1. Combine a tabela indicadores_municipio, construída no Capítulo 7 (com a proporção de baixo peso por município), com a tabela de população, e verifique se os municípios mais populosos têm proporções de baixo peso maiores ou menores que os demais.

  2. Usando a tabela de população por faixa etária, calcule para cada município a proporção da população com 60 anos ou mais. Combine essa informação com a taxa de natalidade e descreva a relação entre os dois indicadores.

Desafio

  1. Em seu computador, obtenha os óbitos de residentes em Rondônia em 2019 com o microdatasus ou com o healthbR, conforme o código abaixo. Selecione os óbitos de menores de um ano, conte-os por município de residência, combine com os nascidos vivos e calcule a taxa de mortalidade infantil por mil nascidos vivos. Discuta os problemas de instabilidade nos municípios pequenos.
library(microdatasus)
sim_bruto <- fetch_datasus(year_start = 2019, year_end = 2019,
                           uf = "RO", information_system = "SIM-DO")
sim <- process_sim(sim_bruto)
# As variáveis IDADEminutos, IDADEhoras, IDADEdias, IDADEmeses e IDADEanos,
# criadas por process_sim(), permitem identificar os menores de um ano.
  1. Explique por que uma junção pode aumentar o número de linhas da tabela de destino. Construa um pequeno exemplo, com duas tabelas fictícias, em que isso acontece, e mostre como identificar o problema.

8.10 Síntese

Dados organizados seguem três regras: cada variável em uma coluna, cada observação em uma linha e cada valor em uma célula. A função pivot_longer() transforma tabelas largas, com variáveis espalhadas nos nomes das colunas, em tabelas longas, adequadas à análise; pivot_wider() faz o caminho inverso, útil para tabelas de apresentação. A função separate_wider_delim() divide uma coluna em várias, e bind_rows() empilha tabelas. As junções combinam tabelas por meio de chaves: left_join(), inner_join(), right_join() e full_join() acrescentam colunas, enquanto semi_join() e anti_join() filtram linhas. No Brasil, a diferença entre o código de município com seis dígitos, usado pelo DATASUS, e com sete dígitos, usado pelo IBGE, é a armadilha mais comum. Toda junção deve ser conferida quanto ao número de linhas e às linhas sem correspondência.

Tabela 8.2: Funções apresentadas no capítulo.
Função Pacote Finalidade
pivot_longer(), pivot_wider() tidyr Converter entre os formatos longo e largo
separate_wider_delim(), unite() tidyr Separar e unir colunas
bind_rows() dplyr Empilhar tabelas
left_join(), right_join(), inner_join(), full_join() dplyr Junções de mutação
semi_join(), anti_join() dplyr Junções de filtragem
join_by() dplyr Especificar as chaves da junção
transmute() dplyr Criar colunas mantendo apenas as novas
str_sub() stringr Extrair parte de um texto

8.11 Para saber mais

O artigo de WICKHAM (2014) é a referência original sobre dados organizados e continua sendo uma leitura clara e útil. O capítulo 5 do R para Ciência de Dados (WICKHAM; ÇETINKAYA-RUNDEL; GROLEMUND, 2023) trata da reorganização de tabelas, e o capítulo 19, das junções, com uma explicação visual de como cada tipo funciona. O Manual de R para Epidemiologistas (BATRA et al., 2021) dedica o capítulo 12 à pivotagem e o capítulo 14 às junções, com exemplos de vigilância. Faria (FARIA, 2024) trata das bases relacionais no capítulo 6 e dos dados organizados no capítulo 7.

Obra Capítulo Seções de interesse
R para Ciência de Dados (WICKHAM; ÇETINKAYA-RUNDEL; GROLEMUND, 2023) 5. Organização de dados; 19. Uniões Dados organizados; Alongando os dados; Chaves; Uniões básicas
Manual de R para Epidemiologistas (BATRA et al., 2021) 12. Pivoteando dados; 14. Juntando dados Largo-para-longo; Longo-para-largo; Joins com dplyr; Anexando (binding)
Introdução à Linguagem R (FARIA, 2024) 6. Introdução a base de dados relacionais com dplyr; 7. Tidy Data Dados relacionais e o conceito de key; Diferentes tipos de join; Operações de pivô
Artigo de referência WICKHAM (2014) —