5. Do SQL para o R com dbplyr

Traduza suas queries SQL para o universo tidyverse

☕ Assine o Café com R

Fique por dentro das aulas, conteúdos, newsletter!

Que cada gole desperte uma nova ideia.

Que cada script abra uma nova conversa.

Que o Café com R, se torne um ponto de encontro nosso!

Bem-vindo ao mundo do dbplyr!

Se você já sabe SQL e está começando com R, esta apresentação é para você!

O que você vai aprender hoje

O que é dbplyr e por que ele é incrível
Como conectar R a bancos de dados
Traduzir SELECT, WHERE, JOIN e muito mais
Trabalhar com dados sem carregar tudo na memória
Exemplos práticos que você pode testar agora

Spoiler: Você vai escrever código R que gera SQL automaticamente! 🎉

O que é dbplyr?

dbplyr é um pacote que traduz código dplyr (R) para SQL.

Por que isso é fantástico:

Escreva em R, execute em SQL
Trabalhe com milhões de linhas sem travamentos
Use a sintaxe tidyverse que você ama
Funciona com vários bancos de dados (PostgreSQL, MySQL, SQLite, etc)
O R só traz para memória o que você realmente precisa

Dica inicial

“Pense em R, execute em SQL, aprenda os dois!”

A cada query você escreve, está praticando DUAS linguagens ao mesmo tempo!

Imagem: Allison Horst.

SQL x dplyr: A grande comparação

-- Em SQL
SELECT nome, idade 
FROM clientes 
WHERE idade > 18;

Mesma lógica, sintaxe diferente!

Instalando o que você precisa

Primeiro, instale os pacotes necessários:

DBI: Interface com bancos de dados
RSQLite: Para trabalhar com SQLite
dbplyr: O tradutor SQL ↔︎ R
dplyr: Manipulação de dados

Carregando os pacotes

# Carregar pacotes (faz TODA vez)
library(DBI)
library(dplyr)
library(dbplyr)

Lembre-se: Instalar é como baixar o app, carregar é como abrir o app!

Criando um banco de dados de exemplo

Vamos criar um banco SQLite em memória para praticar:

# Criar conexão com banco em memória
con <- dbConnect(RSQLite::SQLite(), ":memory:")

# Criar tabela de clientes
dbWriteTable(con, "clientes", data.frame(
  id = 1:5,
  nome = c("Ana", "Jennifer", "Carla", "Daniel", "Elena"),
  idade = c(25, 33, 22, 35, 28),
  cidade = c("RJ", "SP", "SP", "MG", "RJ")))

Pronto! Agora temos um banco de dados para trabalhar.

Conectando ao banco

Para usar dbplyr, conecte-se à tabela:

# Criar referência à tabela
clientes_db <- tbl(con, "clientes")

# Ver os dados
clientes_db

# Source:   table<`clientes`> [?? x 4]
# Database: sqlite 3.51.2 [:memory:]
     id nome     idade cidade
  <int> <chr>    <dbl> <chr> 
1     1 Ana         25 RJ    
2     2 Jennifer    33 SP    
3     3 Carla       22 SP    
4     4 Daniel      35 MG    
5     5 Elena       28 RJ

Importante: Os dados ainda estão no banco, não na memória do R!

SELECT: Selecionando colunas

SQL:

SELECT nome, idade FROM clientes;

dbplyr (R):

clientes_db |>
  select(nome, idade)

# Source:   SQL [?? x 2]
# Database: sqlite 3.51.2 [:memory:]
  nome     idade
  <chr>    <dbl>
1 Ana         25
2 Jennifer    33
3 Carla       22
4 Daniel      35
5 Elena       28

WHERE: Filtrando linhas

SQL:

SELECT * FROM clientes WHERE idade > 25;

dbplyr (R):

clientes_db |>
  filter(idade > 25)

# Source:   SQL [?? x 4]
# Database: sqlite 3.51.2 [:memory:]
     id nome     idade cidade
  <int> <chr>    <dbl> <chr> 
1     2 Jennifer    33 SP    
2     4 Daniel      35 MG    
3     5 Elena       28 RJ

Operadores de comparação

SQL	R (dplyr)	Significado
`=`	`==`	Igual
`<>` ou `!=`	`!=`	Diferente
`>`	`>`	Maior que
`<`	`<`	Menor que
`>=`	`>=`	Maior ou igual
`<=`	`<=`	Menor ou igual

