R Academy · Ders

dbplyr: dplyr Sözdizimiyle SQL

SQL'e çevrilip veritabanında çalıştırılan dplyr kodu yazın.

3. ders / 413 adım

dbplyr: dplyr Sözdizimiyle SQL, CoddyKit'te ücretsiz bir R Academy dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, R Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. R Academy kursu toplamda 4 dersten oluşur.

dbplyr Nedir?

dbplyr, dplyr fiillerini otomatik olarak SQL'e çeviren bir R paketidir. Ham SQL yazmak yerine, bildiğiniz dplyr kodunu yazarsınız ve dbplyr bunu veritabanı arka ucunuz için doğru SQL lehçesine dönüştürür. Sorgu veritabanında çalışır — R belleğinde değil.

# install.packages(c('dbplyr', 'DBI', 'RSQLite'))
library(DBI)
library(dbplyr)
library(dplyr)

# dbplyr sits between dplyr and your database:
# Your dplyr code -> dbplyr -> SQL -> Database -> result

# Supported backends: PostgreSQL, MySQL, SQLite,
#                     SQL Server, BigQuery, Snowflake, ...

cat('dbplyr translates dplyr to SQL')

Veritabanına Bağlanma

dbplyr, bir DBI bağlantısının üzerinde çalışır. Uygun sürücü paketini kullanarak DBI::dbConnect() ile bağlantıyı kurar, ardından bu bağlantı nesnesini dbplyr işlevlerine aktarırsınız.

library(DBI)
library(dplyr)
library(dbplyr)

# SQLite example (no server needed — great for demos)
con <- dbConnect(RSQLite::SQLite(), ':memory:')

# Write a test table to the in-memory database
copy_to(con, nycflights13::flights, 'flights',
        temporary = FALSE, overwrite = TRUE)

# PostgreSQL example (real server):
# con <- dbConnect(
#   RPostgres::Postgres(),
#   host     = 'db.example.com',
#   dbname   = 'analytics',
#   user     = Sys.getenv('DB_USER'),
#   password = Sys.getenv('DB_PASS')
# )

cat('Connected to database')

tbl() — Bir Veritabanı Tablosuna Başvurma

tbl(con, 'table_name'), bir veritabanı tablosuna gecikmeli bir başvuru oluşturur. Henüz veri alınmaz — yalnızca bir işaretçi elde edersiniz. Daha sonra dplyr fiillerini bunun arkasına zincirleyebilirsiniz; dbplyr da SQL sorgusunu adım adım oluşturur.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
mtcars_df <- mtcars
dbWriteTable(con, 'cars', mtcars_df)

# Create a lazy table reference
cars_tbl <- tbl(con, 'cars')

# Printing shows top rows and indicates it is a database source
print(cars_tbl)
# Source: table<cars> [?? x 11]
# Database: sqlite 3.x [:memory:]

cat('tbl() = lazy reference, no data fetched yet')

Bir Veritabanı Tablosuna filter() Uygulama

Yerel bir veri çerçevesinde yaptığınız gibi, tbl() başvurusunun arkasına filter() zincirleyebilirsiniz. dbplyr bunu bir SQL WHERE yan tümcesine dönüştürür. Filtreleme veritabanında gerçekleşir — yalnızca eşleşen satırlar R'ye gönderilir.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'cars', mtcars)
cars_tbl <- tbl(con, 'cars')

# Filter in the database (generates WHERE clause)
high_mpg <- cars_tbl |>
  filter(mpg > 25, cyl == 4)

# Still lazy! No data fetched yet.
cat('Class:', class(high_mpg)[1], '\n')

# Collect to pull data into R:
result <- collect(high_mpg)
cat('Rows matching filter:', nrow(result))

select() ve mutate() Uygulama

select(), SQL SELECT ifadesine; mutate() ise SELECT yan tümcesindeki hesaplanan sütunlara karşılık gelir. dbplyr, SQL'de karşılığı bulunan birçok yaygın R ifadesi de dâhil olmak üzere çeviriyi yönetir.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'cars', mtcars)
cars_tbl <- tbl(con, 'cars')

