Pandas & NumPy Academy · Ders

Pandas'tan SQL Sorguları Çalıştırma

pd.read_sql_query ile rastgele SELECT ifadelerini çalıştırın ve SQL enjeksiyonunu önlemek için sorguları güvenli biçimde parametreleştirin.

Pandas'tan SQL Sorguları Çalıştırma, CoddyKit'te ücretsiz bir Pandas & NumPy 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, Pandas & NumPy Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Pandas & NumPy Academy kursu toplamda 4 dersten oluşur.

pd.read_sql: Birleşik Arayüz

Pandas, üç SQL okuma işlevi sunar: pd.read_sql() (genel sarmalayıcı), pd.read_sql_table() (adı verilen bir tablonun tamamını okur) ve pd.read_sql_query() (rastgele SQL çalıştırır). Çoğu analitik iş akışında pd.read_sql_query() en güçlü seçenektir; çünkü veriler Pandas'a ulaşmadan önce filtreleme, birleştirme ve toplulaştırma içeren herhangi bir SELECT ifadesi yazmanıza olanak tanır. Ağır işlemleri SQL'e, son analizi ise Pandas'a bırakmak, her şeyi yükleyip Python'da filtrelemekten çoğu zaman daha verimlidir.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///ecommerce.db')

# Three equivalent patterns
df1 = pd.read_sql('SELECT * FROM orders LIMIT 100', con=engine)
df2 = pd.read_sql_table('orders', con=engine)  # full table
df3 = pd.read_sql_query('SELECT * FROM orders LIMIT 100', con=engine)

print(df3.head())
print(df3.columns.tolist())

Veritabanı Düzeyinde Filtreleme

Her şeyi yükleyip Pandas'ta filtrelemek yerine verileri her zaman SQL içinde filtreleyin. Uygun dizinlere sahip bir veritabanı, milyonlarca satır üzerinde bir WHERE koşulunu çalıştırıp yalnızca binlerce satırı milisaniyeler içinde döndürebilir; Pandas ise önce gigabaytlarca veriyi yüklemek zorunda kalır. Altın kural şudur: koşulları veritabanına taşıyın. Satır filtreleri için WHERE, sütun seçimi için SELECT col1, col2 ve geliştirme sırasında sonuçları hızlıca önizlemek için LIMIT kullanın.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///sales.db')

# Filter and project at SQL level — only fetch what you need
query = '''
    SELECT order_id, customer_id, amount, status
    FROM orders
    WHERE status = 'completed'
      AND order_date >= '2024-01-01'
      AND amount > 50
    LIMIT 1000
'''

df = pd.read_sql_query(query, con=engine)
print(f'Rows: {len(df)}, Columns: {list(df.columns)}')

SQL ile Pandas'ta Toplulaştırma Karşılaştırması

Büyük tablolar üzerinde basit grup düzeyi özetlerde SQL toplulaştırmaları Pandas'tan daha iyi performans gösterir; çünkü veritabanı engine'i dizinlerden, paralel yürütmeden ve diskteki karma toplulaştırmadan yararlanabilir. Tablo büyük olduğunda GROUP BY ve SUM/COUNT/AVG için SQL kullanın. Toplulaştırılmış sonucu (küçük bir DataFrame'i) daha ileri analiz, görselleştirme veya diğer verilerle birleştirme için Pandas'a yükleyin. SQL'in ifade edemediği karmaşık özel toplulaştırmalar için filtrelenmiş bir alt kümeyi Pandas'a yükleyip groupby'ı orada kullanın.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///sales.db')

# Aggregate in SQL — returns a small result set
query = '''
    SELECT region,
           COUNT(*) AS order_count,
           ROUND(SUM(amount), 2) AS total_revenue,
           ROUND(AVG(amount), 2) AS avg_order_value
    FROM orders
    WHERE status = 'completed'
    GROUP BY region
    ORDER BY total_revenue DESC
'''

df = pd.read_sql_query(query, con=engine)
print(df)

SQL Sorgularında JOIN'ler

SQL JOIN işlemleri, büyük tablolardaki birleştirmelerde Pandas merge() işleminden daha verimlidir; çünkü veritabanı dizinli aramalardan yararlanabilir. Birleştirmenizi SQL içinde yazın ve Pandas'ta önceden birleştirilmiş, muhtemelen filtrelenmiş bir sonuç alın. Birden çok tabloyla yapılan analizlerde, birden çok JOIN içeren tek bir SQL sorgusu genellikle her tabloyu ayrı ayrı okuyup Pandas'ta birleştirmekten daha hızlıdır; özellikle tablolardan biri milyonlarca satır içeriyor ve birleştirme sonucu önemli ölçüde küçültüyorsa.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///ecommerce.db')

query = '''
    SELECT o.order_id,
           c.customer_name,
           c.country,
           p.product_name,
           o.amount
    FROM orders o
    JOIN customers c ON o.customer_id = c.id
    JOIN products p ON o.product_id = p.id
    WHERE o.status = 'completed'
    LIMIT 500
'''

