Pandas & NumPy Academy · Pelajaran

Menghubungkan ke Basis Data dengan SQLAlchemy

Buat mesin SQLAlchemy untuk SQLite dan PostgreSQL, lalu teruskan ke pd.read_sql untuk memuat tabel ke dalam DataFrame.

Menghubungkan ke Basis Data dengan SQLAlchemy adalah pelajaran Pandas & NumPy Academy gratis di CoddyKit. Ini adalah pelajaran 1 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.

Mengapa Menghubungkan Pandas ke Basis Data?

Sebagian besar data produksi berada di basis data relasional — PostgreSQL, MySQL, SQLite, atau SQL Server — bukan dalam berkas CSV. Menghubungkan Pandas langsung ke basis data memungkinkan Anda menguerikan data ke dalam DataFrame tanpa mengekspornya ke CSV terlebih dahulu, mengirim kembali DataFrame yang telah dibersihkan ke dalam tabel, serta menggabungkan kemampuan analitis Python dengan kemampuan pengindeksan dan penggabungan milik basis data. Penghubung antara Pandas dan basis data adalah SQLAlchemy, pustaka abstraksi basis data standar untuk Python.

Memasang SQLAlchemy

SQLAlchemy adalah perangkat SQL dan ORM untuk Python. Untuk integrasi dengan Pandas, Anda hanya memerlukan lapisan Core — bukan ORM. Pasang dengan pip install sqlalchemy. Anda juga memerlukan pengandar basis data tertentu: psycopg2 untuk PostgreSQL, pymysql untuk MySQL, atau sqlite3 (sudah terpasang di Python) untuk SQLite. SQLAlchemy bertindak sebagai lapisan abstraksi: kode Pandas yang sama dapat digunakan dengan basis data apa pun yang didukung, cukup dengan mengubah string koneksi.

# Install dependencies
# pip install sqlalchemy psycopg2-binary  # for PostgreSQL
# pip install sqlalchemy pymysql           # for MySQL
# sqlite3 is built into Python

import sqlalchemy as sa
import pandas as pd

print('SQLAlchemy version:', sa.__version__)

Membuat Mesin Koneksi

Langkah pertama adalah membuat mesin SQLAlchemy menggunakan URL koneksi yang memuat jenis basis data, kredensial, host, port, dan nama basis data. Mesin ini merupakan pabrik koneksi basis data — mesin tidak membuka koneksi sampai Anda benar-benar membutuhkannya. Teruskan mesin tersebut ke fungsi Pandas pd.read_sql() dan df.to_sql(). Jangan pernah menulis kredensial secara langsung di dalam kode; bacalah dari variabel lingkungan atau pengelola rahasia.

import sqlalchemy as sa
import os

# SQLite (file-based, no server needed)
sqlite_engine = sa.create_engine('sqlite:///mydata.db')

# PostgreSQL
# pg_url = 'postgresql://user:pass@localhost:5432/mydb'
# pg_engine = sa.create_engine(pg_url)

# From environment variable (safer)
# pg_engine = sa.create_engine(os.environ['DATABASE_URL'])

print(sqlite_engine)
print(type(sqlite_engine))

Membaca Tabel dengan pd.read_sql_table()

pd.read_sql_table('table_name', con=engine) membaca seluruh tabel basis data ke dalam DataFrame. Fungsi ini secara otomatis menyimpulkan tipe data kolom dari skema basis data — bilangan bulat tetap menjadi bilangan bulat, penanda waktu menjadi datetime, dan seterusnya. Cara ini lebih tepat daripada penyimpulan dari CSV. Anda juga dapat membatasi kolom dengan argumen columns dan memfilter baris dengan schema untuk skema basis data nonbawaan. Berhati-hatilah dengan tabel yang sangat besar: seluruh isinya akan dimuat ke dalam RAM.

import pandas as pd
import sqlalchemy as sa

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

# Read a full table
df = pd.read_sql_table('orders', con=engine)
print(df.shape)
print(df.dtypes)
print(df.head())

