Semua yang Perlu Anda Ketahui Tentang Python dan Object-Relational Maps

Semua yang Perlu Anda Ketahui Tentang Python dan Object-Relational Maps

Anda mungkin pernah mendengar tentang pemetaan relasional objek (ORM). Anda mungkin pernah menggunakannya, tetapi apa sebenarnya itu? Dan bagaimana Anda menggunakannya dengan Python?





Inilah semua yang perlu Anda ketahui tentang ORM dan Python.



Apa itu ORM?

Object-relational mapping (ORM) adalah teknik pemrograman yang digunakan untuk mengakses database. Ini memaparkan database Anda ke dalam serangkaian objek. Anda tidak perlu menulis perintah SQL untuk menyisipkan atau mengambil data, Anda menggunakan serangkaian atribut dan metode yang dilampirkan ke objek.





Ini mungkin terdengar rumit dan tidak perlu, tetapi mereka dapat menghemat banyak waktu, dan membantu mengontrol akses ke database Anda.

Berikut ini contoh. Katakan bahwa setiap kali Anda memasukkan kata sandi ke dalam basis data Anda, Anda ingin melakukan hash, seperti yang dijelaskan dalam keamanan kata sandi situs web . Ini bukan masalah untuk kasus penggunaan sederhana --- Anda melakukan perhitungan sebelum memasukkan. Tetapi bagaimana jika Anda perlu memasukkan catatan di banyak tempat dalam kode? Bagaimana jika programmer lain memasukkan ke dalam tabel Anda, dan Anda tidak mengetahuinya?



Dengan menggunakan ORM, Anda dapat menulis kode untuk memastikan bahwa kapan pun dan di mana pun setiap baris atau bidang dalam database Anda diakses, kode kustom Anda yang lain dijalankan terlebih dahulu.

Ini juga bertindak sebagai 'satu-satunya sumber kebenaran'. Jika Anda ingin mengubah penghitungan khusus, Anda hanya perlu mengubahnya di satu tempat, bukan di beberapa tempat. Dimungkinkan untuk melakukan banyak dari prinsip-prinsip ini dengan pemrograman berorientasi objek (OOP) dengan Python , tetapi ORM bekerja bersama-sama dengan prinsip-prinsip OOP untuk mengontrol akses ke database.



Ada hal-hal tertentu yang harus diperhatikan ketika menggunakan ORM, dan ada keadaan di mana Anda mungkin tidak ingin menggunakannya, tetapi mereka umumnya dianggap sebagai hal yang baik untuk dimiliki, terutama dalam basis kode yang besar.

ORM dengan Python Menggunakan SQLAlchemy

Seperti banyak tugas di Python, mengimpor modul lebih cepat dan lebih mudah daripada menulis sendiri. Tentu saja, dimungkinkan untuk menulis ORM Anda sendiri, tetapi mengapa menemukan kembali roda?



Contoh berikut semua menggunakan SQLAlkimia , ORM Python yang populer, tetapi banyak prinsip yang berlaku terlepas dari implementasinya.

Menyiapkan Python untuk SQLAlchemy

Sebelum terjun langsung, Anda perlu menyiapkan mesin Anda untuk pengembangan Python dengan SQLAlchemy.

Anda harus menggunakan Python 3.6 untuk mengikuti contoh-contoh ini. Sementara versi yang lebih lama akan berfungsi, kode di bawah ini akan memerlukan beberapa modifikasi sebelum dapat dijalankan. Tidak yakin dengan perbedaannya? FAQ Python kami mencakup semua perbedaan.

Sebelum pengkodean, Anda harus menyiapkan lingkungan Python , yang akan mencegah masalah dengan paket Python yang diimpor lainnya.

Pastikan Anda memiliki PIP, manajer paket Python diinstal, yang hadir dengan sebagian besar versi Python modern.

Setelah Anda siap untuk pergi, Anda bisa mulai dengan menyiapkan SQLAlchemy. Dari dalam lingkungan Python Anda di baris perintah, instal SQLAlchemy dengan pemasangan pip memerintah:

pip install SQLAlchemy-1.2.9

NS 1.2.9 adalah nomor versi. Anda dapat mengabaikan ini untuk mendapatkan paket terbaru, tetapi praktik yang baik adalah untuk lebih spesifik. Anda tidak tahu kapan rilis baru dapat merusak kode Anda saat ini.

Sekarang Anda siap untuk memulai pengkodean. Anda mungkin perlu menyiapkan database Anda untuk menerima koneksi Python, tetapi semua contoh berikut menggunakan SQLite database dibuat dalam memori di bawah ini.

Model dalam SQLAlchemy