Atenção: Em R use == para comparação, não =

Combinando filtros com AND

SQL:

SELECT * FROM clientes 
WHERE idade > 25 AND cidade = 'SP';

dbplyr (R):Use & para AND (E)

clientes_db |>
  filter(idade > 25 & cidade == "SP")

# Source:   SQL [?? x 4]
# Database: sqlite 3.51.2 [:memory:]
     id nome     idade cidade
  <int> <chr>    <dbl> <chr> 
1     2 Jennifer    33 SP

Combinando filtros com OR

SQL:

SELECT * FROM clientes 
WHERE cidade = 'SP' OR cidade = 'RJ';

dbplyr (R): Use | para OR (OU)

clientes_db |>
  filter(cidade == "SP" | cidade == "RJ")

# Source:   SQL [?? x 4]
# Database: sqlite 3.51.2 [:memory:]
     id nome     idade cidade
  <int> <chr>    <dbl> <chr> 
1     1 Ana         25 RJ    
2     2 Jennifer    33 SP    
3     3 Carla       22 SP    
4     5 Elena       28 RJ

IN: Valores em uma lista

SQL:

SELECT * FROM clientes 
WHERE cidade IN ('SP', 'RJ');

dbplyr (R):%in% verifica se o valor está no vetor

clientes_db |>
  filter(cidade %in% c("SP", "RJ"))

# Source:   SQL [?? x 4]
# Database: sqlite 3.51.2 [:memory:]
     id nome     idade cidade
  <int> <chr>    <dbl> <chr> 
1     1 Ana         25 RJ    
2     2 Jennifer    33 SP    
3     3 Carla       22 SP    
4     5 Elena       28 RJ

ORDER BY: Ordenando resultados

SQL:

SELECT * FROM clientes ORDER BY idade DESC;

dbplyr (R): Use arrange() para ordenar, desc() para decrescente

clientes_db |>
  arrange(desc(idade))

# Source:     SQL [?? x 4]
# Database:   sqlite 3.51.2 [:memory:]
# Ordered by: desc(idade)
     id nome     idade cidade
  <int> <chr>    <dbl> <chr> 
1     4 Daniel      35 MG    
2     2 Jennifer    33 SP    
3     5 Elena       28 RJ    
4     1 Ana         25 RJ    
5     3 Carla       22 SP

LIMIT: Limitando resultados

SQL:

SELECT * FROM clientes LIMIT 3;

dbplyr (R):

clientes_db |>
  head(3)

# Source:   SQL [?? x 4]
# Database: sqlite 3.51.2 [:memory:]
     id nome     idade cidade
  <int> <chr>    <dbl> <chr> 
1     1 Ana         25 RJ    
2     2 Jennifer    33 SP    
3     3 Carla       22 SP

COUNT: Contando registros

SQL:

SELECT COUNT(*) FROM clientes;

dbplyr (R):

clientes_db |>
  summarise(total = n())

# Source:   SQL [?? x 1]
# Database: sqlite 3.51.2 [:memory:]
  total
  <int>
1     5

n() conta o número de linhas

GROUP BY: Agrupando dados

Vamos criar uma tabela de vendas para exemplos mais interessantes:

dbWriteTable(con, "vendas", data.frame(
  id = 1:8,
  cliente_id = c(1, 2, 1, 3, 2, 1, 4, 5),
  produto = c("A", "B", "A", "C", "B", "C", "A", "B"),
  valor = c(100, 150, 200, 80, 120, 90, 110, 160),
  quantidade = c(2, 1, 3, 1, 2, 1, 2, 1)), overwrite = TRUE)

vendas_db <- tbl(con, "vendas")

GROUP BY com COUNT

SQL:

SELECT produto, COUNT(*) as total_vendas
FROM vendas
GROUP BY produto;

dbplyr (R):

vendas_db |>
  group_by(produto) |>
  summarise(total_vendas = n())

# Source:   SQL [?? x 2]
# Database: sqlite 3.51.2 [:memory:]
  produto total_vendas
  <chr>          <int>
1 A                  3
2 B                  3
3 C                  2

GROUP BY com SUM

SQL:

SELECT produto, SUM(valor) as receita_total
FROM vendas
GROUP BY produto;

dbplyr (R):

