Pandas & NumPy Academy · Pelajaran

Menjalankan Kueri SQL dari Pandas

Jalankan pernyataan SELECT arbitrer dengan pd.read_sql_query dan buat parameter kueri dengan aman untuk mencegah injeksi SQL.

Pelajaran 2 dari 413 langkah

Menjalankan Kueri SQL dari Pandas adalah pelajaran Pandas & NumPy Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Pandas & NumPy Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Pandas & NumPy Academy mencakup 4 pelajaran total.

pd.read_sql: Antarmuka Terpadu

Pandas menyediakan tiga fungsi pembacaan SQL: pd.read_sql() (pembungkus umum), pd.read_sql_table() (membaca seluruh tabel berdasarkan nama), dan pd.read_sql_query() (menjalankan SQL arbitrer). Untuk sebagian besar alur kerja analitis, pd.read_sql_query() paling kuat karena memungkinkan Anda menulis pernyataan SELECT apa pun dengan pemfilteran, penggabungan, dan agregasi sebelum data mencapai Pandas. Menggunakan SQL untuk pekerjaan berat dan Pandas untuk analisis akhir sering kali lebih efisien daripada memuat semuanya lalu memfilter di Python.

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

Memfilter pada Tingkat Basis Data

Selalu filter data dalam SQL, bukan dengan memuat semuanya lalu memfilternya di Pandas. Basis data dengan indeks yang tepat dapat menjalankan klausa WHERE pada jutaan baris dan mengembalikan hanya ribuan baris dalam hitungan milidetik, sedangkan Pandas harus memuat data berukuran gigabita terlebih dahulu. Aturan utamanya: kirim predikat ke basis data. Gunakan WHERE untuk memfilter baris, SELECT col1, col2 untuk memilih kolom, dan LIMIT selama pengembangan untuk melihat pratinjau hasil dengan cepat.

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

Melakukan Agregasi dalam SQL vs Pandas

Untuk ringkasan sederhana per kelompok pada tabel besar, agregasi SQL mengungguli Pandas karena mesin basis data dapat menggunakan indeks, eksekusi paralel, dan agregasi hash pada disk. Gunakan SQL untuk GROUP BY dan SUM/COUNT/AVG ketika tabel berukuran besar. Muat hasil agregasi (DataFrame kecil) ke Pandas untuk analisis lanjutan, visualisasi, atau penggabungan dengan data lain. Untuk agregasi khusus yang kompleks dan tidak dapat dinyatakan dalam SQL, muat subset yang telah difilter ke Pandas dan gunakan groupby di sana.

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)

JOIN dalam Kueri SQL

Operasi JOIN SQL lebih efisien daripada merge() Pandas untuk penggabungan pada tabel besar karena basis data dapat menggunakan pencarian terindeks. Tulis penggabungan Anda dalam SQL dan terima hasil yang telah digabungkan, serta mungkin telah difilter, di Pandas. Untuk analisis banyak tabel, satu kueri SQL dengan beberapa JOIN biasanya lebih cepat daripada membaca setiap tabel secara terpisah lalu menggabungkannya di Pandas, terutama ketika salah satu tabel memiliki jutaan baris dan penggabungan tersebut secara signifikan mengurangi hasil.

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

Menggunakan Variabel Python dalam Kueri

Untuk memasukkan variabel Python ke dalam kueri SQL dengan aman, gunakan text() SQLAlchemy dengan parameter bernama. Tentukan penampung dengan :param_name dalam string kueri, lalu teruskan kamus ke argumen params pada read_sql_query. Cara ini berfungsi untuk nilai tunggal dan — pada beberapa basis data — untuk daftar. Hindari f-string atau pemformatan % untuk membuat string kueri dari variabel; keduanya tidak aman bahkan untuk penggunaan internal.

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

Menggunakan CTE dan Subkueri

Analisis kompleks sering memerlukan Ekspresi Tabel Umum (CTE) atau subkueri. Keduanya didukung sepenuhnya oleh pd.read_sql_query — cukup teruskan seluruh SQL yang terdiri dari beberapa klausa sebagai string kueri. CTE (diawali dengan kata kunci WITH) membuat kueri kompleks lebih mudah dibaca dengan memberi nama pada hasil antara. Cara ini berguna untuk menghitung total berjalan, menentukan peringkat dalam kelompok, dan melakukan pemfilteran bertahap yang akan menjadi panjang jika dilakukan di Pandas.

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

Membaca dengan DatetimeIndex

Saat membaca data deret waktu dari basis data, tetapkan kolom penanda waktu sebagai indeks DataFrame dengan meneruskan index_col='date_column' dan parse_dates=['date_column'] ke read_sql_query. Dengan demikian, Anda langsung mendapatkan DatetimeIndex, yang memungkinkan pengirisan berbasis waktu Pandas (df['2024-01']), pengambilan sampel ulang, dan penghitungan bergulir tanpa langkah pemrosesan pascamuat tambahan. Argumen parse_dates memberi tahu Pandas untuk mengonversi kolom menjadi datetime64.

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

