Python SQLAlchemy Hybrid Properties: Atribut Terkomputasi untuk Pemodelan Data yang Andal

SQLAlchemy, sebuah toolkit SQL Python dan Object-Relational Mapper (ORM) yang kuat dan fleksibel, menawarkan serangkaian fitur yang kaya untuk berinteraksi dengan basis data. Di antaranya, Hybrid Properties menonjol sebagai alat yang sangat berguna untuk membuat atribut terkomputasi dalam model data Anda. Artikel ini memberikan panduan komprehensif untuk memahami dan memanfaatkan SQLAlchemy Hybrid Properties, memungkinkan Anda membangun aplikasi yang lebih ekspresif, mudah dipelihara, dan efisien.

Apa itu SQLAlchemy Hybrid Properties?

Hybrid Property, seperti namanya, adalah jenis properti khusus di SQLAlchemy yang dapat berperilaku berbeda tergantung pada konteks di mana ia diakses. Ini memungkinkan Anda untuk mendefinisikan atribut yang dapat diakses langsung pada instance kelas Anda (seperti properti biasa) atau digunakan dalam ekspresi SQL (seperti kolom). Hal ini dicapai dengan mendefinisikan fungsi terpisah untuk akses tingkat instance dan tingkat kelas.

Pada dasarnya, Hybrid Properties menyediakan cara untuk mendefinisikan atribut terkomputasi yang diturunkan dari atribut lain dari model Anda. Atribut terkomputasi ini dapat digunakan dalam kueri, dan juga dapat diakses langsung pada instance model Anda, menyediakan antarmuka yang konsisten dan intuitif.

Mengapa Menggunakan Hybrid Properties?

Menggunakan Hybrid Properties menawarkan beberapa keuntungan:

• Ekspresif: Memungkinkan Anda untuk mengekspresikan hubungan dan perhitungan kompleks langsung di dalam model Anda, membuat kode Anda lebih mudah dibaca dan dipahami.
• Kemudahan Pemeliharaan: Dengan mengenkapsulasi logika kompleks di dalam Hybrid Properties, Anda mengurangi duplikasi kode dan meningkatkan kemudahan pemeliharaan aplikasi Anda.
• Efisiensi: Hybrid Properties memungkinkan Anda melakukan perhitungan langsung di basis data, mengurangi jumlah data yang perlu ditransfer antara aplikasi Anda dan server basis data.
• Konsistensi: Menyediakan antarmuka yang konsisten untuk mengakses atribut terkomputasi, terlepas dari apakah Anda bekerja dengan instance model Anda atau menulis kueri SQL.

Contoh Dasar: Nama Lengkap

Mari kita mulai dengan contoh sederhana: menghitung nama lengkap seseorang dari nama depan dan nama belakang mereka.

Mendefinisikan Model

Pertama, kita mendefinisikan model `Person` sederhana dengan kolom `first_name` dan `last_name`.

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.hybrid import hybrid_property

Base = declarative_base()

class Person(Base):
    __tablename__ = 'people'
    id = Column(Integer, primary_key=True)
    first_name = Column(String)
    last_name = Column(String)

    def __repr__(self):
        return f""


engine = create_engine('sqlite:///:memory:') # Basis data dalam memori untuk contoh
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()

Membuat Hybrid Property

Sekarang, kita akan menambahkan Hybrid Property `full_name` yang menggabungkan nama depan dan nama belakang.

class Person(Base):
    __tablename__ = 'people'
    id = Column(Integer, primary_key=True)
    first_name = Column(String)
    last_name = Column(String)

    @hybrid_property
    def full_name(self):
        return f"{self.first_name} {self.last_name}"

    def __repr__(self):
        return f""

Dalam contoh ini, dekorator `@hybrid_property` mengubah metode `full_name` menjadi Hybrid Property. Ketika Anda mengakses `person.full_name`, kode di dalam metode ini akan dieksekusi.

Mengakses Hybrid Property