df = pd.read_sql_query(query, con=engine)
print(df.head())

Sorgularda Python Değişkenlerini Kullanma

Python değişkenlerini SQL sorgularına güvenli şekilde eklemek için SQLAlchemy'nin adlandırılmış parametrelerle text() işlevini kullanın. Sorgu dizesinde :param_name ile yer tutucular tanımlayın ve read_sql_query işlevinin params bağımsız değişkenine bir sözlük geçirin. Bu yöntem hem tek değerlerle hem de bazı veritabanlarında listelerle çalışır. Değişkenlerden sorgu dizeleri oluşturmak için f-dizelerinden veya % biçimlendirmesinden kaçının; bunlar dahili kullanımda bile güvenli değildir.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///sales.db')

# Python variables to inject
min_amount = 200.0
start_date = '2024-01-01'
end_date = '2024-12-31'

query = sa.text('''
    SELECT * FROM orders
    WHERE amount > :min_amount
      AND order_date BETWEEN :start_date AND :end_date
''')

with engine.connect() as conn:
    df = pd.read_sql_query(query, con=conn,
                           params={'min_amount': min_amount,
                                   'start_date': start_date,
                                   'end_date': end_date})
print(f'{len(df)} orders found')

CTE'leri ve Alt Sorguları Kullanma

Karmaşık analizler çoğu zaman Ortak Tablo İfadeleri (CTE'ler) veya alt sorgular gerektirir. Bunlar pd.read_sql_query tarafından tamamen desteklenir; çok cümleli SQL'in tamamını sorgu dizesi olarak geçirmeniz yeterlidir. WITH anahtar sözcüğüyle başlatılan CTE'ler, ara sonuçları adlandırarak karmaşık sorguları daha okunabilir hâle getirir. Bu özellik, çalışan toplam hesaplamaları, gruplar içindeki sıralamalar ve Pandas'ta ayrıntılı olacak çok adımlı filtrelemeler için kullanışlıdır.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///sales.db')

query = '''
    WITH monthly_revenue AS (
        SELECT strftime('%Y-%m', order_date) AS month,
               SUM(amount) AS revenue
        FROM orders
        WHERE status = 'completed'
        GROUP BY month
    )
    SELECT month,
           revenue,
           revenue - LAG(revenue) OVER (ORDER BY month)
               AS month_over_month_change
    FROM monthly_revenue
    ORDER BY month
'''

df = pd.read_sql_query(query, con=engine)
print(df.tail())

DatetimeIndex ile Okuma

Bir veritabanından zaman serisi verilerini okurken, index_col='date_column' ve parse_dates=['date_column'] değerlerini read_sql_query işlevine geçirerek zaman damgası sütununu DataFrame'in dizini olarak ayarlayın. Böylece doğrudan bir DatetimeIndex elde eder, ek son işleme adımlarına gerek kalmadan Pandas'ın zamana dayalı dilimleme (df['2024-01']), yeniden örnekleme ve rolling hesaplamalarını etkinleştirirsiniz. parse_dates bağımsız değişkeni, Pandas'a sütunu datetime64 türüne dönüştürmesini söyler.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///metrics.db')

df = pd.read_sql_query(
    'SELECT recorded_at, metric_value FROM daily_metrics ORDER BY recorded_at',
    con=engine,
    index_col='recorded_at',
    parse_dates=['recorded_at']
)
print(df.index.dtype)   # datetime64[ns]
print(df['2024-06'])    # Slice by month directly

Yavaş Sorguların Profilini Çıkarma

Bir sorgu yavaş olduğunda, veritabanının yürütme planını görmek için SELECT ifadenizden önce SQL anahtar sözcüğü EXPLAIN'i (veya SQLite'ta EXPLAIN QUERY PLAN) ekleyin. Dizin aramalarını beklediğiniz yerlerde tam tablo taramalarına ('SCAN TABLE') bakın; buralarda 'SEARCH TABLE' görülmesi gerekir. WHERE ve JOIN sütunlarında eksik dizinler, yavaş sorguların en yaygın nedenidir. Veritabanında uygun dizini oluşturun ve Pandas veri işleme hattını yeniden çalıştırmadan önce EXPLAIN ile tekrar kontrol edin.

import sqlalchemy as sa

engine = sa.create_engine('sqlite:///sales.db')

# Check if the query uses an index
with engine.connect() as conn:
    plan = conn.execute(sa.text(
        'EXPLAIN QUERY PLAN SELECT * FROM orders WHERE customer_id = 42'
    )).fetchall()
    for row in plan:
        print(row)
    # Look for 'SEARCH TABLE orders USING INDEX' — not 'SCAN TABLE'

Büyük Sonuç Kümelerinde Sayfalama