Menganalisis Kinerja Kueri Lambat

Ketika sebuah kueri berjalan lambat, tambahkan kata kunci SQL EXPLAIN (atau EXPLAIN QUERY PLAN di SQLite) sebelum SELECT untuk melihat rencana eksekusi basis data. Cari pemindaian seluruh tabel ('SCAN TABLE') ketika Anda mengharapkan pencarian menggunakan indeks ('SEARCH TABLE'). Indeks yang tidak ada pada kolom WHERE dan JOIN adalah penyebab paling umum kueri berjalan lambat. Buat indeks yang sesuai di basis data, lalu periksa kembali dengan EXPLAIN sebelum menjalankan ulang alur kerja Pandas.

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'

Paginasi untuk Kumpulan Hasil Berukuran Besar

Ketika melakukan iterasi pada kumpulan hasil berukuran besar secara interaktif (misalnya, memproses satu halaman hasil setiap kali), gunakan SQL LIMIT dan OFFSET untuk menerapkan paginasi. Ambil N baris setiap kali, proses baris tersebut, lalu ambil N baris berikutnya. Meskipun cara ini kurang efisien dibandingkan pendekatan chunksize (yang mempertahankan kursor), paginasi berguna ketika baris harus ditampilkan secara bertahap dalam laporan atau ketika menggabungkan hasil dari beberapa kueri.

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

Menggabungkan Kueri SQL dengan Logika Pandas

Pola yang paling kuat adalah alur kerja hibrida: gunakan SQL untuk pemfilteran dan agregasi tingkat kasar, lalu gunakan Pandas untuk transformasi tingkat detail yang sulit diekspresikan dalam SQL (tabel pivot, penguraian string, fungsi apply, jendela bergulir). Baca kumpulan hasil yang ukurannya mudah dikelola dari SQL (ribuan baris), lalu rangkai operasi Pandas pada DataFrame yang dihasilkan. Cara ini menggabungkan keunggulan kedua alat sekaligus menjaga data tetap mengalir melalui satu proses Python.

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

Penanganan Kesalahan untuk Kueri Basis Data

Kueri basis data dapat gagal karena waktu tunggu jaringan habis, kesalahan sintaks, atau koneksi terputus. Bungkus pemanggilan basis data dalam blok try-except yang menangkap sqlalchemy.exc.OperationalError untuk masalah koneksi dan sqlalchemy.exc.ProgrammingError untuk kesalahan sintaks SQL. Catat kesalahan tersebut beserta konteksnya (kueri, parameter), lalu coba lagi dengan jeda eksponensial atau tangani kegagalan secara baik. Dalam alur kerja produksi, membedakan kesalahan sementara (dapat dicoba lagi) dari kesalahan permanen (SQL perlu diperbaiki) sangat penting.

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

Pemeriksaan Singkat

Uji pemahaman Anda tentang konsep Analisis Data dari pelajaran ini.

Jawab di pelajaran interaktif

Ringkasan Pelajaran

Dalam pelajaran ini Anda mempelajari bahwa pd.read_sql_query() menjalankan SELECT SQL apa pun dan mengembalikan DataFrame, mendorong filter dan agregasi ke SQL lebih efisien daripada memuat seluruh tabel ke dalam Pandas, dan alur kerja hibrida menggabungkan SQL untuk pengurangan data tingkat kasar dengan Pandas untuk transformasi khusus tingkat detail. Selanjutnya, kita akan mempelajari cara menulis DataFrame kembali ke tabel basis data.

Gratis untuk memulai

Belajar Python dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 30
Pelajaran: 120

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menjalankan Kueri SQL dari Pandas” gratis?

Ya — teks lengkap “Menjalankan Kueri SQL dari Pandas” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Pandas & NumPy Academy, upgrade ke CoddyKit PRO. Kursus Pandas & NumPy Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Menjalankan Kueri SQL dari Pandas”?

Jalankan pernyataan SELECT arbitrer dengan pd.read_sql_query dan buat parameter kueri dengan aman untuk mencegah injeksi SQL. Kamu berlatih Pandas & NumPy Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Pandas & NumPy Academy?

Tidak diperlukan pengalaman sebelumnya. Pandas & NumPy Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Menjalankan Kueri SQL dari Pandas” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Pandas & NumPy Academy ini?

Ya. Setiap pelajaran Pandas & NumPy Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Menghubungkan ke Basis Data dengan SQLAlchemy
Menjalankan Kueri SQL dari Pandas
Menulis DataFrames ke Tabel Basis Data
Pandas vs. SQL: Memilih Alat yang Tepat

← Kembali ke Pandas & NumPy Academy