R Academy · Aula

Conectando-se ao PostgreSQL e ao MySQL

Use os drivers RPostgres e RMySQL para se conectar a bancos de dados baseados em servidor.

Conectando-se ao PostgreSQL e ao MySQL é uma aula grátis de R Academy no CoddyKit. Esta é a aula 2 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.

Conexões com bancos de dados de produção

Embora o RSQLite seja ótimo para desenvolvimento e testes, os dados de produção ficam em PostgreSQL, MySQL, SQL Server ou bancos de dados na nuvem. A interface DBI permanece a mesma — apenas o pacote do driver e os argumentos da conexão mudam. Essa é a principal vantagem do DBI.

library(DBI)

# Driver packages for each database:
# PostgreSQL  -> RPostgres::Postgres()
# MySQL       -> RMySQL::MySQL() or RMariaDB::MariaDB()
# SQL Server  -> odbc::odbc()
# BigQuery    -> bigrquery::bigquery()
# Redshift    -> RPostgres::Postgres()  (same protocol)
# DuckDB      -> duckdb::duckdb()

# All use the same DBI functions:
# dbConnect, dbGetQuery, dbExecute, dbDisconnect

Conectando ao PostgreSQL

RPostgres::Postgres() é o driver para PostgreSQL. Passe os parâmetros de conexão: host, port (padrão 5432), dbname, user e password. Nunca inclua credenciais diretamente no código — use variáveis de ambiente.

library(DBI)
# library(RPostgres)  # Uncomment when available

# PostgreSQL connection pattern:
# con <- dbConnect(
#   RPostgres::Postgres(),
#   host     = 'db.example.com',
#   port     = 5432,
#   dbname   = 'analytics',
#   user     = 'analyst',
#   password = 'secretpassword'
# )

# Query exactly like SQLite:
# result <- dbGetQuery(con, 'SELECT * FROM sales LIMIT 5')
# dbDisconnect(con)

cat('PostgreSQL uses the same DBI interface as SQLite!')

Usando variáveis de ambiente para credenciais

Incluir senhas diretamente no código é um risco de segurança. Armazene as credenciais como variáveis de ambiente e leia-as com Sys.getenv(). Em produção, defina-as em .Renviron, em arquivos .env (que não devem ser incluídos no git) ou por meio de sistemas de gerenciamento de segredos.

library(DBI)

# Set environment variables (normally done outside R):
# In .Renviron file:
# DB_HOST=db.example.com
# DB_NAME=analytics
# DB_USER=analyst
# DB_PASS=secretpassword

# Read credentials from environment
get_pg_connection <- function() {
  dbConnect(
    RPostgres::Postgres(),  # driver
    host     = Sys.getenv('DB_HOST'),
    port     = as.integer(Sys.getenv('DB_PORT', '5432')),
    dbname   = Sys.getenv('DB_NAME'),
    user     = Sys.getenv('DB_USER'),
    password = Sys.getenv('DB_PASS')
  )
}

cat('Sys.getenv() reads environment variables safely.')
cat('\nDB_HOST value:', nchar(Sys.getenv('DB_HOST')), 'chars')

Conectando ao MySQL / MariaDB

As conexões MySQL usam RMariaDB::MariaDB() (o driver moderno do MySQL) ou RMySQL::MySQL(). Os argumentos da conexão são semelhantes aos do PostgreSQL. MariaDB é o driver recomendado tanto para servidores MySQL quanto MariaDB.

library(DBI)

# MySQL / MariaDB connection pattern:
# library(RMariaDB)
# con <- dbConnect(
#   RMariaDB::MariaDB(),
#   host     = Sys.getenv('MYSQL_HOST'),
#   port     = 3306,
#   dbname   = Sys.getenv('MYSQL_DB'),
#   user     = Sys.getenv('MYSQL_USER'),
#   password = Sys.getenv('MYSQL_PASS')
# )

# SSL connection:
# con <- dbConnect(
#   RMariaDB::MariaDB(),
#   host = 'secure-db.example.com',
#   ssl.ca = '/path/to/ca-cert.pem'
# )