# Select specific columns + add a computed column
result <- cars_tbl |>
  filter(am == 1) |>              # manual transmission
  select(mpg, cyl, hp, wt) |>    # pick columns
  mutate(wt_kg = wt * 453.592)   # add computed column

# Pull into R
df <- collect(result)
cat('Columns:', names(df), '\n')
cat('Rows:', nrow(df))

group_by() ve summarise() — Toplulaştırma

group_by() ve summarise(), toplulaştırma işlevleriyle birlikte SQL GROUP BY ifadesine dönüştürülür. Bu sayede tüm satırları önce R'ye çekmeden özetleri veritabanında hesaplayabilirsiniz — büyük tablolar için bu kritik önem taşır.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'cars', mtcars)
cars_tbl <- tbl(con, 'cars')

# Aggregate in the database
summary_tbl <- cars_tbl |>
  group_by(cyl) |>
  summarise(
    avg_mpg  = mean(mpg, na.rm = TRUE),
    max_hp   = max(hp),
    n_models = n()
  )

result <- collect(summary_tbl)
print(result)

show_query() — Oluşturulan SQL'i İnceleme

show_query(), dbplyr'nin veritabanına göndereceği SQL'i yazdırır. Bu, hata ayıklama, performans ayarlama ve dplyr kodunuzun nasıl dönüştüğünü görerek SQL öğrenme açısından son derece değerlidir.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'cars', mtcars)
cars_tbl <- tbl(con, 'cars')

# Build a query
q <- cars_tbl |>
  filter(mpg > 20) |>
  group_by(cyl) |>
  summarise(avg_mpg = mean(mpg, na.rm = TRUE))

# See the SQL dbplyr generated:
show_query(q)
# <SQL>
# SELECT cyl, AVG(mpg) AS avg_mpg
# FROM cars
# WHERE mpg > 20.0
# GROUP BY cyl

collect() — Verileri R'ye Çekme

collect(), gecikmeli sorguyu çalıştırır ve sonuçları yerel bir R veri çerçevesine (tibble) alır. collect() çağrılana kadar veritabanından R'ye hiçbir veri aktarılmaz — tüm işlemler SQL'e çevrilir ve sunucu tarafında çalıştırılır.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'cars', mtcars)
cars_tbl <- tbl(con, 'cars')

# Build up a lazy query chain
lazy_q <- cars_tbl |>
  filter(hp > 100) |>
  select(mpg, hp, cyl) |>
  arrange(desc(hp))

# Nothing fetched yet
cat('Is lazy?', inherits(lazy_q, 'tbl_sql'), '\n')

# NOW pull data into R
local_df <- collect(lazy_q)
cat('Class after collect:', class(local_df)[1], '\n')
cat('Rows:', nrow(local_df))

copy_to() — Yerel Veri Çerçevesini Veritabanına Gönderme

copy_to(), yerel bir R veri çerçevesini veritabanına (genellikle geçici) bir tablo olarak yazar. Bu, yerel arama tablolarını büyük uzak tablolarla birleştirmek veya önceden var olan bir veritabanı olmadan test yapmak için kullanışlıdır.

library(DBI)
library(dplyr)
library(dbplyr)

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

# Push a local data frame into the database
local_df <- data.frame(
  cyl       = c(4, 6, 8),
  category  = c('efficient', 'balanced', 'powerful')
)

# copy_to creates a temporary table in the DB
copy_to(con, local_df, name = 'cyl_labels', temporary = TRUE)

# Now reference it with tbl()
labels_tbl <- tbl(con, 'cyl_labels')
cat('Rows in DB table:', collect(labels_tbl) |> nrow())

Veritabanı Tablolarını Birleştirme

Aynı dplyr left_join(), inner_join() vb. işlevlerini kullanarak iki tbl() başvurusunu birleştirebilirsiniz. dbplyr bunları SQL JOIN yan tümcelerine dönüştürür — birleştirme veritabanında gerçekleşir.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'cars', mtcars)
copy_to(con, data.frame(cyl = c(4,6,8),
                         label = c('four','six','eight')),
        'cyl_ref', temporary = TRUE)