vendas_db |>
  group_by(produto) |>
  summarise(receita_total = sum(valor, na.rm = TRUE))

# Source:   SQL [?? x 2]
# Database: sqlite 3.51.2 [:memory:]
  produto receita_total
  <chr>           <dbl>
1 A                 410
2 B                 430
3 C                 170

Múltiplas agregações

SQL:

SELECT produto, 
       COUNT(*) as vendas,
       SUM(valor) as receita,
       AVG(valor) as ticket_medio
FROM vendas
GROUP BY produto;

Múltiplas agregações

dbplyr (R):

vendas_db |>
  group_by(produto) |>
  summarise(
    vendas = n(),
    receita = sum(valor, na.rm = TRUE),
    ticket_medio = mean(valor, na.rm = TRUE))

# Source:   SQL [?? x 4]
# Database: sqlite 3.51.2 [:memory:]
  produto vendas receita ticket_medio
  <chr>    <int>   <dbl>        <dbl>
1 A            3     410         137.
2 B            3     430         143.
3 C            2     170          85

Funções de agregação

SQL	R (dplyr)	Função
`COUNT(*)`	`n()`	Contar linhas
`SUM()`	`sum()`	Somar valores
`AVG()`	`mean()`	Calcular média
`MIN()`	`min()`	Valor mínimo
`MAX()`	`max()`	Valor máximo

Dica: Sempre use na.rm = TRUE em R para ignorar valores NA

HAVING: Filtrando grupos

SQL:

SELECT produto, SUM(valor) as receita
FROM vendas
GROUP BY produto
HAVING SUM(valor) > 200;

dbplyr (R):

vendas_db |>
  group_by(produto) |>
  summarise(receita = sum(valor, na.rm = TRUE)) |>
  filter(receita > 200)

# Source:   SQL [?? x 2]
# Database: sqlite 3.51.2 [:memory:]
  produto receita
  <chr>     <dbl>
1 A           410
2 B           430

INNER JOIN: Juntando tabelas

SQL:

SELECT c.nome, v.produto, v.valor
FROM clientes c
INNER JOIN vendas v ON c.id = v.cliente_id;

dbplyr (R):

clientes_db |>
  inner_join(vendas_db, by = c("id" = "cliente_id")) |>
  select(nome, produto, valor)

# Source:   SQL [?? x 3]
# Database: sqlite 3.51.2 [:memory:]
  nome     produto valor
  <chr>    <chr>   <dbl>
1 Ana      A         100
2 Ana      A         200
3 Ana      C          90
4 Jennifer B         120
5 Jennifer B         150
6 Carla    C          80
7 Daniel   A         110
8 Elena    B         160

LEFT JOIN

SQL:

SELECT c.nome, v.produto
FROM clientes c
LEFT JOIN vendas v ON c.id = v.cliente_id;

dbplyr (R):

clientes_db |>
  left_join(vendas_db, by = c("id" = "cliente_id")) |>
  select(nome, produto)

# Source:   SQL [?? x 2]
# Database: sqlite 3.51.2 [:memory:]
  nome     produto
  <chr>    <chr>  
1 Ana      A      
2 Ana      A      
3 Ana      C      
4 Jennifer B      
5 Jennifer B      
6 Carla    C      
7 Daniel   A      
8 Elena    B

Tipos de JOIN

SQL	R (dplyr)	O que faz
`INNER JOIN`	`inner_join()`	Apenas registros que combinam
`LEFT JOIN`	`left_join()`	Todos da esquerda + combinações
`RIGHT JOIN`	`right_join()`	Todos da direita + combinações
`FULL JOIN`	`full_join()`	Todos os registros

Memória: O nome indica qual tabela mantém todos os registros

CASE WHEN: Criando categorias

SQL:

SELECT nome, idade,
  CASE 
    WHEN idade < 25 THEN 'Jovem'
    WHEN idade < 30 THEN 'Adulto'
    ELSE 'Experiente'
  END as faixa_etaria
FROM clientes;

CASE WHEN em R

dbplyr (R): Use TRUE como “ELSE”

clientes_db |>
  mutate(
    faixa_etaria = case_when(
      idade < 25 ~ "Jovem",
      idade < 30 ~ "Adulto",
      TRUE ~ "Experiente")) |>
  select(nome, idade, faixa_etaria)

