Mit PostgreSQL und MySQL verbinden
Verwenden Sie die Treiber RPostgres und RMySQL, um sich mit serverbasierten Datenbanken zu verbinden.
Mit PostgreSQL und MySQL verbinden ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des R Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.
Datenbankverbindungen für Produktivsysteme
Während RSQLite hervorragend für Entwicklung und Tests geeignet ist, liegen Produktivdaten in PostgreSQL, MySQL, SQL Server oder Cloud-Datenbanken. Die DBI-Schnittstelle bleibt gleich — nur das Treiberpaket und die Verbindungsargumente ändern sich. Das ist die zentrale Stärke von 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, dbDisconnectMit PostgreSQL verbinden
RPostgres::Postgres() ist der Treiber für PostgreSQL. Übergeben Sie die Verbindungsparameter: host, port (Standardwert 5432), dbname, user und password. Hinterlegen Sie Zugangsdaten niemals direkt im Code — verwenden Sie stattdessen Umgebungsvariablen.
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!')Umgebungsvariablen für Zugangsdaten verwenden
Passwörter direkt im Code zu hinterlegen, stellt ein Sicherheitsrisiko dar. Speichern Sie Zugangsdaten als Umgebungsvariablen und lesen Sie sie mit Sys.getenv() ein. Legen Sie sie in Produktivsystemen in .Renviron, .env-Dateien (die nicht in Git eingecheckt werden) oder über Systeme zur Verwaltung von Geheimnissen fest.
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')Mit MySQL / MariaDB verbinden
Für MySQL-Verbindungen verwenden Sie RMariaDB::MariaDB() (den modernen MySQL-Treiber) oder RMySQL::MySQL(). Die Verbindungsargumente ähneln denen von PostgreSQL. MariaDB ist der empfohlene Treiber für MySQL- und MariaDB-Server.
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.')Verbindungs-Timeout und erneute Verbindung
Bei lang laufenden Skripten kann es zu Verbindungs-Timeouts kommen. Prüfen Sie mit dbIsValid(con), ob die Verbindung noch gültig ist. Erwägen Sie bei ETL-Skripten, zu Beginn jedes Verarbeitungspakets eine neue Verbindung herzustellen, statt eine einzelne Verbindung stundenlang offen zu halten.
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))Das Konzept des Connection Pooling
Für jede Abfrage eine neue Datenbankverbindung zu öffnen, ist aufwendig. Connection Pooling hält eine Gruppe offener Verbindungen vor und verwendet sie wieder. Das ist für Web-APIs und Shiny-Apps entscheidend, bei denen pro Sekunde viele Anfragen eingehen.
# 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!')Abfragen mit SQL-Parametern (sicher)
Fügen Sie Benutzereingaben niemals durch Verkettung in SQL-Zeichenfolgen ein (Risiko einer SQL-Injection). Verwenden Sie parametrisierte Abfragen mit sqlInterpolate(con, sql, .dots=list(...)) oder glue_sql() aus dem Paket glue, um Werte sicher einzusetzen.
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)SSH-Tunneling für entfernte Datenbanken
Viele Produktivdatenbanken sind nicht direkt aus dem Internet erreichbar. Ein übliches Vorgehen ist SSH-Tunneling: Leiten Sie über SSH einen lokalen Port an den Port der entfernten Datenbank weiter und verbinden Sie R anschließend mit 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.')Große Tabellen blockweise einlesen
Wenn eine Datenbanktabelle Millionen von Zeilen enthält, kann das gleichzeitige Laden aller Daten den Speicher erschöpfen. Verwenden Sie LIMIT/OFFSET oder einen cursorbasierten Abruf, um die Tabelle blockweise zu verarbeiten. Kombinieren Sie dies mit dbFetch(), um Ergebnisse im Stream abzurufen.
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() — Metadaten der Verbindung
dbGetInfo(con) gibt Metadaten zur Verbindung zurück: Serverversion, Datenbankname, Benutzer usw. Das ist nützlich für Protokollierung und Diagnose sowie zur Überprüfung, ob Sie in Skripten, die mit mehreren Umgebungen arbeiten, mit der richtigen Datenbankinstanz verbunden sind.
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)SQLite- und PostgreSQL-Nutzung im Vergleich
Wählen Sie SQLite für Prototyping, eingebettete Daten und Tests; wählen Sie PostgreSQL für den produktiven Einsatz, den Zugriff durch mehrere Benutzer und erweiterte SQL-Funktionen. Der DBI-Code ist nahezu identisch – der einzige Unterschied besteht im Treiber und in den Verbindungsparametern.
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!')Kurzer Wissenstest
Wie sollten Datenbankzugangsdaten in einem R-Skript bereitgestellt werden?
Zusammenfassung: PostgreSQL- und MySQL-Verbindungen
Die wichtigsten Punkte für Datenbankverbindungen im produktiven Einsatz:
- PostgreSQL-Treiber:
RPostgres::Postgres()mit den Argumenten host, port, dbname, user und password - MySQL-/MariaDB-Treiber:
RMariaDB::MariaDB()mit ähnlichen Argumenten - Verwenden Sie für Zugangsdaten immer
Sys.getenv('VAR')– niemals fest codierte Werte dbIsValid(con)prüft, ob die Verbindung noch aktiv ist- Das Paket
poolverwaltet Verbindungspools für Apps mit hohem Datenverkehr sqlInterpolate()verhindert SQL-Injection bei von Benutzern bereitgestellten Werten- SSH-Tunnel: Leiten Sie einen lokalen Port weiter, um auf private Datenbanken zuzugreifen
- Alle DBI-Funktionen funktionieren backendübergreifend identisch
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)Häufig gestellte Fragen
Ist die Lektion „Mit PostgreSQL und MySQL verbinden“ kostenlos?
Ja — der vollständige Text von „Mit PostgreSQL und MySQL verbinden“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des R Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der R Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Mit PostgreSQL und MySQL verbinden“?
Verwenden Sie die Treiber RPostgres und RMySQL, um sich mit serverbasierten Datenbanken zu verbinden. Du übst R Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um R Academy zu starten?
Keine Vorkenntnisse erforderlich. R Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Mit PostgreSQL und MySQL verbinden“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser R Academy-Lektion Code schreiben und ausführen?
Ja. Jede R Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Grundlagen von DBI und RSQLite
- Mit PostgreSQL und MySQL verbinden
- dbplyr: SQL über dplyr-Syntax
- Parametrisierte Abfragen und Transaktionen