Fundamentos de DBI y RSQLite
Conéctese a bases de datos SQLite, ejecute consultas y recupere resultados con DBI.
Fundamentos de DBI y RSQLite es una lección gratuita de R Academy en CoddyKit. Esta es la lección 1 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.
Acceso a bases de datos en R con DBI
El paquete DBI proporciona una interfaz unificada para acceder a bases de datos desde R. Las mismas funciones funcionan con distintos backends de bases de datos (SQLite, PostgreSQL, MySQL, etc.) al combinar DBI con el paquete controlador correspondiente. RSQLite es el backend más accesible, ya que no requiere instalar ningún servidor.
library(DBI)
library(RSQLite)
# DBI + RSQLite: connect to an in-memory SQLite database
# ':memory:' creates a fresh database in RAM
con <- dbConnect(RSQLite::SQLite(), ':memory:')
cat('Connection class:', class(con), '\n')
cat('Database backend:', dbGetInfo(con)$dbname, '\n')
# Always close connection when done
dbDisconnect(con)
cat('Connection closed.')dbConnect() — Crear una conexión
dbConnect(drv, ...) crea una conexión a una base de datos. El primer argumento es el objeto controlador. Para SQLite: RSQLite::SQLite(). Los argumentos adicionales (como la ruta del archivo de la base de datos) dependen del backend.
library(DBI)
library(RSQLite)
# In-memory database (disappears when connection closes)
con_mem <- dbConnect(RSQLite::SQLite(), ':memory:')
# File-based SQLite database (persists to disk)
# con_file <- dbConnect(RSQLite::SQLite(), '/tmp/mydb.sqlite')
# Always wrap connections in tryCatch or use on.exit()
on.exit(dbDisconnect(con_mem))
cat('Connected! Is valid:', dbIsValid(con_mem))dbWriteTable() — Cargar datos en la base de datos
dbWriteTable(con, 'table_name', df) crea una tabla y carga en ella un marco de datos. Establezca overwrite=TRUE para reemplazar una tabla existente o append=TRUE para agregar filas a una tabla existente.
library(DBI)
library(RSQLite)
con <- dbConnect(RSQLite::SQLite(), ':memory:')
# Load a data frame into the database
students <- data.frame(
id = 1:5,
name = c('Alice','Bob','Carol','Dave','Eve'),
score = c(85, 92, 78, 88, 95)
)
dbWriteTable(con, 'students', students)
# Verify: list tables
cat('Tables in DB:', dbListTables(con), '\n')
dbDisconnect(con)dbListTables() y dbListFields()
dbListTables(con) devuelve los nombres de todas las tablas de la base de datos conectada. dbListFields(con, 'table') devuelve los nombres de las columnas de una tabla específica. Utilice estas funciones para explorar una base de datos desconocida.
library(DBI)
library(RSQLite)
con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'students', data.frame(id=1:3, name=c('A','B','C'), score=c(80,90,85)))
dbWriteTable(con, 'courses', data.frame(code=c('R101','R201'), title=c('Intro','Advanced')))
cat('Tables:', paste(dbListTables(con), collapse=', '), '\n')
cat('Students fields:', paste(dbListFields(con, 'students'), collapse=', '), '\n')
dbDisconnect(con)dbGetQuery() — Ejecutar SQL y devolver datos
dbGetQuery(con, sql) ejecuta una consulta SELECT y devuelve el resultado como un marco de datos. Esta es la función principal para leer datos de una base de datos. Combina dbSendQuery() + dbFetch() + dbClearResult() en un solo paso.
library(DBI)
library(RSQLite)
con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'students',
data.frame(id=1:5, name=c('Alice','Bob','Carol','Dave','Eve'),
score=c(85,92,78,88,95)))
# Run SQL and get results as data frame
high_scorers <- dbGetQuery(con,
'SELECT name, score FROM students WHERE score >= 88 ORDER BY score DESC'
)
print(high_scorers)
dbDisconnect(con)dbFetch() — Recuperar resultados por bloques
Para conjuntos de resultados grandes, utilice el enfoque de tres pasos: dbSendQuery() envía la consulta, dbFetch(con, n=1000) recupera bloques de n filas y dbClearResult() limpia los recursos. Esto permite controlar el uso de memoria en tablas grandes.
library(DBI)
library(RSQLite)
con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'data', data.frame(x=1:100, y=rnorm(100)))
# Three-step approach for chunked reading
rs <- dbSendQuery(con, 'SELECT * FROM data WHERE x <= 5')
chunk <- dbFetch(rs, n=3) # Get first 3 rows
cat('Rows fetched so far:', nrow(chunk), '\n')
print(chunk)
dbClearResult(rs) # Always clear!
dbDisconnect(con)dbExecute() — Ejecutar SQL que no sea SELECT
dbExecute(con, sql) ejecuta instrucciones SQL que modifican los datos (INSERT, UPDATE, DELETE, CREATE, DROP) y devuelve el número de filas afectadas. Utilícelo para operaciones DDL y DML que no devuelven filas.
library(DBI)
library(RSQLite)
con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'students',
data.frame(id=1:4, name=c('Alice','Bob','Carol','Dave'), score=c(85,92,78,88)))
# Update a record
rows_affected <- dbExecute(con,
'UPDATE students SET score = 95 WHERE name = \'Alice\''
)
cat('Rows updated:', rows_affected, '\n')
# Verify
print(dbGetQuery(con, 'SELECT * FROM students WHERE name = \'Alice\''))
dbDisconnect(con)dbExistsTable() y dbRemoveTable()
dbExistsTable(con, 'name') comprueba si existe una tabla (devuelve TRUE/FALSE). dbRemoveTable(con, 'name') elimina una tabla. Estas funciones son útiles para configurar y desmontar de forma segura scripts que pueden ejecutarse varias veces.
library(DBI)
library(RSQLite)
con <- dbConnect(RSQLite::SQLite(), ':memory:')
cat('Before: exists?', dbExistsTable(con, 'results'), '\n')
dbWriteTable(con, 'results', data.frame(x=1:3, y=4:6))
cat('After write: exists?', dbExistsTable(con, 'results'), '\n')
dbRemoveTable(con, 'results')
cat('After remove: exists?', dbExistsTable(con, 'results'), '\n')
dbDisconnect(con)dbDisconnect() — Cerrar conexiones
Cierre siempre las conexiones a bases de datos con dbDisconnect(con) cuando haya terminado. Las conexiones abiertas consumen memoria y descriptores de archivo. Utilice on.exit(dbDisconnect(con)) dentro de las funciones para garantizar la limpieza incluso si se produce un error.
library(DBI)
library(RSQLite)
# Safe connection pattern using on.exit()
safe_query <- function(query) {
con <- dbConnect(RSQLite::SQLite(), ':memory:')
on.exit(dbDisconnect(con)) # Runs even if error!
dbWriteTable(con, 'data', data.frame(x=1:5, y=6:10))
dbGetQuery(con, query)
}
result <- safe_query('SELECT * FROM data WHERE x > 3')
print(result)Cargar mtcars en SQLite
Un ejemplo práctico: cargue el conjunto de datos integrado mtcars en SQLite y, después, ejecute consultas SQL sobre él. Esto demuestra el flujo de trabajo completo de DBI y le permite practicar SQL desde R.
library(DBI)
library(RSQLite)
con <- dbConnect(RSQLite::SQLite(), ':memory:')
# Load mtcars into the database
dbWriteTable(con, 'cars', mtcars, overwrite=TRUE)
# SQL query
result <- dbGetQuery(con, '
SELECT cyl,
COUNT(*) AS n,
ROUND(AVG(mpg), 1) AS avg_mpg,
ROUND(AVG(hp), 0) AS avg_hp
FROM cars
GROUP BY cyl
ORDER BY cyl
')
print(result)
dbDisconnect(con)Resumen del flujo de trabajo de DBI
El flujo de trabajo de DBI sigue un patrón coherente independientemente del backend de base de datos: conectar → cargar/consultar → desconectar. El mismo código funciona con SQLite, PostgreSQL, MySQL y otros sistemas; solo debe cambiar el controlador en dbConnect().
library(DBI)
library(RSQLite)
# Complete DBI workflow
con <- dbConnect(RSQLite::SQLite(), ':memory:')
# 1. Create table
dbWriteTable(con, 'orders',
data.frame(order_id=1:4, customer=c('Alice','Bob','Alice','Carol'),
amount=c(100,200,150,80)))
# 2. Query
totals <- dbGetQuery(con,
'SELECT customer, COUNT(*) orders, SUM(amount) total
FROM orders GROUP BY customer ORDER BY total DESC')
print(totals)
# 3. Clean up
dbDisconnect(con)Comprobación rápida
¿Cuál es la diferencia entre dbGetQuery() y dbExecute() en DBI?
Resumen: DBI y RSQLite
Aspectos clave de DBI y RSQLite:
dbConnect(RSQLite::SQLite(), ':memory:')— crea una conexión SQLite en memoriadbWriteTable(con, 'name', df)— carga un marco de datos en una tabladbListTables(con)— enumera las tablas;dbListFields(con, 'tbl')— enumera las columnasdbGetQuery(con, sql)— ejecuta SELECT y devuelve un marco de datosdbFetch(rs, n=1000)— recuperación por bloques para resultados grandesdbExecute(con, sql)— ejecuta INSERT/UPDATE/DELETE/DDLdbDisconnect(con)— cierre siempre la conexión; utiliceon.exit()en las funciones- DBI funciona con PostgreSQL, MySQL, BigQuery, etc., cambiando el controlador
library(DBI)
library(RSQLite)
con <- dbConnect(RSQLite::SQLite(), ':memory:')
on.exit(dbDisconnect(con))
dbWriteTable(con, 'scores',
data.frame(student=c('Alice','Bob','Carol'), score=c(85,92,78)))
dbExecute(con, 'UPDATE scores SET score = score + 5 WHERE score < 80')
dbGetQuery(con, 'SELECT * FROM scores ORDER BY score DESC')
Aprende R con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 43
- Lecciones
- 159
Preguntas frecuentes
¿La lección «Fundamentos de DBI y RSQLite» es gratis?
Sí — el texto completo de «Fundamentos de DBI y RSQLite» 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 «Fundamentos de DBI y RSQLite»?
Conéctese a bases de datos SQLite, ejecute consultas y recupere resultados con DBI. 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 1 de 4.
¿Cuánto tiempo toma la lección «Fundamentos de DBI y RSQLite»?
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
- Fundamentos de DBI y RSQLite
- Conexión a PostgreSQL y MySQL
- dbplyr: SQL mediante la sintaxis de dplyr
- Consultas parametrizadas y transacciones