# Source:   SQL [?? x 3]
# Database: sqlite 3.51.2 [:memory:]
  nome     idade faixa_etaria
  <chr>    <dbl> <chr>       
1 Ana         25 Adulto      
2 Jennifer    33 Experiente  
3 Carla       22 Jovem       
4 Daniel      35 Experiente  
5 Elena       28 Adulto

Criando novas colunas

SQL:

SELECT *, valor * quantidade as total
FROM vendas;

dbplyr (R):

vendas_db |>
  mutate(total = valor * quantidade)

# Source:   SQL [?? x 6]
# Database: sqlite 3.51.2 [:memory:]
     id cliente_id produto valor quantidade total
  <int>      <dbl> <chr>   <dbl>      <dbl> <dbl>
1     1          1 A         100          2   200
2     2          2 B         150          1   150
3     3          1 A         200          3   600
4     4          3 C          80          1    80
5     5          2 B         120          2   240
6     6          1 C          90          1    90
7     7          4 A         110          2   220
8     8          5 B         160          1   160

mutate() cria ou modifica colunas

DISTINCT: Valores únicos

SQL:

SELECT DISTINCT cidade FROM clientes;

dbplyr (R):

clientes_db |>
  distinct(cidade)

# Source:   SQL [?? x 1]
# Database: sqlite 3.51.2 [:memory:]
  cidade
  <chr> 
1 RJ    
2 SP    
3 MG

Subconsultas (Subqueries)

SQL:

SELECT * FROM vendas
WHERE valor > (SELECT AVG(valor) FROM vendas);

dbplyr (R):

# Calcular a média
valor_medio <- vendas_db |>
  summarise(media = mean(valor, na.rm = TRUE)) |>
  pull(media)

# Filtrar
vendas_db |>
  filter(valor > valor_medio)

# Source:   SQL [?? x 5]
# Database: sqlite 3.51.2 [:memory:]
     id cliente_id produto valor quantidade
  <int>      <dbl> <chr>   <dbl>      <dbl>
1     2          2 B         150          1
2     3          1 A         200          3
3     8          5 B         160          1

LIKE: Buscas com padrões

SQL:

SELECT * FROM clientes 
WHERE nome LIKE 'A%';

dbplyr (R):

# clientes_db |> 
# filter(str_detect(nome, "^A"))

Use str_detect() do pacote stringr (parte do tidyverse)

Vendo o SQL gerado

Quer ver qual SQL o dbplyr está gerando? Use show_query():

clientes_db |>
  filter(idade > 25) |>
  select(nome, cidade) |>
  show_query()

<SQL>
SELECT `nome`, `cidade`
FROM `clientes`
WHERE (`idade` > 25.0)

Perfeito para aprender! Compare seu código R com o SQL gerado.

Executando e coletando dados

O dbplyr é “lazy” (preguiçoso) - só executa quando necessário.

# Isso NÃO executa ainda, só prepara a query
query <- clientes_db |>
  filter(idade > 25)

# Isso executa e traz para o R
resultado <- query |> collect()

# Agora é um data.frame normal no R
class(resultado)

[1] "tbl_df"     "tbl"        "data.frame"

Por que usar collect()?

Sem collect():

Dados ficam no banco
Operações rápidas (SQL é otimizado)
Economiza memória

Por que usar collect()?

Com collect():

Dados vêm para o R
Use quando precisar processar no R
Use depois de filtrar para trazer menos dados

Dica: Filtre e agregue NO BANCO, só depois traga para o R!

Exemplo: Análise

# 1. Fazer query complexa no banco
relatorio <- clientes_db |>
  left_join(vendas_db, by = c("id" = "cliente_id")) |>
  filter(!is.na(valor)) |>
  group_by(nome, cidade) |>
  summarise(
    total_compras = n(),
    valor_total = sum(valor, na.rm = TRUE),
    ticket_medio = mean(valor, na.rm = TRUE)) |>
  arrange(desc(valor_total))

Exemplo: Análise - Resultado SQL

<SQL>
SELECT
  `nome`,
  `cidade`,
  COUNT(*) AS `total_compras`,
  SUM(`valor`) AS `valor_total`,
  AVG(`valor`) AS `ticket_medio`