cat('RMariaDB supports both MySQL and MariaDB servers.')

Tempo limite e reconexão

Scripts de longa duração podem atingir o tempo limite da conexão. Verifique se a conexão ainda é válida com dbIsValid(con). Para scripts ETL, considere reconectar no início de cada lote de processamento em vez de manter uma única conexão aberta por horas.

library(DBI)
library(RSQLite)

# Safe function with reconnection
query_with_check <- function(con, sql) {
  if (!dbIsValid(con)) {
    stop('Connection is no longer valid. Reconnect.')
  }
  dbGetQuery(con, sql)
}

# Demonstrate with SQLite
con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 't', data.frame(x=1:3))

cat('Connection valid:', dbIsValid(con), '\n')
print(query_with_check(con, 'SELECT * FROM t'))

dbDisconnect(con)
cat('After disconnect, valid:', dbIsValid(con))

Conceito de agrupamento de conexões

Abrir uma nova conexão com o banco de dados para cada consulta é dispendioso. O agrupamento de conexões mantém um conjunto de conexões abertas e as reutiliza. Isso é essencial para APIs web e aplicativos Shiny que recebem muitas solicitações por segundo.

# The 'pool' package provides connection pooling for R
# library(pool)

# Create a pool (connections managed automatically)
# my_pool <- pool::dbPool(
#   drv      = RPostgres::Postgres(),
#   dbname   = Sys.getenv('DB_NAME'),
#   host     = Sys.getenv('DB_HOST'),
#   user     = Sys.getenv('DB_USER'),
#   password = Sys.getenv('DB_PASS'),
#   minSize  = 2,   # Always keep 2 connections ready
#   maxSize  = 10   # Maximum 10 simultaneous connections
# )

# Use the pool like a regular connection:
# result <- dbGetQuery(my_pool, 'SELECT * FROM table')

# Close the pool on shutdown:
# pool::poolClose(my_pool)

cat('pool package: connection reuse for high-traffic apps!')

Consultando com parâmetros SQL (com segurança)

Nunca concatene a entrada do usuário em strings SQL (há risco de injeção de SQL). Use consultas parametrizadas com sqlInterpolate(con, sql, .dots=list(...)) ou glue_sql() do pacote glue para inserir valores com segurança.

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

# UNSAFE (SQL injection possible):
# name_input <- 'Alice' # imagine user-provided
# dbGetQuery(con, paste('SELECT * FROM students WHERE name =', name_input))

# SAFE: use sqlInterpolate
name_input <- 'Alice'
safe_sql <- sqlInterpolate(con,
  'SELECT * FROM students WHERE name = ?name',
  name = name_input
)
print(dbGetQuery(con, safe_sql))
dbDisconnect(con)

Tunelamento SSH para bancos de dados remotos

Muitos bancos de dados de produção não são acessíveis diretamente pela internet. Um padrão comum é o tunelamento SSH: encaminhe uma porta local para a porta do banco de dados remoto por SSH e, em seguida, conecte o R a localhost:local_port.

# SSH tunnel setup (run in terminal before connecting from R):
# ssh -N -L 5433:db-server.internal:5432 user@jump-host.example.com

# Then connect in R as if the DB is local:
# con <- dbConnect(
#   RPostgres::Postgres(),
#   host     = 'localhost',
#   port     = 5433,   # Local forwarded port
#   dbname   = 'analytics',
#   user     = Sys.getenv('DB_USER'),
#   password = Sys.getenv('DB_PASS')
# )

# You can also script the tunnel with:
# system('ssh -fN -L 5433:db:5432 user@jump-host')

cat('SSH tunneling makes private databases accessible to R.')

Lendo tabelas grandes em blocos

Quando uma tabela de banco de dados tem milhões de linhas, carregar tudo de uma vez pode esgotar a memória. Use LIMIT/OFFSET ou a recuperação baseada em cursor para processar a tabela em blocos. Combine isso com dbFetch() para transmitir os resultados.

library(DBI)
library(RSQLite)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'big_table', data.frame(id=1:100, value=rnorm(100)))

