R Academy · Lekcja

Podstawy DBI i RSQLite

Łącz się z bazami danych SQLite, wykonuj zapytania i pobieraj wyniki za pomocą DBI.

Podstawy DBI i RSQLite to bezpłatna lekcja R Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej R Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs R Academy zawiera 4 lekcji w sumie.

Dostęp do baz danych w R za pomocą DBI

Pakiet DBI udostępnia ujednolicony interfejs dostępu do baz danych w R. Te same funkcje działają z różnymi bazami danych (SQLite, PostgreSQL, MySQL itd.) dzięki połączeniu DBI z pakietem sterownika odpowiednim dla danej bazy. RSQLite to najbardziej przystępny backend — nie wymaga instalacji serwera.

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() — tworzenie połączenia

dbConnect(drv, ...) tworzy połączenie z bazą danych. Pierwszym argumentem jest obiekt sterownika. Dla SQLite jest to RSQLite::SQLite(). Dodatkowe argumenty (takie jak ścieżka do pliku bazy danych) zależą od backendu.

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() — ładowanie danych do bazy

dbWriteTable(con, 'table_name', df) tworzy tabelę i ładuje do niej ramkę danych. Ustawienie overwrite=TRUE zastępuje istniejącą tabelę, a append=TRUE dodaje wiersze do istniejącej tabeli.

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() i dbListFields()

dbListTables(con) zwraca nazwy wszystkich tabel w połączonej bazie danych. dbListFields(con, 'table') zwraca nazwy kolumn określonej tabeli. Funkcje te służą do poznawania nieznanej bazy danych.

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() — wykonywanie SQL i zwracanie danych

dbGetQuery(con, sql) wykonuje zapytanie SELECT i zwraca wynik jako ramkę danych. Jest to podstawowa funkcja do odczytywania danych z bazy. Łączy działanie dbSendQuery() + dbFetch() + dbClearResult() w jednym kroku.

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() — pobieranie wyników partiami

W przypadku dużych zbiorów wyników należy użyć podejścia trzyetapowego: dbSendQuery() wysyła zapytanie, dbFetch(con, n=1000) pobiera partie po n wierszy, a dbClearResult() wykonuje sprzątanie. Pozwala to kontrolować zużycie pamięci w przypadku dużych tabel.

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() — wykonywanie SQL innego niż SELECT

dbExecute(con, sql) wykonuje instrukcje SQL modyfikujące dane (INSERT, UPDATE, DELETE, CREATE, DROP) i zwraca liczbę zmodyfikowanych wierszy. Należy używać tej funkcji do operacji DDL i DML, które nie zwracają wierszy.

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

dbExistsTable(con, 'name') sprawdza, czy tabela istnieje (zwraca TRUE/FALSE). dbRemoveTable(con, 'name') usuwa tabelę. Funkcje te są przydatne do bezpiecznego przygotowywania i sprzątania w skryptach, które mogą być uruchamiane wielokrotnie.

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() — zamykanie połączeń

Po zakończeniu pracy należy zawsze zamknąć połączenia z bazą danych za pomocą dbDisconnect(con). Otwarte połączenia zużywają pamięć i uchwyty plików. Wewnątrz funkcji należy użyć on.exit(dbDisconnect(con)), aby zagwarantować sprzątanie nawet w przypadku wystąpienia błędu.

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)

Ładowanie mtcars do SQLite

Praktyczny przykład: załaduj wbudowany zbiór danych mtcars do SQLite, a następnie wykonuj na nim zapytania SQL. Ten przykład pokazuje pełny przebieg pracy z DBI i umożliwia ćwiczenie SQL z poziomu 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)

Podsumowanie przebiegu pracy z DBI

Przebieg pracy z DBI jest zgodny ze stałym schematem niezależnie od backendu bazy danych: Połącz → Załaduj/Wykonaj zapytanie → Rozłącz. Ten sam kod działa z SQLite, PostgreSQL, MySQL i innymi bazami po zamianie sterownika w 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)

Szybkie sprawdzenie

Jaka jest różnica między dbGetQuery() a dbExecute() w DBI?

Podsumowanie: DBI i RSQLite

Najważniejsze informacje dotyczące DBI i RSQLite:

dbConnect(RSQLite::SQLite(), ':memory:') — tworzy połączenie z bazą SQLite w pamięci
dbWriteTable(con, 'name', df) — ładuje ramkę danych do tabeli
dbListTables(con) — wyświetla tabele; dbListFields(con, 'tbl') — wyświetla kolumny
dbGetQuery(con, sql) — wykonuje SELECT i zwraca ramkę danych
dbFetch(rs, n=1000) — pobieranie dużych wyników partiami
dbExecute(con, sql) — wykonuje INSERT/UPDATE/DELETE/DDL
dbDisconnect(con) — zawsze zamyka połączenie; w funkcjach należy używać on.exit()
DBI współpracuje z PostgreSQL, MySQL, BigQuery itd. po zamianie sterownika

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

Często zadawane pytania

Czy lekcja „Podstawy DBI i RSQLite” jest bezpłatna?

Tak — pełny tekst „Podstawy DBI i RSQLite” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu R Academy, przejdź na CoddyKit PRO. Kurs R Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Podstawy DBI i RSQLite”?

Łącz się z bazami danych SQLite, wykonuj zapytania i pobieraj wyniki za pomocą DBI. Ćwiczysz R Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć R Academy?

Nie wymagamy żadnego doświadczenia. R Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Podstawy DBI i RSQLite”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji R Academy?

Tak. Każda lekcja R Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do R Academy