R Academy · Aula

Fundamentos de DBI e RSQLite

Conecte-se a bancos de dados SQLite, execute consultas e recupere resultados com DBI.

Aula 1 de 413 etapas

Fundamentos de DBI e RSQLite é uma aula grátis de R Academy no CoddyKit. Esta é a aula 1 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.

Acesso a bancos de dados em R com DBI

O pacote DBI fornece uma interface unificada para acesso a bancos de dados em R. As mesmas funções funcionam em diferentes mecanismos de banco de dados (SQLite, PostgreSQL, MySQL etc.) combinando DBI com um pacote de driver do mecanismo. RSQLite é o mecanismo mais acessível — não requer instalação de 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() — criando uma conexão

dbConnect(drv, ...) cria uma conexão com um banco de dados. O primeiro argumento é o objeto de driver. Para SQLite: RSQLite::SQLite(). Os argumentos adicionais (como o caminho do arquivo do banco de dados) dependem do mecanismo.

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() — carregando dados no banco

dbWriteTable(con, 'table_name', df) cria uma tabela e carrega nela um quadro de dados. Defina overwrite=TRUE para substituir uma tabela existente ou append=TRUE para adicionar linhas a uma tabela 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() e dbListFields()

dbListTables(con) retorna os nomes de todas as tabelas do banco de dados conectado. dbListFields(con, 'table') retorna os nomes das colunas de uma tabela específica. Use essas funções para explorar um banco de dados desconhecido.

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() — executando SQL e retornando dados

dbGetQuery(con, sql) executa uma consulta SELECT e retorna o resultado como um quadro de dados. Essa é a principal função para ler dados de um banco de dados. Ela combina dbSendQuery() + dbFetch() + dbClearResult() em uma única etapa.

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() — recuperando resultados em blocos

Para grandes conjuntos de resultados, use a abordagem em três etapas: dbSendQuery() envia a consulta, dbFetch(con, n=1000) recupera blocos de n linhas e dbClearResult() faz a limpeza. Isso controla o uso de memória em tabelas 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() — executando SQL que não é SELECT

dbExecute(con, sql) executa SQL que modifica dados (INSERT, UPDATE, DELETE, CREATE, DROP) e retorna o número de linhas afetadas. Use essa função para operações DDL e DML que não retornam linhas.

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() e dbRemoveTable()

dbExistsTable(con, 'name') verifica se uma tabela existe (retorna TRUE/FALSE). dbRemoveTable(con, 'name') exclui uma tabela. Essas funções são úteis para configurar e desmontar com segurança scripts que podem ser executados várias vezes.

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() — fechando conexões

Sempre feche as conexões com bancos de dados usando dbDisconnect(con) quando terminar. Conexões abertas consomem memória e identificadores de arquivos. Use on.exit(dbDisconnect(con)) dentro das funções para garantir a limpeza mesmo que ocorra um erro.

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)

Carregando mtcars no SQLite

Um exemplo prático: carregue o conjunto de dados integrado mtcars no SQLite e execute consultas SQL nele. Isso demonstra o fluxo completo de trabalho do DBI e permite praticar SQL a partir do 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)

Resumo do fluxo de trabalho do DBI

O fluxo de trabalho do DBI segue um padrão consistente, independentemente do mecanismo de banco de dados: conectar → carregar/consultar → desconectar. O mesmo código funciona com SQLite, PostgreSQL, MySQL e outros, bastando trocar o driver em 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)

Verificação rápida

Qual é a diferença entre dbGetQuery() e dbExecute() no DBI?

Responda na aula interativa

Revisão: DBI e RSQLite

Principais pontos sobre DBI e RSQLite:

dbConnect(RSQLite::SQLite(), ':memory:') — cria uma conexão SQLite em memória
dbWriteTable(con, 'name', df) — carrega um quadro de dados em uma tabela
dbListTables(con) — lista tabelas; dbListFields(con, 'tbl') — lista colunas
dbGetQuery(con, sql) — executa SELECT e retorna um quadro de dados
dbFetch(rs, n=1000) — recuperação em blocos para resultados grandes
dbExecute(con, sql) — executa INSERT/UPDATE/DELETE/DDL
dbDisconnect(con) — sempre fecha a conexão; use on.exit() nas funções
O DBI funciona com PostgreSQL, MySQL, BigQuery etc. trocando o driver

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')

Grátis para começar

Aprenda R com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 43
Aulas: 159

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Fundamentos de DBI e RSQLite” é grátis?

Sim — o texto completo de “Fundamentos de DBI e RSQLite” é 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 “Fundamentos de DBI e RSQLite”?

Conecte-se a bancos de dados SQLite, execute consultas e recupere resultados com DBI. 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 1 de 4.

Quanto tempo leva a aula “Fundamentos de DBI e RSQLite”?

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