# Process in chunks of 25 rows
chunk_size <- 25
offset <- 0
total_processed <- 0

repeat {
  chunk <- dbGetQuery(con, sprintf(
    'SELECT * FROM big_table LIMIT %d OFFSET %d',
    chunk_size, offset
  ))
  if (nrow(chunk) == 0) break
  total_processed <- total_processed + nrow(chunk)
  offset <- offset + chunk_size
}

cat('Total rows processed:', total_processed, '\n')
dbDisconnect(con)

dbGetInfo() — metadados da conexão

dbGetInfo(con) retorna metadados da conexão: versão do servidor, nome do banco de dados, usuário etc. Isso é útil para registro, diagnóstico e verificação de que você se conectou à instância correta do banco de dados em scripts executados em vários ambientes.

library(DBI)
library(RSQLite)

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

info <- dbGetInfo(con)
print(info)

# For PostgreSQL, info would include:
# $host, $port, $dbname, $username, $server.version

dbDisconnect(con)

Comparando o uso de SQLite e PostgreSQL

Escolha SQLite para prototipagem, dados incorporados e testes; escolha PostgreSQL para produção, acesso multiusuário e recursos avançados de SQL. O código DBI é quase idêntico — a única diferença está no driver e nos parâmetros de conexão.

library(DBI)
library(RSQLite)

# SQLite (development/testing)
con_dev <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con_dev, 'data', mtcars)
dev_result <- dbGetQuery(con_dev, 'SELECT COUNT(*) n FROM data')
cat('SQLite dev DB rows:', dev_result$n, '\n')
dbDisconnect(con_dev)

# PostgreSQL (production) — same interface:
# con_prod <- dbConnect(RPostgres::Postgres(),
#   host=Sys.getenv('PG_HOST'), dbname=Sys.getenv('PG_DB'),
#   user=Sys.getenv('PG_USER'), password=Sys.getenv('PG_PASS'))
# prod_result <- dbGetQuery(con_prod, 'SELECT COUNT(*) n FROM data')
# dbDisconnect(con_prod)

cat('Same DBI code works for both!')

Verificação rápida

Qual é a forma recomendada de fornecer as credenciais do banco de dados em um script R?

Recapitulação: conexões PostgreSQL e MySQL

Principais conclusões sobre conexões com bancos de dados em produção:

Driver do PostgreSQL: RPostgres::Postgres() com argumentos host, port, dbname, user e password
Driver do MySQL/MariaDB: RMariaDB::MariaDB() com argumentos semelhantes
Use sempre Sys.getenv('VAR') para as credenciais — nunca as insira diretamente no código
dbIsValid(con) verifica se a conexão ainda está ativa
O pacote pool gerencia conjuntos de conexões para aplicativos com alto tráfego
sqlInterpolate() evita injeção de SQL com valores fornecidos pelo usuário
Túnel SSH: encaminha uma porta local para acessar bancos de dados privados
Todas as funções DBI funcionam de forma idêntica em diferentes sistemas de banco de dados

library(DBI)
library(RSQLite)

# Production-ready connection pattern (SQLite for demo)
open_connection <- function() {
  con <- dbConnect(RSQLite::SQLite(), ':memory:')
  if (!dbIsValid(con)) stop('Failed to connect')
  cat('Connected successfully\n')
  con
}

run_query <- function(con, sql) {
  if (!dbIsValid(con)) stop('Connection lost')
  dbGetQuery(con, sql)
}

con <- open_connection()
dbWriteTable(con, 't', data.frame(x=1:3, y=4:6))
print(run_query(con, 'SELECT * FROM t'))
dbDisconnect(con)

Perguntas Frequentes

A aula “Conectando-se ao PostgreSQL e ao MySQL” é grátis?

Sim — o texto completo de “Conectando-se ao PostgreSQL e ao MySQL” é 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 “Conectando-se ao PostgreSQL e ao MySQL”?

Use os drivers RPostgres e RMySQL para se conectar a bancos de dados baseados em servidor. 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 2 de 4.

Quanto tempo leva a aula “Conectando-se ao PostgreSQL e ao MySQL”?

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