FROM (
  SELECT `q01`.*
  FROM (
    SELECT
      `clientes`.*,
      `vendas`.`id` AS `id.y`,
      `produto`,
      `valor`,
      `quantidade`
    FROM `clientes`
    LEFT JOIN `vendas`
      ON (`clientes`.`id` = `vendas`.`cliente_id`)
  ) AS `q01`
  WHERE (NOT((`valor` IS NULL)))
) AS `q01`
GROUP BY `nome`, `cidade`
ORDER BY `valor_total` DESC

Coletando o resultado

# 3. Executar e trazer para o R
resultado_final <- relatorio |> collect()

# 4. Agora você pode usar ggplot2, etc
print(resultado_final)

# A tibble: 5 × 5
# Groups:   nome [5]
  nome     cidade total_compras valor_total ticket_medio
  <chr>    <chr>          <int>       <dbl>        <dbl>
1 Ana      RJ                 3         390          130
2 Jennifer SP                 2         270          135
3 Elena    RJ                 1         160          160
4 Daniel   MG                 1         110          110
5 Carla    SP                 1          80           80

Perfeito! Processamos tudo no banco e só trouxemos o resultado final.

Conectando a bancos reais

PostgreSQL:

library(RPostgres)
con <- dbConnect(
  RPostgres::Postgres(),
  dbname = "seu_banco",
  host = "localhost",
  port = 5432,
  user = "seu_usuario",
  password = "sua_senha")

Conectando a bancos reais (cont.)

MySQL:

library(RMariaDB)
con <- dbConnect(
  RMariaDB::MariaDB(),
  dbname = "seu_banco",
  host = "localhost",
  user = "seu_usuario",
  password = "sua_senha")

Boas práticas com bancos

1. Sempre feche a conexão:

dbDisconnect(con)

2. Filtre ANTES de collect():

# ✅ Bom - filtra no banco
dados |> filter(ano == 2024) |> collect()

# ❌ Ruim - traz tudo para depois filtrar
dados |> collect() |> filter(ano == 2024)

Boas práticas (cont.)

3. Use índices no banco de dados:

# Criar índice (SQL)
dbExecute(con, "CREATE INDEX idx_cliente ON vendas(cliente_id)")

4. Teste com LIMIT primeiro:

# Ver amostra antes de processar tudo
minha_tabela |> head(100) |> collect()

Tabela de tradução SQL > dplyr

SQL	dplyr	Função
`SELECT`	`select()`	Escolher colunas
`WHERE`	`filter()`	Filtrar linhas
`ORDER BY`	`arrange()`	Ordenar
`GROUP BY`	`group_by()`	Agrupar
Agregações + `GROUP BY`	`summarise()`	Resumir
`HAVING`	`filter()` após `summarise()`	Filtrar grupos

Tabela de tradução SQL > dplyr (cont.)

SQL	dplyr	Função
`LIMIT`	`head()`	Limitar resultados
`DISTINCT`	`distinct()`	Valores únicos
`INNER JOIN`	`inner_join()`	Interseção
`LEFT JOIN`	`left_join()`	Esquerda + combinação
`RIGHT JOIN`	`right_join()`	Direita + combinação
`FULL JOIN`	`full_join()`	União completa
`CASE WHEN`	`case_when()`	Condicionais
Criar coluna	`mutate()`	Nova variável

Exercício 1

Desafio: Traduza este SQL para dplyr:

SELECT cidade, COUNT(*) as total
FROM clientes
WHERE idade >= 25
GROUP BY cidade
HAVING COUNT(*) > 1
ORDER BY total DESC;

Tente fazer sozinho antes de ver a resposta!

Solução do exercício 1

clientes_db |>
  filter(idade >= 25) |>
  group_by(cidade) |>
  summarise(total = n()) |>
  filter(total > 1) |>
  arrange(desc(total))

Leia em voz alta: “Pegue clientes, filtre idade >= 25, agrupe por cidade, conte quantos em cada, filtre grupos com mais de 1, ordene por total decrescente”

Exercício 2

Desafio: Crie uma query que:

Una clientes e vendas
Calcule o valor total por cliente
Mostre apenas clientes com total > 200
Ordene do maior para o menor

Tente fazer sozinho!

Solução do exercício 2

clientes_db |>
  inner_join(vendas_db, by = c("id" = "cliente_id")) |>
  group_by(nome) |>
  summarise(valor_total = sum(valor, na.rm = TRUE)) |>
  filter(valor_total > 200) |>
  arrange(desc(valor_total))

