Belajar Python - Persistensi & Database

#Pendahuluan

Hampir semua aplikasi nyata menyimpan data. Episode 9 memperkenalkan kalian pada dunia persistensi: cara Python berkomunikasi dengan database relasional lewat SQLAlchemy, mengelola perubahan skema dengan Alembic, dan berinteraksi dengan database NoSQL seperti Redis dan MongoDB.

Kita juga membahas pola connection pooling dan transaction yang menjadi fondasi aplikasi skala produksi. Ini adalah jembatan menuju episode 13, ketika kalian membangun API yang benar-benar menyimpan data.

#SQLAlchemy Core dan ORM

#Memahami Dua Gaya

SQLAlchemy menyediakan dua gaya pemrograman:

• Core: menulis SQL secara eksplisit dengan ekspresi Python.
• ORM: memetakan objek Python ke tabel database.

Keduanya berbagi fondasi yang sama, jadi kalian bisa mencampurnya. Mari lihat perbedaannya.

#SQLAlchemy Core

Core memakai ekspresi SQL sebagai objek Python:

SQLAlchemy Core

from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String
 
engine = create_engine("sqlite:///buku.db")
metadata = MetaData()
 
buku = Table(
    "buku",
    metadata,
    Column("id", Integer, primary_key=True),
    Column("judul", String),
)
 
metadata.create_all(engine)
print("tabel dibuat")

create_engine("sqlite:///buku.db") membuat koneksi ke database. Table mendefinisikan struktur tabel secara eksplisit. Core memberi kontrol penuh atas SQL yang dihasilkan.

#SQLAlchemy ORM

ORM memetakan kelas Python ke tabel:

SQLAlchemy ORM

from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
from sqlalchemy import create_engine
 
class Base(DeclarativeBase):
    pass
 
class Buku(Base):
    __tablename__ = "buku"
    id: Mapped[int] = mapped_column(primary_key=True)
    judul: Mapped[str]
 
engine = create_engine("sqlite:///buku.db")
Base.metadata.create_all(engine)
print(Buku.__tablename__)

class Buku(Base) mendefinisikan model yang mewarisi DeclarativeBase. Anotasi Mapped[int] dan Mapped[str] menentukan kolom. ORM mengurangi boilerplate dan membuat query lebih natural, cocok untuk CRUD standar.

#Session dan Transaction

#Membuat Session

Session adalah unit kerja ORM yang mengelola transaction:

Menggunakan Session

from sqlalchemy.orm import Session
from sqlalchemy import create_engine
 
engine = create_engine("sqlite:///buku.db")
 
with Session(engine) as sesi:
    buku_baru = Buku(judul="Belajar Python")
    sesi.add(buku_baru)
    sesi.commit()
    print("disimpan")

with Session(engine) as sesi: membuka sesi yang mengelola koneksi dan transaction. sesi.add(buku_baru) menandai objek untuk disimpan, dan sesi.commit() menulisnya ke database. Context manager menjamin sesi ditutup dengan benar.

#Migrasi dengan Alembic

#Membuat dan Menerapkan Migrasi

Alur kerja migrasi:

alembic revision --autogenerate -m "tambah tabel buku"
alembic upgrade head

alembic revision --autogenerate -m "tambah tabel buku" menghasilkan file revisi otomatis dari model kalian. alembic upgrade head menerapkan semua revisi yang belum dijalankan. Dengan cara ini, perubahan skema bisa diterapkan konsisten di semua environment.

#Redis dan MongoDB

#Redis: Key-Value Store

Redis adalah store key-value in-memory yang sangat cepat untuk cache dan antrian. Driver resminya adalah redis-py:

Menggunakan Redis

import redis
 
r = redis.Redis(host="localhost", port=6379, decode_responses=True)
r.set("nama", "Arman")
print(r.get("nama"))
 
r.rpush("antrian", "tugas-1")
r.rpush("antrian", "tugas-2")
print(r.lpop("antrian"))

redis.Redis(host="localhost", port=6379) membuat klien Redis. r.set dan r.get mengelola key-value, sedangkan r.rpush dan r.lpop mengelola antrian. Redis ideal untuk caching dan task queue.

#MongoDB: Document Store

MongoDB menyimpan dokumen JSON-like. Driver resminya adalah pymongo:

Menggunakan MongoDB

from pymongo import MongoClient
 
klien = MongoClient("mongodb://localhost:27017")
db = klien["belajar"]
koleksi = db["produk"]
 
koleksi.insert_one({"nama": "laptop", "harga": 15000000})
hasil = koleksi.find_one({"nama": "laptop"})
print(hasil["harga"])

MongoClient("mongodb://localhost:27017") menghubungkan ke server MongoDB. insert_one menyimpan dokumen dan find_one mengambilnya berdasarkan kriteria. MongoDB cocok untuk data semi-terstruktur yang fleksibel.

#Connection Pooling

#Mengapa Pooling Penting

Membuka koneksi database setiap operasi itu mahal. Connection pooling memakai ulang koneksi yang sudah ada:

Pooling dengan SQLAlchemy

from sqlalchemy import create_engine
 
engine = create_engine(
    "postgresql+psycopg://user:pass@localhost/db",
    pool_size=10,
    max_overflow=20,
    pool_timeout=30,
)
print("pool dikonfigurasi")

pool_size=10 menentukan jumlah koneksi dasar, max_overflow=20 batas koneksi tambahan, dan pool_timeout=30 waktu tunggu saat pool penuh. Pooling mencegah aplikasi kehabisan koneksi saat traffic tinggi — penting untuk API di episode 13.

#Penutup

Inti yang harus dibawa pulang:

• SQLAlchemy Core memberi kontrol eksplisit; ORM memetakan objek ke tabel.
• Session mengelola transaction dengan commit dan rollback.
• Alembic mencatat perubahan skema sebagai migrasi berurutan.
• Redis untuk key-value dan antrian cepat; MongoDB untuk dokumen fleksibel.
• Connection pooling memakai ulang koneksi untuk efisiensi.
• Transaction menjaga konsistensi database saat multi-tabel.

Di episode 10 selanjutnya kita akan membahas I/O, serialization, dan data formats — file I/O dengan pathlib, pemrosesan CSV, JSON, dan YAML, risiko keamanan pickle, serta streaming data dengan generator dan pemrosesan berchunk. Data project kalian mulai bisa masuk dan keluar sistem!