Mari kita buat beberapa data dan lihat bagaimana cara mengakses properti `full_name`.

person1 = Person(first_name='Alice', last_name='Smith')
person2 = Person(first_name='Bob', last_name='Johnson')

session.add_all([person1, person2])
session.commit()

print(person1.full_name)  # Keluaran: Alice Smith
print(person2.full_name)  # Keluaran: Bob Johnson

Menggunakan Hybrid Property dalam Kueri

Kekuatan sebenarnya dari Hybrid Properties muncul saat Anda menggunakannya dalam kueri. Kita dapat memfilter berdasarkan `full_name` seolah-olah itu adalah kolom biasa.

people_with_smith = session.query(Person).filter(Person.full_name == 'Alice Smith').all()
print(people_with_smith) # Keluaran: []

Namun, contoh di atas hanya akan berfungsi untuk pemeriksaan kesetaraan sederhana. Untuk operasi yang lebih kompleks dalam kueri (seperti `LIKE`), kita perlu mendefinisikan fungsi ekspresi.

Mendefinisikan Fungsi Ekspresi

Untuk menggunakan Hybrid Properties dalam ekspresi SQL yang lebih kompleks, Anda perlu mendefinisikan fungsi ekspresi. Fungsi ini memberi tahu SQLAlchemy cara menerjemahkan Hybrid Property menjadi ekspresi SQL.

Mari kita modifikasi contoh sebelumnya untuk mendukung kueri `LIKE` pada properti `full_name`.

from sqlalchemy import func

class Person(Base):
    __tablename__ = 'people'
    id = Column(Integer, primary_key=True)
    first_name = Column(String)
    last_name = Column(String)

    @hybrid_property
    def full_name(self):
        return f"{self.first_name} {self.last_name}"

    @full_name.expression
    def full_name(cls):
        return func.concat(cls.first_name, ' ', cls.last_name)

    def __repr__(self):
        return f""

Di sini, kita menambahkan dekorator `@full_name.expression`. Ini mendefinisikan fungsi yang mengambil kelas (`cls`) sebagai argumen dan mengembalikan ekspresi SQL yang menggabungkan nama depan dan nama belakang menggunakan fungsi `func.concat`. `func.concat` adalah fungsi SQLAlchemy yang mewakili fungsi penggabungan basis data (misalnya, `||` di SQLite, `CONCAT` di MySQL dan PostgreSQL).

Sekarang kita dapat menggunakan kueri `LIKE`:

people_with_smith = session.query(Person).filter(Person.full_name.like('%Smith%')).all()
print(people_with_smith) # Keluaran: []

Mengatur Nilai: Setter

Hybrid Properties juga dapat memiliki setter, yang memungkinkan Anda memperbarui atribut yang mendasarinya berdasarkan nilai baru. Ini dilakukan dengan menggunakan dekorator `@full_name.setter`.

Mari tambahkan setter ke properti `full_name` kita yang memisahkan nama lengkap menjadi nama depan dan nama belakang.

class Person(Base):
    __tablename__ = 'people'
    id = Column(Integer, primary_key=True)
    first_name = Column(String)
    last_name = Column(String)

    @hybrid_property
    def full_name(self):
        return f"{self.first_name} {self.last_name}"

    @full_name.expression
    def full_name(cls):
        return func.concat(cls.first_name, ' ', cls.last_name)

    @full_name.setter
    def full_name(self, full_name):
        parts = full_name.split()
        self.first_name = parts[0]
        self.last_name = ' '.join(parts[1:]) if len(parts) > 1 else ''

    def __repr__(self):
        return f""

Sekarang Anda dapat mengatur properti `full_name`, dan itu akan memperbarui atribut `first_name` dan `last_name`.

person = Person(first_name='Alice', last_name='Smith')
session.add(person)
session.commit()

person.full_name = 'Charlie Brown'
print(person.first_name)  # Keluaran: Charlie
print(person.last_name)   # Keluaran: Brown

session.commit()

Deleters

