0Pricing
R Academy · Lección

dbplyr: SQL mediante la sintaxis de dplyr

Escriba código dplyr que se traduzca a SQL y se ejecute en la base de datos.

dbplyr: SQL mediante la sintaxis de dplyr es una lección gratuita de R Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.

¿Qué es dbplyr?

dbplyr es un paquete de R que traduce automáticamente los verbos de dplyr a SQL. En lugar de escribir SQL sin procesar, escriba código familiar de dplyr y dbplyr lo convierte al dialecto SQL correcto para el backend de su base de datos. La consulta se ejecuta en la base de datos, no en la memoria de R.

# install.packages(c('dbplyr', 'DBI', 'RSQLite'))
library(DBI)
library(dbplyr)
library(dplyr)

# dbplyr sits between dplyr and your database:
# Your dplyr code -> dbplyr -> SQL -> Database -> result

# Supported backends: PostgreSQL, MySQL, SQLite,
#                     SQL Server, BigQuery, Snowflake, ...

cat('dbplyr translates dplyr to SQL')

Conexión a una base de datos

dbplyr funciona sobre una conexión de DBI. Establezca la conexión con DBI::dbConnect() usando el paquete del controlador adecuado y, después, pase ese objeto de conexión a las funciones de dbplyr.

library(DBI)
library(dplyr)
library(dbplyr)

# SQLite example (no server needed — great for demos)
con <- dbConnect(RSQLite::SQLite(), ':memory:')

# Write a test table to the in-memory database
copy_to(con, nycflights13::flights, 'flights',
        temporary = FALSE, overwrite = TRUE)

# PostgreSQL example (real server):
# con <- dbConnect(
#   RPostgres::Postgres(),
#   host     = 'db.example.com',
#   dbname   = 'analytics',
#   user     = Sys.getenv('DB_USER'),
#   password = Sys.getenv('DB_PASS')
# )

cat('Connected to database')

tbl() — Referencia a una tabla de base de datos

tbl(con, 'table_name') crea una referencia diferida a una tabla de la base de datos. Todavía no se recuperan datos; solo obtiene un puntero. Después puede encadenar verbos de dplyr y dbplyr irá construyendo la consulta SQL de forma incremental.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
mtcars_df <- mtcars
dbWriteTable(con, 'cars', mtcars_df)

# Create a lazy table reference
cars_tbl <- tbl(con, 'cars')

# Printing shows top rows and indicates it is a database source
print(cars_tbl)
# Source: table<cars> [?? x 11]
# Database: sqlite 3.x [:memory:]

cat('tbl() = lazy reference, no data fetched yet')

Aplicación de filter() a una tabla de base de datos

Puede encadenar filter() a una referencia tbl(), igual que lo haría con un marco de datos local. dbplyr lo traduce a una cláusula SQL WHERE. El filtrado se realiza en la base de datos; solo se enviarán a R las filas que coincidan.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'cars', mtcars)
cars_tbl <- tbl(con, 'cars')

# Filter in the database (generates WHERE clause)
high_mpg <- cars_tbl |>
  filter(mpg > 25, cyl == 4)

# Still lazy! No data fetched yet.
cat('Class:', class(high_mpg)[1], '\n')

# Collect to pull data into R:
result <- collect(high_mpg)
cat('Rows matching filter:', nrow(result))

Aplicación de select() y mutate()

select() se corresponde con SQL SELECT y mutate() con columnas calculadas en la cláusula SELECT. dbplyr se encarga de la traducción, incluidas muchas expresiones comunes de R que tienen equivalentes en SQL.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'cars', mtcars)
cars_tbl <- tbl(con, 'cars')

# Select specific columns + add a computed column
result <- cars_tbl |>
  filter(am == 1) |>              # manual transmission
  select(mpg, cyl, hp, wt) |>    # pick columns
  mutate(wt_kg = wt * 453.592)   # add computed column

# Pull into R
df <- collect(result)
cat('Columns:', names(df), '\n')
cat('Rows:', nrow(df))

group_by() y summarise() — Agregación

group_by() y summarise() se traducen a SQL GROUP BY con funciones de agregación. Esto permite calcular resúmenes en la base de datos sin cargar primero todas las filas en R, algo fundamental para tablas grandes.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'cars', mtcars)
cars_tbl <- tbl(con, 'cars')

# Aggregate in the database
summary_tbl <- cars_tbl |>
  group_by(cyl) |>
  summarise(
    avg_mpg  = mean(mpg, na.rm = TRUE),
    max_hp   = max(hp),
    n_models = n()
  )

result <- collect(summary_tbl)
print(result)

show_query() — Inspección del SQL generado

show_query() imprime el SQL que dbplyr enviará a la base de datos. Resulta muy útil para depurar, optimizar el rendimiento y aprender SQL observando cómo se traduce su código de dplyr.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'cars', mtcars)
cars_tbl <- tbl(con, 'cars')

# Build a query
q <- cars_tbl |>
  filter(mpg > 20) |>
  group_by(cyl) |>
  summarise(avg_mpg = mean(mpg, na.rm = TRUE))

# See the SQL dbplyr generated:
show_query(q)
# <SQL>
# SELECT cyl, AVG(mpg) AS avg_mpg
# FROM cars
# WHERE mpg > 20.0
# GROUP BY cyl