Salah satu komponen kunci dari ORM adalah model . Ini adalah kelas Python yang menguraikan seperti apa tampilan tabel, dan cara kerjanya. Ini adalah versi ORM dari BUAT TABEL pernyataan dalam SQL. Anda memerlukan model untuk setiap tabel di database Anda.

Buka editor teks atau IDE favorit Anda, dan buat file baru bernama test.py . Masukkan kode starter ini, simpan file, dan jalankan:

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
engine = create_engine('sqlite://') # Create the database in memory
Base.metadata.create_all(engine) # Create all the tables in the database

Kode ini melakukan beberapa hal. Impor diperlukan agar Python memahami di mana menemukan modul SQLAlchemy yang dibutuhkannya. Model Anda akan menggunakan declarative_base nanti, dan itu mengonfigurasi model baru agar berfungsi seperti yang diharapkan.

NS buat_mesin metode membuat koneksi baru ke database Anda. Jika Anda sudah memiliki database, Anda harus mengubahnya sqlite:// ke URI basis data Anda. Karena itu, kode ini hanya akan membuat database baru di memori. Basis data dihancurkan setelah kode Anda selesai dieksekusi.

Akhirnya, buat_semua metode membuat semua tabel yang ditentukan dalam mode Anda di database Anda. Karena Anda belum menentukan model apa pun, tidak akan terjadi apa-apa. Silakan dan jalankan kode ini, untuk memastikan Anda tidak memiliki masalah atau kesalahan ketik.

Mari kita membuat model. Tambahkan impor lain ke bagian atas file Anda:

from sqlalchemy import Column, Integer, String

Ini mengimpor Kolom , Bilangan bulat , dan Rangkaian modul dari SQLAlchemy. Mereka menentukan bagaimana tabel database, bidang, kolom, dan tipe data bekerja.

Di bawahnya declarative_base , buat kelas model Anda:

class Cars(Base):
__tablename__ = 'cars'
id = Column(Integer, primary_key=True)
make = Column(String(50), nullable=False)
color = Column(String(50), nullable=False)

Contoh sederhana ini menggunakan mobil, tetapi tabel Anda mungkin berisi data apa pun.

Setiap kelas harus mewarisi Basis . Nama tabel database Anda didefinisikan dalam __namatabel__ . Ini harus sama dengan nama kelas, tetapi ini hanya rekomendasi, dan tidak ada yang akan rusak jika tidak cocok.

Akhirnya, setiap kolom didefinisikan sebagai variabel python di dalam kelas. Tipe data yang berbeda digunakan, dan kunci utama atribut memberitahu SQLAlchemy untuk membuat Indo kolom sebagai kunci utama.

Silakan tambahkan satu impor terakhir, kali ini untuk Kunci asing modul. Tambahkan ini di samping Anda Kolom impor:

from sqlalchemy import Column, ForeignKey, Integer, String

Sekarang buat kelas model kedua. Kelas ini disebut Pemilik Mobil , dan menyimpan detail pemilik mobil tertentu yang disimpan di mobil meja:

class CarOwners(Base):
__tablename__ = 'carowners'
id = Column(Integer, primary_key=True)
name = Column(String(50), nullable=False)
age = Column(Integer, nullable=False)
car_id = Column(Integer, ForeignKey('cars.id'))
car = relationship(Cars)

Ada beberapa atribut baru yang diperkenalkan di sini. NS mobil_id bidang didefinisikan sebagai kunci asing. Ini terkait dengan Indo dalam mobil meja. Perhatikan bagaimana nama tabel huruf kecil digunakan, bukan nama kelas huruf besar.

Akhirnya, atribut mobil didefinisikan sebagai hubungan . Ini memungkinkan model Anda mengakses mobil tabel melalui variabel ini. Ini ditunjukkan di bawah ini.

Jika Anda menjalankan kode ini sekarang, Anda akan melihat bahwa tidak ada yang terjadi. Ini karena Anda belum menyuruhnya melakukan sesuatu yang terlihat.

Objek di SQLAlchemy

Sekarang setelah model Anda dibuat, Anda dapat mulai mengakses objek, dan membaca dan menulis data. Sebaiknya tempatkan logika Anda ke dalam kelas dan filenya sendiri, tetapi untuk saat ini, logika dapat tetap berada di samping model.

Menulis Data

Dalam contoh ini, Anda perlu memasukkan beberapa data ke dalam database sebelum Anda dapat membacanya. Jika Anda menggunakan database yang sudah ada, Anda mungkin sudah memiliki data. Bagaimanapun, masih sangat berguna untuk mengetahui cara memasukkan data.

Anda mungkin terbiasa menulis MEMASUKKAN pernyataan dalam SQL. SQLAlchemy menangani ini untuk Anda. Berikut cara menyisipkan satu baris ke dalam mobil model. Mulai dengan impor baru untuk pembuat sesi :