Mirip dengan setter, Anda juga dapat mendefinisikan deleter untuk Hybrid Property menggunakan dekorator `@full_name.deleter`. Ini memungkinkan Anda untuk mendefinisikan apa yang terjadi ketika Anda mencoba `del person.full_name`.

Untuk contoh kita, mari buat penghapusan nama lengkap membersihkan nama depan dan nama belakang.

class Person(Base):
    __tablename__ = 'people'
    id = Column(Integer, primary_key=True)
    first_name = Column(String)
    last_name = Column(String)

    @hybrid_property
    def full_name(self):
        return f"{self.first_name} {self.last_name}"

    @full_name.expression
    def full_name(cls):
        return func.concat(cls.first_name, ' ', cls.last_name)

    @full_name.setter
    def full_name(self, full_name):
        parts = full_name.split()
        self.first_name = parts[0]
        self.last_name = ' '.join(parts[1:]) if len(parts) > 1 else ''

    @full_name.deleter
    def full_name(self):
        self.first_name = None
        self.last_name = None

    def __repr__(self):
        return f""

person = Person(first_name='Charlie', last_name='Brown')
session.add(person)
session.commit()

del person.full_name
print(person.first_name) # Keluaran: None
print(person.last_name)  # Keluaran: None

session.commit()

Contoh Lanjutan: Menghitung Usia dari Tanggal Lahir

Mari kita pertimbangkan contoh yang lebih kompleks: menghitung usia seseorang dari tanggal lahir mereka. Ini menunjukkan kekuatan Hybrid Properties dalam menangani tanggal dan melakukan perhitungan.

Menambahkan Kolom Tanggal Lahir

Pertama, kita tambahkan kolom `date_of_birth` ke model `Person` kita.

from sqlalchemy import Date
import datetime

class Person(Base):
    __tablename__ = 'people'
    id = Column(Integer, primary_key=True)
    first_name = Column(String)
    last_name = Column(String)
    date_of_birth = Column(Date)

    # ... (kode sebelumnya)

Menghitung Usia dengan Hybrid Property

Sekarang kita buat Hybrid Property `age`. Properti ini menghitung usia berdasarkan kolom `date_of_birth`. Kita perlu menangani kasus di mana `date_of_birth` adalah `None`.

from sqlalchemy import Date
import datetime

class Person(Base):
    __tablename__ = 'people'
    id = Column(Integer, primary_key=True)
    first_name = Column(String)
    last_name = Column(String)
    date_of_birth = Column(Date)

    @hybrid_property
    def age(self):
        if self.date_of_birth:
            today = datetime.date.today()
            age = today.year - self.date_of_birth.year - ((today.month, today.day) < (self.date_of_birth.month, self.date_of_birth.day))
            return age
        return None # Atau nilai default lainnya

    @age.expression
    def age(cls):
        today = datetime.date.today()
        return func.cast(func.strftime('%Y', 'now') - func.strftime('%Y', cls.date_of_birth) - (func.strftime('%m-%d', 'now') < func.strftime('%m-%d', cls.date_of_birth)), Integer)

    # ... (kode sebelumnya)

Pertimbangan Penting:

• Fungsi Tanggal Spesifik Basis Data: Fungsi ekspresi menggunakan `func.strftime` untuk perhitungan tanggal. Fungsi ini spesifik untuk SQLite. Untuk basis data lain (seperti PostgreSQL atau MySQL), Anda perlu menggunakan fungsi tanggal spesifik basis data yang sesuai (misalnya, `EXTRACT` di PostgreSQL, `YEAR` dan `MAKEDATE` di MySQL).
• Type Casting: Kita menggunakan `func.cast` untuk mengubah hasil perhitungan tanggal menjadi integer. Ini memastikan bahwa properti `age` mengembalikan nilai integer.
• Zona Waktu: Perhatikan zona waktu saat bekerja dengan tanggal. Pastikan tanggal Anda disimpan dan dibandingkan dalam zona waktu yang konsisten.
• Menangani nilai `None` Properti harus menangani kasus di mana `date_of_birth` adalah `None` untuk mencegah kesalahan.