collect() — Carga de datos en R

collect() ejecuta la consulta diferida y recupera los resultados en un marco de datos local de R (tibble). Hasta que no llama a collect(), no se transfieren datos de la base de datos a R; todas las operaciones se traducen a SQL y se ejecutan en el servidor.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'cars', mtcars)
cars_tbl <- tbl(con, 'cars')

# Build up a lazy query chain
lazy_q <- cars_tbl |>
  filter(hp > 100) |>
  select(mpg, hp, cyl) |>
  arrange(desc(hp))

# Nothing fetched yet
cat('Is lazy?', inherits(lazy_q, 'tbl_sql'), '\n')

# NOW pull data into R
local_df <- collect(lazy_q)
cat('Class after collect:', class(local_df)[1], '\n')
cat('Rows:', nrow(local_df))

copy_to() — Envío de un marco de datos local a la base de datos

copy_to() escribe un marco de datos local de R en la base de datos como una tabla (normalmente temporal). Resulta útil para combinar tablas de búsqueda locales con tablas remotas grandes o para realizar pruebas sin una base de datos existente.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')

# Push a local data frame into the database
local_df <- data.frame(
  cyl       = c(4, 6, 8),
  category  = c('efficient', 'balanced', 'powerful')
)

# copy_to creates a temporary table in the DB
copy_to(con, local_df, name = 'cyl_labels', temporary = TRUE)

# Now reference it with tbl()
labels_tbl <- tbl(con, 'cyl_labels')
cat('Rows in DB table:', collect(labels_tbl) |> nrow())

Combinación de tablas de bases de datos

Puede combinar dos referencias tbl() usando las mismas funciones left_join(), inner_join(), etc. de dplyr. dbplyr las traduce a cláusulas SQL JOIN; la combinación se ejecuta en la base de datos.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'cars', mtcars)
copy_to(con, data.frame(cyl = c(4,6,8),
                         label = c('four','six','eight')),
        'cyl_ref', temporary = TRUE)

cars_tbl  <- tbl(con, 'cars')
labels_tbl <- tbl(con, 'cyl_ref')

# Join in the database
joined <- left_join(cars_tbl, labels_tbl, by = 'cyl') |>
  select(mpg, cyl, label, hp)

show_query(joined)   # See the SQL JOIN
result <- collect(joined)
cat('Joined rows:', nrow(result))

Cuándo NO usar dbplyr

dbplyr no puede traducir todas las expresiones de R a SQL. Es posible que las funciones personalizadas complejas, la manipulación de fechas de R base o las funciones estadísticas específicas de R no tengan equivalentes en SQL. Llame primero a collect() para cargar los datos en R y, después, aplique localmente las operaciones exclusivas de R.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'cars', mtcars)
cars_tbl <- tbl(con, 'cars')

# Do as much as possible in the database:
prepped <- cars_tbl |>
  filter(mpg > 15) |>
  select(mpg, hp, cyl) |>
  collect()               # <- pull only what you need

# Now apply R-only operations locally:
cor_result <- cor(prepped$mpg, prepped$hp)
cat('Correlation mpg~hp:', round(cor_result, 3))

# Rule: filter and aggregate in DB, model in R

Comprobación rápida

Después de crear una cadena de verbos de dplyr sobre una referencia de base de datos tbl(), ¿qué función ejecuta la consulta y devuelve los resultados como un marco de datos local de R?

dbplyr — Aspectos clave

dbplyr permite consultar bases de datos con la sintaxis de dplyr, sin necesidad de SQL:

  • tbl(con, 'table') — referencia diferida a una tabla de la base de datos
  • filter(), select(), mutate() — se traducen a cláusulas SQL
  • group_by() |> summarise() — se convierte en SQL GROUP BY
  • show_query() — inspecciona el SQL generado (muy útil para aprender)
  • collect() — ejecuta la consulta y carga los datos en R
  • copy_to() — envía un marco de datos local a la base de datos
  • Las combinaciones también funcionan: left_join(), inner_join(), etc.
  • Filtre y agregue en la base de datos; use R solo para lo que SQL no pueda hacer
# Complete dbplyr workflow example:
library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'sales', data.frame(
  region  = c('North','South','North','East','South'),
  revenue = c(100, 200, 150, 300, 250),
  year    = c(2023, 2023, 2024, 2024, 2024)
))

tbl(con, 'sales') |>
  filter(year == 2024) |>
  group_by(region) |>
  summarise(total = sum(revenue, na.rm = TRUE)) |>
  arrange(desc(total)) |>
  collect() |>
  print()

Preguntas frecuentes

¿La lección «dbplyr: SQL mediante la sintaxis de dplyr» es gratis?

Sí — el texto completo de «dbplyr: SQL mediante la sintaxis de dplyr» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.

¿Qué aprenderé en «dbplyr: SQL mediante la sintaxis de dplyr»?

Escriba código dplyr que se traduzca a SQL y se ejecute en la base de datos. Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar R Academy?

No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «dbplyr: SQL mediante la sintaxis de dplyr»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de R Academy?

Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Fundamentos de DBI y RSQLite
  2. Conexión a PostgreSQL y MySQL
  3. dbplyr: SQL mediante la sintaxis de dplyr
  4. Consultas parametrizadas y transacciones
← Volver a R Academy