from sqlalchemy.orm import sessionmaker

Ini diperlukan untuk membuat sidang dan DBSesi objek, yang digunakan untuk membaca dan menulis data:

DBSession = sessionmaker(bind=engine)
session = DBSession()

Sekarang letakkan ini di bawah Anda buat_semua penyataan:

car1 = Cars(
make='Ford',
color='silver'
)
session.add(car1)
session.commit()

Mari kita memecah kode itu. Variabel mobil1 didefinisikan sebagai objek berdasarkan mobil model. Merek dan warnanya ditetapkan sebagai parameter. Ini seperti mengatakan 'buatkan saya mobil, tapi jangan tulis ke database dulu'. Mobil ini ada dalam memori tetapi menunggu untuk ditulis.

Tambahkan mobil ke sesi dengan session.add , dan kemudian menulisnya ke database dengan session.commit .

Sekarang mari tambahkan pemilik:

owner1 = CarOwners(
name='Joe',
age='99',
car_id=(car1.id)
)
session.add(owner1)
session.commit()

Kode ini hampir identik dengan sisipan sebelumnya untuk mobil model. Perbedaan utama di sini adalah mobil_id adalah kunci asing sehingga membutuhkan id baris yang ada di tabel lain. Ini diakses melalui mobil1.id Properti.

Anda tidak perlu menanyakan database atau mengembalikan id apa pun, karena SQLAlchemy menangani ini untuk Anda (selama Anda mengkomit data terlebih dahulu).

Membaca Data

Setelah Anda menulis beberapa data, Anda dapat mulai membacanya kembali. Berikut adalah cara untuk menanyakan mobil dan Pemilik Mobil tabel:

result = session.query(Cars).all()

Sesederhana itu. Dengan menggunakan pertanyaan metode yang ditemukan di sidang , Anda menentukan model, dan kemudian menggunakan semua metode untuk mengambil semua hasil. Jika Anda tahu hanya akan ada satu hasil, maka Anda dapat menggunakan pertama metode:

result = session.query(Cars).first()

Setelah Anda menanyakan model, dan menyimpan hasil yang dikembalikan dalam variabel, Anda dapat mengakses data melalui objek:

print(result[0].color)

Ini mencetak warna 'perak', karena catatan itu adalah baris pertama. Anda dapat mengulang objek hasil jika Anda mau.

Saat Anda mendefinisikan hubungan dalam model Anda, dimungkinkan untuk mengakses data dalam tabel terkait tanpa menentukan gabungan:

result = session.query(CarOwners).all()
print(result[0].name)
print(result[0].car.color)

Ini berfungsi karena model Anda berisi detail struktur tabel Anda, dan mobil atribut didefinisikan sebagai tautan ke mobil meja.

Apa yang Tidak Disukai Tentang ORM?

Tutorial ini hanya membahas dasar-dasarnya, tetapi setelah Anda memahaminya, Anda dapat melanjutkan ke topik lanjutan. Ada beberapa potensi kerugian ORM:

  • Anda harus menulis model Anda sebelum kueri apa pun dapat dijalankan.
  • Ini adalah sintaks baru untuk dipelajari.
  • Ini mungkin terlalu rumit untuk kebutuhan sederhana.
  • Anda harus memiliki desain database yang baik untuk memulai.

Masalah-masalah ini bukan masalah besar mereka sendiri, tetapi mereka adalah hal-hal yang harus diwaspadai. Jika Anda bekerja dengan database yang sudah ada, Anda mungkin akan ketahuan.

Jika Anda tidak yakin ORM adalah alat yang tepat untuk Anda, pastikan Anda membaca tentang perintah SQL penting yang harus diketahui oleh programmer .

Membagikan Membagikan Menciak Surel Haruskah Anda Segera Upgrade ke Windows 11?

Windows 11 akan segera hadir, tetapi haruskah Anda memperbarui sesegera mungkin atau menunggu beberapa minggu? Mari kita cari tahu.

Baca Selanjutnya Topik-topik yang berkaitan
  • Pemrograman
  • Python
  • SQL
  • Tutorial Pengkodean
Tentang Penulis Joe Coburn(136 Artikel Diterbitkan)

Joe adalah lulusan Ilmu Komputer dari University of Lincoln, Inggris. Dia adalah pengembang perangkat lunak profesional, dan ketika dia tidak menerbangkan drone atau menulis musik, dia sering terlihat sedang mengambil foto atau membuat video.

cara menggunakan gif sebagai wallpaper
More From Joe Coburn

Berlangganan newsletter kami

Bergabunglah dengan buletin kami untuk kiat teknologi, ulasan, ebook gratis, dan penawaran eksklusif!

Klik di sini untuk berlangganan