Menggunakan Properti Usia

person1 = Person(first_name='Alice', last_name='Smith', date_of_birth=datetime.date(1990, 1, 1))
person2 = Person(first_name='Bob', last_name='Johnson', date_of_birth=datetime.date(1985, 5, 10))

session.add_all([person1, person2])
session.commit()

print(person1.age)  # Keluaran: (Berdasarkan tanggal saat ini dan tanggal lahir)
print(person2.age)  # Keluaran: (Berdasarkan tanggal saat ini dan tanggal lahir)

people_over_30 = session.query(Person).filter(Person.age > 30).all()
print(people_over_30) # Keluaran: (Orang yang lebih tua dari 30 berdasarkan tanggal saat ini)

Contoh dan Kasus Penggunaan yang Lebih Kompleks

Menghitung Total Pesanan dalam Aplikasi E-commerce

Dalam aplikasi e-commerce, Anda mungkin memiliki model `Order` dengan hubungan ke model `OrderItem`. Anda bisa menggunakan Hybrid Property untuk menghitung nilai total pesanan.

from sqlalchemy import ForeignKey, Float
from sqlalchemy.orm import relationship

class Order(Base):
    __tablename__ = 'orders'
    id = Column(Integer, primary_key=True)
    items = relationship("OrderItem", back_populates="order")

    @hybrid_property
    def total(self):
        return sum(item.price * item.quantity for item in self.items)

    @total.expression
    def total(cls):
        return session.query(func.sum(OrderItem.price * OrderItem.quantity)).\
            filter(OrderItem.order_id == cls.id).scalar_subquery()

class OrderItem(Base):
    __tablename__ = 'order_items'
    id = Column(Integer, primary_key=True)
    order_id = Column(Integer, ForeignKey('orders.id'))
    order = relationship("Order", back_populates="items")
    price = Column(Float)
    quantity = Column(Integer)

Contoh ini menunjukkan fungsi ekspresi yang lebih kompleks menggunakan subquery untuk menghitung total langsung di basis data.

Perhitungan Geografis

Jika Anda bekerja dengan data geografis, Anda bisa menggunakan Hybrid Properties untuk menghitung jarak antar titik atau menentukan apakah suatu titik berada dalam wilayah tertentu. Ini sering melibatkan penggunaan fungsi geografis spesifik basis data (misalnya, fungsi PostGIS di PostgreSQL).

from geoalchemy2 import Geometry
from sqlalchemy import cast

class Location(Base):
    __tablename__ = 'locations'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    coordinates = Column(Geometry(geometry_type='POINT', srid=4326))

    @hybrid_property
    def latitude(self):
        if self.coordinates:
            return self.coordinates.x
        return None

    @latitude.expression
    def latitude(cls):
        return cast(func.ST_X(cls.coordinates), Float)

    @hybrid_property
    def longitude(self):
        if self.coordinates:
            return self.coordinates.y
        return None

    @longitude.expression
    def longitude(cls):
        return cast(func.ST_Y(cls.coordinates), Float)

Contoh ini memerlukan ekstensi `geoalchemy2` dan mengasumsikan Anda menggunakan basis data dengan PostGIS diaktifkan.

Praktik Terbaik untuk Menggunakan Hybrid Properties

• Tetap Sederhana: Gunakan Hybrid Properties untuk perhitungan yang relatif sederhana. Untuk logika yang lebih kompleks, pertimbangkan untuk menggunakan fungsi atau metode terpisah.
• Gunakan Tipe Data yang Sesuai: Pastikan tipe data yang digunakan dalam Hybrid Properties Anda kompatibel dengan Python dan SQL.
• Pertimbangkan Kinerja: Meskipun Hybrid Properties dapat meningkatkan kinerja dengan melakukan perhitungan di basis data, penting untuk memantau kinerja kueri Anda dan mengoptimalkannya sesuai kebutuhan.
• Uji Secara Menyeluruh: Uji Hybrid Properties Anda secara menyeluruh untuk memastikan bahwa mereka menghasilkan hasil yang benar dalam semua konteks.
• Dokumentasikan Kode Anda: Dokumentasikan Hybrid Properties Anda dengan jelas untuk menjelaskan apa yang mereka lakukan dan bagaimana cara kerjanya.

