Grundlagen von DBI und RSQLite
Verbinden Sie sich mit SQLite-Datenbanken, führen Sie Abfragen aus und rufen Sie Ergebnisse mit DBI ab.
Grundlagen von DBI und RSQLite ist eine kostenlose R Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.
Datenbankzugriff in R mit DBI
Das Paket DBI stellt eine einheitliche Schnittstelle für den Datenbankzugriff in R bereit. Dieselben Funktionen funktionieren mit verschiedenen Datenbank-Backends (SQLite, PostgreSQL, MySQL usw.), indem DBI mit einem passenden Backend-Treiberpaket kombiniert wird. RSQLite ist das am einfachsten zugängliche Backend — es erfordert keine Serverinstallation.
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() — Eine Verbindung herstellen
dbConnect(drv, ...) stellt eine Datenbankverbindung her. Das erste Argument ist das Treiberobjekt. Für SQLite lautet es: RSQLite::SQLite(). Weitere Argumente (z. B. der Pfad zur Datenbankdatei) hängen vom Backend ab.
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() — Daten in eine Datenbank laden
dbWriteTable(con, 'table_name', df) erstellt eine Tabelle und lädt einen Dataframe hinein. Setzen Sie overwrite=TRUE, um eine vorhandene Tabelle zu ersetzen, oder append=TRUE, um Zeilen an eine vorhandene Tabelle anzuhängen.
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() und dbListFields()
dbListTables(con) gibt die Namen aller Tabellen in der verbundenen Datenbank zurück. dbListFields(con, 'table') gibt die Spaltennamen einer bestimmten Tabelle zurück. Verwenden Sie diese Funktionen, um eine unbekannte Datenbank zu erkunden.
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() — SQL ausführen und Daten zurückgeben
dbGetQuery(con, sql) führt eine SELECT-Abfrage aus und gibt das Ergebnis als Dataframe zurück. Dies ist die wichtigste Funktion zum Lesen von Daten aus einer Datenbank. Sie kombiniert dbSendQuery(), dbFetch() und dbClearResult() in einem Schritt.
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() — Ergebnisse in Blöcken abrufen
Für große Ergebnismengen verwenden Sie den dreistufigen Ansatz: dbSendQuery() sendet die Abfrage, dbFetch(con, n=1000) ruft Blöcke mit jeweils n Zeilen ab und dbClearResult() räumt auf. So lässt sich der Speicherverbrauch bei großen Tabellen kontrollieren.
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() — Nicht-SELECT-SQL ausführen
dbExecute(con, sql) führt SQL-Anweisungen aus, die Daten ändern (INSERT, UPDATE, DELETE, CREATE, DROP), und gibt die Anzahl der betroffenen Zeilen zurück. Verwenden Sie die Funktion für DDL- und DML-Operationen, die keine Zeilen zurückgeben.
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() und dbRemoveTable()
dbExistsTable(con, 'name') prüft, ob eine Tabelle vorhanden ist (gibt TRUE/FALSE zurück). dbRemoveTable(con, 'name') löscht eine Tabelle. Diese Funktionen sind nützlich für einen sicheren Aufbau und Abbau in Skripten, die mehrmals ausgeführt werden können.
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() — Verbindungen schließen
Schließen Sie Datenbankverbindungen immer mit dbDisconnect(con), sobald Sie sie nicht mehr benötigen. Offene Verbindungen verbrauchen Speicher und Dateihandles. Verwenden Sie innerhalb von Funktionen on.exit(dbDisconnect(con)), um die Bereinigung auch im Fehlerfall sicherzustellen.
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)mtcars in SQLite laden
Ein praktisches Beispiel: Laden Sie den integrierten Datensatz mtcars in SQLite und führen Sie anschließend SQL-Abfragen darauf aus. Damit lernen Sie den vollständigen DBI-Ablauf kennen und können SQL aus R heraus üben.
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)Zusammenfassung des DBI-Ablaufs
Der DBI-Ablauf folgt unabhängig vom Datenbank-Backend einem einheitlichen Muster: Verbinden → Laden/Abfragen → Trennen. Derselbe Code funktioniert für SQLite, PostgreSQL, MySQL und andere Systeme, indem Sie den Treiber in dbConnect() austauschen.
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)Schnelltest
Was ist der Unterschied zwischen dbGetQuery() und dbExecute() in DBI?
Zusammenfassung: DBI und RSQLite
Die wichtigsten Punkte zu DBI und RSQLite:
dbConnect(RSQLite::SQLite(), ':memory:')— erstellt eine SQLite-Verbindung im ArbeitsspeicherdbWriteTable(con, 'name', df)— lädt einen Dataframe in eine TabelledbListTables(con)— listet Tabellen auf;dbListFields(con, 'tbl')— listet Spalten aufdbGetQuery(con, sql)— führt SELECT aus und gibt einen Dataframe zurückdbFetch(rs, n=1000)— blockweises Abrufen großer ErgebnissedbExecute(con, sql)— führt INSERT/UPDATE/DELETE/DDL ausdbDisconnect(con)— Verbindung immer schließen; in Funktionenon.exit()verwenden- DBI funktioniert mit PostgreSQL, MySQL, BigQuery usw., indem Sie den Treiber austauschen
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')Häufig gestellte Fragen
Ist die Lektion „Grundlagen von DBI und RSQLite“ kostenlos?
Ja — der vollständige Text von „Grundlagen von DBI und RSQLite“ 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 „Grundlagen von DBI und RSQLite“?
Verbinden Sie sich mit SQLite-Datenbanken, führen Sie Abfragen aus und rufen Sie Ergebnisse mit DBI ab. 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 1 von 4.
Wie lange dauert die Lektion „Grundlagen von DBI und RSQLite“?
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