R Academy · Ders

PostgreSQL ve MySQL'e Bağlanma

Sunucu tabanlı veritabanlarına bağlanmak için RPostgres ve RMySQL sürücülerini kullanın.

PostgreSQL ve MySQL'e Bağlanma, CoddyKit'te ücretsiz bir R Academy dersidir. Bu, 4 dersinin 2. 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.

Üretim Veritabanı Bağlantıları

RSQLite geliştirme ve test için harika olsa da üretim verileri PostgreSQL, MySQL, SQL Server veya bulut veritabanlarında bulunur. DBI arayüzü aynı kalır — yalnızca sürücü paketi ve bağlantı bağımsız değişkenleri değişir. Bu, DBI'ın temel gücüdür.

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

PostgreSQL'e Bağlanma

RPostgres::Postgres(), PostgreSQL için kullanılan sürücüdür. Bağlantı parametrelerini aktarın: host, port (varsayılan 5432), dbname, user ve password. Kimlik bilgilerini asla doğrudan kod içine yazmayın — bunun yerine ortam değişkenlerini kullanın.

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

Kimlik Bilgileri için Ortam Değişkenlerini Kullanma

Parolaları kod içine doğrudan yazmak bir güvenlik riskidir. Kimlik bilgilerini ortam değişkenleri olarak saklayın ve Sys.getenv() ile okuyun. Üretimde bunları .Renviron, .env dosyalarında (git'e eklenmemiş) veya gizli bilgi yönetim sistemleri aracılığıyla ayarlayın.

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

MySQL / MariaDB'ye Bağlanma

MySQL bağlantıları RMariaDB::MariaDB() (modern MySQL sürücüsü) veya RMySQL::MySQL() kullanır. Bağlantı bağımsız değişkenleri PostgreSQL'inkilere benzerdir. Hem MySQL hem de MariaDB sunucuları için MariaDB sürücüsü önerilir.

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

Bağlantı Zaman Aşımı ve Yeniden Bağlanma

Uzun süre çalışan betikler bağlantı zaman aşımlarıyla karşılaşabilir. dbIsValid(con) ile bağlantının hâlâ geçerli olup olmadığını denetleyin. ETL betikleri için, tek bir bağlantıyı saatlerce açık tutmak yerine her işleme grubunun başında yeniden bağlanmayı değerlendirin.

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

Bağlantı Havuzlama Kavramı

Her sorgu için yeni bir veritabanı bağlantısı açmak maliyetlidir. Bağlantı havuzlama, bir dizi açık bağlantıyı korur ve bunları yeniden kullanır. Saniyede çok sayıda isteğin geldiği web API'leri ve Shiny uygulamaları için bu kritik öneme sahiptir.

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

SQL Parametreleriyle Sorgulama (Güvenli)

Kullanıcı girdisini SQL dizelerine asla birleştirmeyin (SQL ekleme riski). Değerleri güvenli biçimde eklemek için sqlInterpolate(con, sql, .dots=list(...)) ile parametreli sorgular veya glue paketindeki glue_sql() işlevini kullanın.

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)

Uzak Veritabanları için SSH Tünelleme

Üretim veritabanlarının çoğuna internet üzerinden doğrudan erişilemez. Yaygın bir yöntem SSH tünellemedir: SSH aracılığıyla yerel bir bağlantı noktasını uzak veritabanı bağlantı noktasına yönlendirin, ardından R'yi localhost:local_port adresine bağlayın.

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

Büyük Tabloları Parçalar Halinde Okuma

Bir veritabanı tablosunda milyonlarca satır olduğunda her şeyi tek seferde yüklemek belleği tüketebilir. Tabloyu parçalar halinde işlemek için LIMIT/OFFSET veya imleç tabanlı veri almayı kullanın. Akış hâlindeki sonuçlar için dbFetch() ile birlikte kullanın.

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() — Bağlantı Üst Verileri

dbGetInfo(con) bağlantı üst verilerini döndürür: sunucu sürümü, veritabanı adı, kullanıcı vb. Bu, günlük kaydı, tanılama ve birden çok ortamda çalışan betiklerde doğru veritabanı örneğine bağlandığınızı doğrulamak için kullanışlıdır.

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 ve PostgreSQL Kullanımını Karşılaştırma

Prototip oluşturma, gömülü veriler ve test için SQLite'ı; üretim ortamı, çok kullanıcılı erişim ve gelişmiş SQL özellikleri için PostgreSQL'i tercih edin. DBI kodu neredeyse aynıdır — tek fark sürücü ve bağlantı parametreleridir.

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

Kısa Kontrol

Bir R betiğinde veritabanı kimlik bilgilerini sağlamanın önerilen yolu nedir?

Özet: PostgreSQL ve MySQL Bağlantıları

Üretim veritabanı bağlantıları için önemli çıkarımlar:

PostgreSQL sürücüsü: host, port, dbname, user ve password bağımsız değişkenleriyle RPostgres::Postgres()
MySQL/MariaDB sürücüsü: benzer bağımsız değişkenlerle RMariaDB::MariaDB()
Kimlik bilgileri için her zaman Sys.getenv('VAR') kullanın — değerleri doğrudan koda yazmayın
dbIsValid(con), bağlantının hâlâ etkin olup olmadığını kontrol eder
pool paketi, yoğun trafiğe sahip uygulamalar için bağlantı havuzlarını yönetir
sqlInterpolate(), kullanıcı tarafından sağlanan değerlerle SQL enjeksiyonunu önler
SSH tüneli: özel veritabanlarına erişmek için yerel bir bağlantı noktasını yönlendirir
Tüm DBI işlevleri farklı arka uçlarda aynı şekilde çalışır

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)

Sıkça Sorulan Sorular

“PostgreSQL ve MySQL'e Bağlanma” dersi ücretsiz mi?

Evet — “PostgreSQL ve MySQL'e Bağlanma” 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.

“PostgreSQL ve MySQL'e Bağlanma” dersinde ne öğreneceğim?

Sunucu tabanlı veritabanlarına bağlanmak için RPostgres ve RMySQL sürücülerini kullanı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 2. dersidir.

“PostgreSQL ve MySQL'e Bağlanma” 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