Büyük bir sonuç kümesini etkileşimli olarak yinelerken (örneğin sonuçların her seferinde bir sayfasını işlerken), sayfalama uygulamak için SQL LIMIT ve OFFSET kullanın. Her seferinde N satır alın, bunları işleyin, ardından sonraki N satırı alın. İmleci koruyan chunksize yaklaşımından daha az verimli olsa da sayfalama, satırların bir raporda artımlı olarak gösterilmesi gerektiğinde veya birden çok sorgunun sonuçları birleştirildiğinde kullanışlıdır.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///sales.db')
page_size = 10000
offset = 0

while True:
    query = sa.text(
        'SELECT * FROM orders ORDER BY order_id LIMIT :limit OFFSET :offset'
    )
    with engine.connect() as conn:
        df = pd.read_sql_query(query, con=conn,
                               params={'limit': page_size, 'offset': offset})
    if len(df) == 0:
        break
    print(f'Page at offset {offset}: {len(df)} rows')
    offset += page_size

SQL Sorgularını Pandas Mantığıyla Birleştirme

En güçlü düzen karma veri işleme hattıdır: kaba düzeyde filtreleme ve toplulaştırma için SQL'i, SQL'in kullanışsız biçimde ifade ettiği ince ayrıntılı dönüşümler için Pandas'ı kullanın (özet tablolar, dize ayrıştırma, apply işlevleri, rolling pencereleri). SQL'den yönetilebilir bir sonuç kümesi (binlerce satır) okuyun, ardından elde edilen DataFrame üzerinde Pandas işlemlerini zincirleyin. Bu yaklaşım, verilerin tek bir Python sürecinden geçmesini sağlarken her iki aracın güçlü yönlerini birleştirir.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///sales.db')

# SQL: coarse filter and join
df = pd.read_sql_query('''
    SELECT o.customer_id, o.amount, o.order_date, c.country
    FROM orders o JOIN customers c ON o.customer_id = c.id
    WHERE o.status = 'completed'
''', con=engine, parse_dates=['order_date'])

# Pandas: rolling 30-day revenue per country
df = df.sort_values('order_date')
df['rolling_30d'] = (
    df.groupby('country')['amount']
    .transform(lambda x: x.rolling('30D').sum())
)
print(df.head())

Veritabanı Sorgularında Hata İşleme

Veritabanı sorguları ağ zaman aşımları, söz dizimi hataları veya kaybolan bağlantılar nedeniyle başarısız olabilir. Bağlantı sorunları için sqlalchemy.exc.OperationalError, SQL söz dizimi hataları için sqlalchemy.exc.ProgrammingError yakalayan try-except bloklarıyla veritabanı çağrılarını sarın. Hatayı bağlam bilgileriyle (sorgu, parametreler) günlüğe kaydedin ve üstel beklemeyle yeniden deneyin veya işlemi kontrollü biçimde sonlandırın. Üretim veri işleme hatlarında geçici hataları (yeniden denenebilir) kalıcı hatalardan (SQL'in düzeltilmesi gerekir) ayırmak çok önemlidir.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///sales.db')

try:
    df = pd.read_sql_query(
        'SELECT * FROM nonexistent_table',
        con=engine
    )
except sa.exc.OperationalError as e:
    print(f'Connection or table error: {e}')
except sa.exc.ProgrammingError as e:
    print(f'SQL syntax error: {e}')
except Exception as e:
    print(f'Unexpected error: {type(e).__name__}: {e}')

Kısa Kontrol

Bu dersteki Veri Analizi kavramlarını anlayıp anlamadığınızı test edin.

Ders Özeti

Bu derste şunları öğrendiniz: pd.read_sql_query() herhangi bir SQL SELECT ifadesini çalıştırır ve bir DataFrame döndürür; filtreleri ve toplulaştırmaları SQL'e taşımak, tam tabloları Pandas'a yüklemekten daha verimlidir; karma veri işleme hatları, kaba veri azaltma için SQL'i, ayrıntılı özel dönüşümler için Pandas'ı birleştirir. Sırada DataFrame'leri veritabanı tablolarına geri yazmayı öğreneceğiz.

Sıkça Sorulan Sorular

“Pandas'tan SQL Sorguları Çalıştırma” dersi ücretsiz mi?

Evet — “Pandas'tan SQL Sorguları Çalıştırma” 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 Pandas & NumPy Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Pandas & NumPy Academy kursu toplamda 4 dersten oluşur.

“Pandas'tan SQL Sorguları Çalıştırma” dersinde ne öğreneceğim?

pd.read_sql_query ile rastgele SELECT ifadelerini çalıştırın ve SQL enjeksiyonunu önlemek için sorguları güvenli biçimde parametreleştirin. Pandas & NumPy 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.

Pandas & NumPy Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Pandas & NumPy 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.

“Pandas'tan SQL Sorguları Çalıştırma” 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 Pandas & NumPy Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Pandas & NumPy 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

SQLAlchemy ile Veritabanına Bağlanma
Pandas'tan SQL Sorguları Çalıştırma
DataFrame'leri Veritabanı Tablolarına Yazma
Pandas ve SQL: Doğru Aracı Seçme

← Pandas & NumPy Academy Sayfasına Dön