Menjalankan Kueri dengan pd.read_sql_query()

pd.read_sql_query('SELECT ...', con=engine) menjalankan pernyataan SELECT SQL arbitrer dan mengembalikan hasilnya sebagai DataFrame. Ini merupakan pendekatan yang paling fleksibel: Anda dapat memfilter, menggabungkan, dan mengagregasikan data dalam SQL sebelum memuatnya ke Pandas, sehingga hanya baris dan kolom yang diperlukan yang dimuat. Tulis kueri sebagai string Python biasa. Jangan pernah menggabungkan masukan pengguna ke dalam kueri — gunakan kueri berparameter untuk mencegah injeksi SQL.

import pandas as pd
import sqlalchemy as sa

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

query = '''
    SELECT customer_id, SUM(amount) AS total_spent,
           COUNT(*) AS num_orders
    FROM orders
    WHERE status = 'completed'
    GROUP BY customer_id
    ORDER BY total_spent DESC
    LIMIT 100
'''

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

Kueri Berparameter untuk Keamanan

Jangan pernah membuat kueri SQL dengan menggabungkan string dan nilai yang diberikan pengguna — hal ini membuka kerentanan injeksi SQL. Sebagai gantinya, gunakan kueri berparameter: teruskan parameter sebagai kamus dengan penampung bernama. SQLAlchemy menangani proses pelepasan karakter khusus. Sintaks penampungnya adalah :name dalam kueri teks SQLAlchemy atau %(name)s untuk kueri bergaya psycopg2. Selalu gunakan parameterisasi, bahkan untuk skrip internal, agar kebiasaan yang baik terbentuk.

import pandas as pd
import sqlalchemy as sa

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

# Safe: parameterised query
params = {'status': 'completed', 'min_amount': 500.0}
query = sa.text(
    'SELECT * FROM orders WHERE status = :status AND amount > :min_amount'
)

with engine.connect() as conn:
    df = pd.read_sql_query(query, con=conn, params=params)
print(f'Loaded {len(df)} rows')

Menangani Hasil Kueri Besar dalam Potongan

Untuk hasil kueri yang besar, gunakan chunksize dalam pd.read_sql_query() untuk menerima iterator berisi DataFrame, bukan memuat semuanya sekaligus. Perilaku ini serupa dengan pd.read_csv(chunksize=...), tetapi baris diambil dari basis data dalam kelompok-kelompok. Gabungkan cara ini dengan pola akumulator berjalan untuk mengagregasikan hasil dari kueri yang menghasilkan jutaan baris tanpa menghabiskan RAM.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('postgresql://user:pass@host/db')

total = 0.0
count = 0

for chunk in pd.read_sql_query(
    'SELECT amount FROM orders',
    con=engine,
    chunksize=50000
):
    total += chunk['amount'].sum()
    count += len(chunk)

print(f'Mean amount: {total/count:.2f}')

Pengelola Konteks Koneksi

Selalu buka koneksi basis data di dalam pengelola konteks (with engine.connect() as conn:) untuk memastikan koneksi ditutup dengan benar meskipun terjadi pengecualian. Lupa menutup koneksi menyebabkan habisnya kapasitas kumpulan koneksi dalam lingkungan produksi, sehingga kueri baru dapat macet saat menunggu slot yang tersedia. Kumpulan koneksi SQLAlchemy mengelola sejumlah koneksi tetap dan mendaur ulangnya secara otomatis ketika pengelola konteks digunakan.

import pandas as pd
import sqlalchemy as sa

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

# Using context manager — connection always closed properly
with engine.connect() as conn:
    df = pd.read_sql_query(
        'SELECT * FROM products WHERE category = "Electronics"',
        con=conn
    )
    print(f'Products loaded: {len(df)}')
# Connection is automatically returned to the pool here

Memeriksa Skema Basis Data