cars_tbl  <- tbl(con, 'cars')
labels_tbl <- tbl(con, 'cyl_ref')

# Join in the database
joined <- left_join(cars_tbl, labels_tbl, by = 'cyl') |>
  select(mpg, cyl, label, hp)

show_query(joined)   # See the SQL JOIN
result <- collect(joined)
cat('Joined rows:', nrow(result))

dbplyr Ne Zaman Kullanılmamalı

dbplyr her R ifadesini SQL'e çeviremez. Karmaşık özel işlevlerin, temel R tarih işlemlerinin veya R'ye özgü istatistiksel işlevlerin SQL karşılığı bulunmayabilir. Önce collect() kullanarak verileri R'ye çekin, ardından yalnızca R'de yapılabilen işlemleri yerel olarak uygulayın.

library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'cars', mtcars)
cars_tbl <- tbl(con, 'cars')

# Do as much as possible in the database:
prepped <- cars_tbl |>
  filter(mpg > 15) |>
  select(mpg, hp, cyl) |>
  collect()               # <- pull only what you need

# Now apply R-only operations locally:
cor_result <- cor(prepped$mpg, prepped$hp)
cat('Correlation mpg~hp:', round(cor_result, 3))

# Rule: filter and aggregate in DB, model in R

Kısa Kontrol

Bir tbl() veritabanı başvurusunda dplyr fiillerinden oluşan bir zincir oluşturduktan sonra, sorguyu çalıştırıp sonuçları yerel bir R veri çerçevesi olarak döndüren işlev hangisidir?

İnteraktif derste cevapla

dbplyr — Önemli Çıkarımlar

dbplyr, SQL yazmadan dplyr söz dizimiyle veritabanlarını sorgulamanızı sağlar:

tbl(con, 'table') — bir DB tablosuna gecikmeli başvuru
filter(), select(), mutate() — SQL yan tümcelerine dönüştürülür
group_by() |> summarise() — SQL GROUP BY ifadesine dönüşür
show_query() — oluşturulan SQL'i inceleyin (öğrenmek için harikadır)
collect() — sorguyu çalıştırır ve verileri R'ye çeker
copy_to() — yerel bir veri çerçevesini veritabanına gönderir
Birleştirmeler de çalışır: left_join(), inner_join() vb.
DB'de filtreleme ve toplulaştırma yapın; R'yi yalnızca SQL'in yapamadığı işlemler için kullanın

# Complete dbplyr workflow example:
library(DBI)
library(dplyr)
library(dbplyr)

con <- dbConnect(RSQLite::SQLite(), ':memory:')
dbWriteTable(con, 'sales', data.frame(
  region  = c('North','South','North','East','South'),
  revenue = c(100, 200, 150, 300, 250),
  year    = c(2023, 2023, 2024, 2024, 2024)
))

tbl(con, 'sales') |>
  filter(year == 2024) |>
  group_by(region) |>
  summarise(total = sum(revenue, na.rm = TRUE)) |>
  arrange(desc(total)) |>
  collect() |>
  print()

Başlamak ücretsiz

Yapay zeka eğitmeniyle R öğren — ücretsiz

Tarayıcında gerçek kod yaz ve çalıştır, 7/24 yapay zeka eğitmeninden anında yardım al; web'de ya da uygulamada kaldığın yerden devam et.

Kurslar: 43
Dersler: 159

Ücretsiz öğrenmeye başla Tüm kursu görüntüle

Sıkça Sorulan Sorular

“dbplyr: dplyr Sözdizimiyle SQL” dersi ücretsiz mi?

Evet — “dbplyr: dplyr Sözdizimiyle SQL” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve R Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. R Academy kursu toplamda 4 dersten oluşur.

“dbplyr: dplyr Sözdizimiyle SQL” dersinde ne öğreneceğim?

SQL'e çevrilip veritabanında çalıştırılan dplyr kodu yazın. R Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

R Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te R Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“dbplyr: dplyr Sözdizimiyle SQL” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu R Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her R Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← R Academy Sayfasına Dön