# Source:     SQL [?? x 2]
# Database:   sqlite 3.51.2 [:memory:]
# Ordered by: desc(valor_total)
  nome     valor_total
  <chr>          <dbl>
1 Ana              390
2 Jennifer         270

Dicas de performance

1. Projete (select) cedo:

# ✅ Melhor - seleciona só o necessário
tabela |> select(col1, col2) |> filter(...)

# ❌ Pior - carrega todas as colunas
tabela |> filter(...) |> select(col1, col2)

2. Filtre no banco, não no R

3. Use índices nas colunas de JOIN e WHERE

Debugando problemas comuns

Erro: “no applicable method” -Você tentou usar uma função que não funciona com banco

Solução: Use collect() antes OU use função equivalente do SQL

Debugando problemas comuns

Dados não aparecem: Lembre-se: dbplyr é lazy!

Solução: Use collect() ou apenas visualize com print()

Debugando problemas comuns

Query muito lenta: Está trazendo dados demais?

Solução: Filtre e agregue ANTES de collect()

Quando NÃO usar dbplyr

Não use dbplyr quando:

Precisar de operações muito específicas do R (como modelos complexos)
Os dados são pequenos (< 100MB) - só use read_csv()
Precisar de loops ou operações iterativas
A query SQL já está pronta e otimizada

Use dbplyr quando

Dados não cabem na memória
Quer sintaxe R mas poder do banco
Está explorando dados grandes
Precisa combinar várias fontes

Recursos para continuar

Documentação:

Livros gratuitos:

R for Data Science - Cap. Databases

Prática:

Use seus próprios bancos!
Comece com SQLite para aprender
Depois migre para PostgreSQL/MySQL

Projeto prático sugerido

Mini projeto para praticar:

Crie um banco SQLite com 2-3 tabelas relacionadas
Escreva 5 queries SQL que você já conhece
Traduza todas para dbplyr
Compare os resultados
Use show_query() para ver o SQL gerado
Identifique padrões de tradução

Isso vai consolidar seu aprendizado!

Cheat sheet rápido

# Conectar
con <- dbConnect(RSQLite::SQLite(), "banco.db")
tabela <- tbl(con, "nome_tabela")

# Operações básicas
tabela |> filter(col > 10)        # WHERE
tabela |> select(col1, col2)      # SELECT
tabela |> arrange(col)            # ORDER BY
tabela |> distinct(col)           # DISTINCT

# Agregações
tabela |> group_by(col) |>
  summarise(total = n())          # COUNT

# Joins
left_join(tab1, tab2, by = "id")  # LEFT JOIN

# Executar
tabela |> collect()               # Trazer para R
tabela |> show_query()            # Ver SQL

Recapitulando

Você aprendeu:

O que é dbplyr e como funciona
Conectar R a bancos de dados
Traduzir SELECT, WHERE, JOIN, GROUP BY
Usar collect() e show_query()
Boas práticas de performance
Quando usar (e não usar) dbplyr

O melhor: Você pode escrever R e deixar o banco fazer o trabalho pesado!

Dica final

Fluxo ideal:

Escreva a query em dplyr
Use show_query() para ver o SQL
Aprenda com a tradução
Otimize se necessário
Use collect() só no final

“Pense em R, execute em SQL, aprenda os dois!”

A cada query você escreve, está praticando DUAS linguagens ao mesmo tempo!

Mensagem final

SQL + R = 💪

Você não precisa escolher entre SQL e R.

Com dbplyr, você tem o melhor dos dois mundos:

A elegância do tidyverse
O poder e performance do SQL
A flexibilidade de escolher quando usar cada um

Continue praticando e explorando!

Muito obrigada!

Esta apresentação é parte do projeto Café com R

É OPEN, USE, COMPARTILHE!

Perguntas? Dúvidas? Sugestões?

Próximo passo: Abra seu RStudio e comece a praticar!

Limpando o ambiente

Não esqueça de fechar a conexão ao terminar:

# Fechar conexão
dbDisconnect(con)

Boa prática: Sempre feche conexões para liberar recursos!

☕ Assine o Café com R

Fique por dentro das aulas, conteúdos, newsletter!

Que cada gole desperte uma nova ideia.

Que cada script abra uma nova conversa.

Que o Café com R, se torne um ponto de encontro nosso!