Kesalahan Umum dan Cara Menghindarinya

• Fungsi Spesifik Basis Data: Pastikan fungsi ekspresi Anda menggunakan fungsi yang agnostik terhadap basis data atau menyediakan implementasi spesifik basis data untuk menghindari masalah kompatibilitas.
• Fungsi Ekspresi yang Salah: Periksa kembali bahwa fungsi ekspresi Anda dengan benar menerjemahkan Hybrid Property Anda menjadi ekspresi SQL yang valid.
• Bottleneck Kinerja: Hindari menggunakan Hybrid Properties untuk perhitungan yang terlalu kompleks atau intensif sumber daya, karena ini dapat menyebabkan bottleneck kinerja.
• Nama yang Bertentangan: Hindari menggunakan nama yang sama untuk Hybrid Property Anda dan kolom dalam model Anda, karena ini dapat menyebabkan kebingungan dan kesalahan.

Pertimbangan Internasionalisasi

Saat bekerja dengan Hybrid Properties dalam aplikasi yang diinternasionalkan, pertimbangkan hal berikut:

• Format Tanggal dan Waktu: Gunakan format tanggal dan waktu yang sesuai untuk berbagai lokal.
• Format Angka: Gunakan format angka yang sesuai untuk berbagai lokal, termasuk pemisah desimal dan pemisah ribuan.
• Format Mata Uang: Gunakan format mata uang yang sesuai untuk berbagai lokal, termasuk simbol mata uang dan tempat desimal.
• Perbandingan String: Gunakan fungsi perbandingan string yang sadar lokal untuk memastikan bahwa string dibandingkan dengan benar dalam berbagai bahasa.

Misalnya, saat menghitung usia, pertimbangkan format tanggal berbeda yang digunakan di seluruh dunia. Di beberapa wilayah, tanggal ditulis sebagai `BB/HH/TTTT`, sementara di wilayah lain `HH/BB/TTTT` atau `TTTT-BB-HH`. Pastikan kode Anda mengurai tanggal dengan benar dalam semua format.

Saat menggabungkan string (seperti dalam contoh `full_name`), waspadai perbedaan budaya dalam urutan nama. Di beberapa budaya, nama keluarga mendahului nama pemberian. Pertimbangkan untuk menyediakan opsi bagi pengguna untuk menyesuaikan format tampilan nama.

Kesimpulan

SQLAlchemy Hybrid Properties adalah alat yang kuat untuk membuat atribut terkomputasi dalam model data Anda. Mereka memungkinkan Anda untuk mengekspresikan hubungan dan perhitungan kompleks langsung di model Anda, meningkatkan keterbacaan kode, kemudahan pemeliharaan, dan efisiensi. Dengan memahami cara mendefinisikan Hybrid Properties, fungsi ekspresi, setter, dan deleter, Anda dapat memanfaatkan fitur ini untuk membangun aplikasi yang lebih canggih dan kuat.

Dengan mengikuti praktik terbaik yang diuraikan dalam artikel ini dan menghindari kesalahan umum, Anda dapat secara efektif memanfaatkan Hybrid Properties untuk meningkatkan model SQLAlchemy Anda dan menyederhanakan logika akses data Anda. Ingatlah untuk mempertimbangkan aspek internasionalisasi untuk memastikan aplikasi Anda berfungsi dengan benar bagi pengguna di seluruh dunia. Dengan perencanaan dan implementasi yang cermat, Hybrid Properties dapat menjadi bagian yang tak ternilai dari toolkit SQLAlchemy Anda.