Sebelum menulis kueri, Anda perlu mengetahui tabel dan kolom yang tersedia. Inspektur SQLAlchemy memungkinkan Anda merefleksikan skema basis data tanpa menulis SQL mentah. inspector.get_table_names() mencantumkan semua tabel; inspector.get_columns('table') mengembalikan nama dan tipe kolom. Cara ini berguna saat bekerja dengan basis data yang belum dikenal dan lebih rapi daripada menjalankan PRAGMA table_info() atau \d tablename secara manual.

import sqlalchemy as sa

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

# List all tables
tables = inspector.get_table_names()
print('Tables:', tables)

# Get columns for the 'orders' table
for col in inspector.get_columns('orders'):
    print(f'  {col["name"]}: {col["type"]}')

Menutup Mesin dan Praktik Terbaik

Dalam skrip yang berjalan lama atau aplikasi web, panggil engine.dispose() setelah selesai untuk menutup semua koneksi dalam kumpulan. Untuk skrip singkat, pengumpul sampah Python menangani pembersihannya. Praktik terbaik untuk koneksi basis data dalam alur data: buat mesin satu kali di bagian atas skrip dan gunakan kembali, gunakan bawaan pengumpulan koneksi (pool_size=5), serta aktifkan pool_pre_ping=True agar koneksi tersambung kembali secara otomatis jika server basis data dimulai ulang di antara kueri.

import sqlalchemy as sa

# Production-grade engine creation
engine = sa.create_engine(
    'postgresql://user:pass@host:5432/mydb',
    pool_size=5,          # max 5 persistent connections
    max_overflow=10,      # allow 10 temporary extra connections
    pool_pre_ping=True,   # verify connection before use
    connect_args={'connect_timeout': 10}
)

# ... run all your queries ...

# At the end of the application/script
engine.dispose()
print('Engine disposed')

Membandingkan Kecepatan read_sql dan read_csv

Untuk data yang sudah berada dalam basis data dengan indeks yang tepat, pd.read_sql_query dengan kueri yang difilter sering kali lebih cepat daripada mengekspor ke CSV lalu membacanya. Server basis data menerapkan filter sebelum mengirim data, sehingga transfer jaringan dan beban penguraian berkurang. Untuk tabel yang sangat lebar, basis data juga dapat memilih hanya kolom yang diperlukan. Namun, membaca dari basis data jarak jauh melalui jaringan yang lambat mungkin lebih lambat daripada membaca berkas Parquet lokal — selalu ukur kinerja kedua pilihan tersebut untuk konfigurasi Anda.

import pandas as pd
import sqlalchemy as sa
import time

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

# Database read with server-side filter
start = time.time()
df_sql = pd.read_sql_query(
    'SELECT * FROM transactions WHERE amount > 100 AND year = 2024',
    con=engine
)
print(f'SQL read: {time.time()-start:.3f}s, {len(df_sql):,} rows')

Pemeriksaan Singkat

Uji pemahaman Anda tentang konsep Analisis Data dari pelajaran ini.

Rangkuman Pelajaran

Dalam pelajaran ini, Anda mempelajari bahwa sa.create_engine() membuat pabrik koneksi yang dapat digunakan kembali dari string URL, pd.read_sql_query() menjalankan SQL arbitrer dan mengembalikan DataFrame, serta kueri berparameter dengan sa.text() dan params mencegah kerentanan injeksi SQL. Selanjutnya, kita akan melihat cara menjalankan kueri SQL yang lebih kompleks dari Pandas dan menggabungkan SQL dengan logika Python.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menghubungkan ke Basis Data dengan SQLAlchemy” gratis?

Ya — teks lengkap “Menghubungkan ke Basis Data dengan SQLAlchemy” 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 “Menghubungkan ke Basis Data dengan SQLAlchemy”?

Buat mesin SQLAlchemy untuk SQLite dan PostgreSQL, lalu teruskan ke pd.read_sql untuk memuat tabel ke dalam DataFrame. 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 1 dari 4.

Berapa lama pelajaran “Menghubungkan ke Basis Data dengan SQLAlchemy” 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