Menggunakan Python dan MySQL dalam Proses ETL:SQLAlchemy

SQLAlchemy membantu Anda bekerja dengan database dengan Python. Dalam postingan ini, kami memberi tahu Anda semua yang perlu Anda ketahui untuk memulai modul ini.

Pada artikel sebelumnya, kami berbicara tentang cara menggunakan Python dalam proses ETL. Kami fokus untuk menyelesaikan pekerjaan dengan menjalankan prosedur tersimpan dan kueri SQL. Dalam artikel ini dan selanjutnya, kami akan menggunakan pendekatan yang berbeda. Alih-alih menulis kode SQL, kami akan menggunakan toolkit SQLAlchemy. Anda juga dapat menggunakan artikel ini secara terpisah, sebagai pengantar singkat tentang menginstal dan menggunakan SQLAlchemy.

Siap? Mari kita mulai.

Apa itu SQLAlchemy?

Python terkenal dengan jumlah dan variasi modulnya. Modul-modul ini mengurangi waktu pengkodean kami secara signifikan karena mereka menerapkan rutinitas yang diperlukan untuk mencapai tugas tertentu. Sejumlah modul yang bekerja dengan data tersedia, termasuk SQLAlchemy.

Untuk mendeskripsikan SQLAlchemy, saya akan menggunakan kutipan dari SQLAlchemy.org:

SQLAlchemy adalah toolkit Python SQL dan Object Relational Mapper yang memberi pengembang aplikasi kekuatan penuh dan fleksibilitas SQL.

Ini menyediakan rangkaian lengkap persistensi tingkat perusahaan yang terkenal pola, dirancang untuk akses database yang efisien dan berkinerja tinggi, diadaptasi ke dalam bahasa domain yang sederhana dan Pythonic.

Bagian terpenting di sini adalah sedikit tentang ORM (object-relational mapper), yang membantu kita memperlakukan objek database sebagai objek Python daripada daftar.

Sebelum kita melangkah lebih jauh dengan SQLAlchemy, mari kita berhenti sejenak dan berbicara tentang ORM.

Pro dan Kontra Menggunakan ORM

Dibandingkan dengan SQL mentah, ORM memiliki kelebihan dan kekurangan – dan sebagian besar juga berlaku untuk SQLAlchemy.

Barang Bagus:

Portabilitas kode. ORM menangani perbedaan sintaksis antar database.
Hanya satu bahasa diperlukan untuk menangani database Anda. Meskipun, sejujurnya, ini seharusnya tidak menjadi motivasi utama untuk menggunakan ORM.
ORM menyederhanakan kode Anda , misalnya mereka menjaga hubungan dan memperlakukannya seperti objek, yang sangat bagus jika Anda terbiasa dengan OOP.
Anda dapat memanipulasi data Anda di dalam program .

Sayangnya, semuanya datang dengan harga. Hal-hal yang Tidak Begitu Baik tentang ORM:

Dalam beberapa kasus, ORM bisa jadi lambat .
Menulis kueri kompleks bisa menjadi lebih rumit, atau bisa menghasilkan kueri yang lambat. Tapi ini tidak terjadi saat menggunakan SQLAlchemy.
Jika Anda mengetahui DBMS Anda dengan baik, maka akan membuang-buang waktu untuk mempelajari cara menulis hal yang sama dalam ORM.

Sekarang setelah kita menangani topik itu, mari kembali ke SQLAlchemy.

Sebelum kita mulai...

… mari kita ingat kembali tujuan dari artikel ini. Jika Anda hanya tertarik untuk menginstal SQLAlchemy dan membutuhkan tutorial singkat tentang cara melakukan perintah sederhana, artikel ini akan melakukannya. Namun, perintah yang disajikan dalam artikel ini akan digunakan di artikel berikutnya untuk melakukan proses ETL dan menggantikan kode SQL (prosedur tersimpan) dan Python yang kami sajikan di artikel sebelumnya.

Oke, sekarang mari kita mulai dari awal:dengan menginstal SQLAlchemy.

Menginstal SQLAlchemy

1. Periksa Apakah Modul Sudah Terpasang

Untuk menggunakan modul Python, Anda harus menginstalnya (yaitu, jika sebelumnya tidak diinstal). Salah satu cara untuk memeriksa modul mana yang telah diinstal adalah menggunakan perintah ini di Python Shell:

help('modules')

Untuk memeriksa apakah modul tertentu telah diinstal, cukup coba impor. Gunakan perintah ini:

import sqlalchemy
sqlalchemy.__version__

Jika SQLAlchemy sudah terinstal, maka baris pertama akan berhasil dijalankan. import adalah perintah Python standar yang digunakan untuk mengimpor modul. Jika modul tidak diinstal, Python akan memunculkan kesalahan – sebenarnya daftar kesalahan, dalam teks merah – yang tidak boleh Anda lewatkan :)

Perintah kedua mengembalikan versi SQLAlchemy saat ini. Hasil yang dikembalikan seperti gambar di bawah ini:

Kami juga membutuhkan modul lain, yaitu PyMySQL . Ini adalah pustaka klien MySQL ringan Python murni. Modul ini mendukung semua yang kita butuhkan untuk bekerja dengan database MySQL, mulai dari menjalankan kueri sederhana hingga tindakan database yang lebih kompleks. Kami dapat memeriksa apakah itu ada menggunakan help('modules') , seperti yang dijelaskan sebelumnya, atau menggunakan dua pernyataan berikut:

import pymysql
pymysql.__version__

Tentu saja, ini adalah perintah yang sama yang kami gunakan untuk menguji apakah SQLAlchemy telah diinstal.

Bagaimana Jika SQLAlchemy atau PyMySQL Belum Terinstal?

Mengimpor modul yang diinstal sebelumnya tidak sulit. Tetapi bagaimana jika modul yang Anda butuhkan belum diinstal?

Beberapa modul memiliki paket instalasi, tetapi sebagian besar Anda akan menggunakan perintah pip untuk menginstalnya. PIP adalah alat Python yang digunakan untuk menginstal dan menghapus modul. Cara termudah untuk menginstal modul (di OS Windows) adalah:

Gunakan Command Prompt -> Jalankan -> cmd .
Posisikan ke direktori Python cd C:\...\Python\Python37\Scripts .
Jalankan perintah pip install (dalam kasus kami, kami akan menjalankan pip install pyMySQL dan pip install sqlAlchemy .

PIP juga dapat digunakan untuk meng-uninstall modul yang ada. Untuk melakukannya, Anda harus menggunakan pip uninstall .

2. Menghubungkan ke Basis Data

Saat menginstal semua yang diperlukan untuk menggunakan SQLAlchemy sangat penting, itu tidak terlalu menarik. Ini juga bukan bagian dari minat kami. Kami bahkan belum terhubung ke database yang ingin kami gunakan. Kami akan menyelesaikannya sekarang:

import sqlalchemy
from sqlalchemy.engine import create_engine
engine_live = sqlalchemy.create_engine('mysql+pymysql://:@localhost:3306/subscription_live')
connection_live = engine_live.connect()
print(engine_live.table_names())

Menggunakan skrip di atas, kami akan membuat koneksi ke database yang terletak di server lokal kami, subscription_live basis data.

(Catatan: Ganti : dengan nama pengguna dan kata sandi Anda yang sebenarnya.)

Mari kita lihat skripnya, perintah demi perintah.

import sqlalchemy
from sqlalchemy.engine import create_engine

Dua baris ini mengimpor modul kita dan create_engine fungsi.

Selanjutnya, kita akan membuat koneksi ke database yang terletak di server kita.

engine_live = sqlalchemy.create_engine('mysql+pymysql:// :@localhost:3306/subscription_live')
connection_live = engine_live.connect()

Fungsi create_engine membuat mesin, dan menggunakan .connect() , terhubung ke database. create_engine fungsi menggunakan parameter ini:

dialect+driver://username:password@host:port/database

Dalam kasus kami, dialeknya adalah mysql , drivernya adalah pymysql (diinstal sebelumnya) dan variabel lainnya khusus untuk server dan database yang ingin kita sambungkan.

(Catatan: Jika Anda terhubung secara lokal, gunakan localhost alih-alih alamat IP "lokal" Anda, 127.0.0.1 dan port yang sesuai :3306 .)

Hasil dari perintah print(engine_live.table_names()) ditunjukkan pada gambar di atas. Seperti yang diharapkan, kami mendapatkan daftar semua tabel dari database operasional/langsung kami.

3. Menjalankan Perintah SQL Menggunakan SQLAlchemy

Di bagian ini, kita akan menganalisis perintah SQL yang paling penting, memeriksa struktur tabel, dan melakukan keempat perintah DML:SELECT, INSERT, UPDATE, dan DELETE.

Kami akan membahas pernyataan yang digunakan dalam skrip ini secara terpisah. Harap dicatat bahwa kami telah melalui bagian koneksi skrip ini dan kami telah mencantumkan nama tabel. Ada sedikit perubahan pada baris ini:

from sqlalchemy import create_engine, select, MetaData, Table, asc

Kami baru saja mengimpor semua yang akan kami gunakan dari SQLAlchemy.

Tabel dan Struktur

Kami akan menjalankan skrip dengan mengetikkan perintah berikut di Python Shell:

import os
file_path = 'D://python_scripts'
os.chdir(file_path)
exec(open("queries.py").read())

Hasilnya adalah skrip yang dieksekusi. Sekarang mari kita menganalisis sisa skrip.

SQLAlchemy mengimpor informasi yang terkait dengan tabel, struktur, dan relasi. Untuk bekerja dengan info itu, mungkin berguna untuk memeriksa daftar tabel (dan kolomnya) di database:

#print connected tables
print("\n -- Tables from _live database -- ")
print (engine_live.table_names())

Ini hanya mengembalikan daftar semua tabel dari database yang terhubung.

Catatan: table_names() metode mengembalikan daftar nama tabel untuk mesin yang diberikan. Anda dapat mencetak seluruh daftar atau mengulanginya menggunakan loop (seperti yang dapat Anda lakukan dengan daftar lainnya).

Selanjutnya, kami akan mengembalikan daftar semua atribut dari tabel yang dipilih. Bagian skrip yang relevan dan hasilnya ditunjukkan di bawah ini:

#SELECT
metadata = MetaData(bind=None)
table_city = Table('city', metadata, autoload = True, autoload_with = engine_live)

# print table columns
print("\n -- Tables columns for table 'city' --")
for column in table_city.c:
  print(column.name)

Anda dapat melihat bahwa saya telah menggunakan for untuk mengulang set hasil. Kita bisa mengganti table_city.c dengan table_city.columns .

Catatan: Proses memuat deskripsi database dan membuat metadata di SQLAlchemy disebut refleksi.

Catatan: MetaData adalah objek yang menyimpan informasi tentang objek dalam database, sehingga tabel dalam database juga ditautkan ke objek ini. Secara umum, objek ini menyimpan info tentang seperti apa skema database. Anda akan menggunakannya sebagai satu titik kontak saat Anda ingin membuat perubahan atau mendapatkan fakta tentang skema DB.

Catatan: Atribut autoload = True dan autoload_with = engine_live harus digunakan untuk memastikan bahwa atribut tabel akan diunggah (jika belum pernah).

PILIH

Saya rasa saya tidak perlu menjelaskan betapa pentingnya pernyataan SELECT :) Jadi, katakan saja Anda dapat menggunakan SQLAlchemy untuk menulis pernyataan SELECT. Jika Anda terbiasa dengan sintaks MySQL, perlu waktu untuk beradaptasi; tetap saja, semuanya cukup logis. Untuk membuatnya sesederhana mungkin, saya akan mengatakan bahwa pernyataan SELECT diiris dan beberapa bagian dihilangkan, tetapi semuanya masih dalam urutan yang sama.

Mari kita coba beberapa pernyataan SELECT sekarang.

# simple select
print("\n -- SIMPLE SELECT -- ")
stmt = select([table_city])
print(stmt)
print(connection_live.execute(stmt).fetchall())
# loop through results
results = connection_live.execute(stmt).fetchall()
for result in results:
  print(result)

Yang pertama adalah pernyataan SELECT sederhana mengembalikan semua nilai dari tabel yang diberikan. Sintaks dari pernyataan ini sangat sederhana:Saya telah menempatkan nama tabel di select() . Harap perhatikan bahwa saya telah:

Siapkan pernyataan - stmt = select([table_city] .
Mencetak pernyataan menggunakan print(stmt) , yang memberi kita ide bagus tentang pernyataan yang baru saja dieksekusi. Ini juga dapat digunakan untuk debugging.
Mencetak hasilnya dengan print(connection_live.execute(stmt).fetchall()) .
Mengulang hasil dan mencetak setiap catatan.

Catatan: Karena kami juga memuat batasan kunci utama dan asing ke dalam SQLAlchemy, pernyataan SELECT mengambil daftar objek tabel sebagai argumen dan secara otomatis menetapkan hubungan jika diperlukan.

Hasilnya terlihat pada gambar di bawah ini:

Python akan mengambil semua atribut dari tabel dan menyimpannya di objek. Seperti yang ditunjukkan, kita dapat menggunakan objek ini untuk melakukan operasi tambahan. Hasil akhir dari pernyataan kami adalah daftar semua kota dari city tabel.

Sekarang, kami siap untuk kueri yang lebih kompleks. Saya baru saja menambahkan klausa ORDER BY .

# simple select
# simple select, using order by
print("\n -- SIMPLE SELECT, USING ORDER BY")
stmt = select([table_city]).order_by(asc(table_city.columns.id))
print(stmt)
print(connection_live.execute(stmt).fetchall())

Catatan: asc() metode melakukan pengurutan menaik terhadap objek induk, menggunakan kolom yang ditentukan sebagai parameter.

Daftar yang dikembalikan sama, tetapi sekarang diurutkan berdasarkan nilai id, dalam urutan menaik. Penting untuk diperhatikan bahwa kami baru saja menambahkan .order_by() ke kueri SELECT sebelumnya. .order_by(...) metode ini memungkinkan kita untuk mengubah urutan kumpulan hasil yang dikembalikan, dengan cara yang sama seperti yang akan kita gunakan dalam kueri SQL. Oleh karena itu, parameter harus mengikuti logika SQL, menggunakan nama kolom atau urutan kolom dan ASC atau DESC.

Selanjutnya, kita akan menambahkan WHERE ke pernyataan SELECT kami.

# select with WHERE
print("\n -- SELECT WITH WHERE --")
stmt = select([table_city]).where(table_city.columns.city_name == 'London')
print(stmt)
print(connection_live.execute(stmt).fetchall())

Catatan: .where() metode digunakan untuk menguji kondisi yang telah kita gunakan sebagai argumen. Kita juga bisa menggunakan .filter() metode, yang lebih baik dalam menyaring kondisi yang lebih kompleks.

Sekali lagi, .where bagian hanya digabungkan dengan pernyataan SELECT kami. Perhatikan bahwa kami telah menempatkan kondisi di dalam tanda kurung. Kondisi apa pun yang ada di dalam tanda kurung diuji dengan cara yang sama seperti yang akan diuji di bagian WHERE dari pernyataan SELECT. Kondisi kesetaraan diuji menggunakan ==bukan =.

Hal terakhir yang akan kita coba dengan SELECT adalah menggabungkan dua tabel. Mari kita lihat kode dan hasilnya terlebih dahulu.

# select with JOIN
print("\n -- SELECT WITH JOIN --")
table_country = Table('country', metadata, autoload = True, autoload_with = engine_live)
stmt = select([table_city.columns.city_name, table_country.columns.country_name]).select_from(table_city.join(table_country))
print(stmt)
print(connection_live.execute(stmt).fetchall())

Ada dua bagian penting dalam pernyataan di atas:

select([table_city.columns.city_name, table_country.columns.country_name]) mendefinisikan kolom mana yang akan dikembalikan dalam hasil kami.
.select_from(table_city.join(table_country)) mendefinisikan kondisi/tabel bergabung. Perhatikan bahwa kita tidak perlu menuliskan kondisi join lengkap, termasuk kuncinya. Ini karena SQLAlchemy “tahu” bagaimana kedua tabel ini digabungkan, karena kunci utama dan aturan kunci asing diimpor di latar belakang.

MASUKKAN / PERBARUI / HAPUS

Ini adalah tiga perintah DML yang tersisa yang akan kami bahas di artikel ini. Meskipun strukturnya bisa menjadi sangat kompleks, perintah-perintah ini biasanya jauh lebih sederhana. Kode yang digunakan disajikan di bawah ini.

# INSERT
print("\n -- INSERT --")
stmt = table_country.insert().values(country_name='USA')
print(stmt)
connection_live.execute(stmt)
# check & print changes
stmt = select([table_country]).order_by(asc(table_country.columns.id))
print(connection_live.execute(stmt).fetchall())


# UPDATE
print("\n -- UPDATE --")
stmt = table_country.update().where(table_country.columns.country_name == 'USA').values(country_name = 'United States of America')
print(stmt)
connection_live.execute(stmt)
# check & print changes
stmt = select([table_country]).order_by(asc(table_country.columns.id))
print(connection_live.execute(stmt).fetchall())

# DELETE
print("\n -- DELETE --")
stmt = table_country.delete().where(table_country.columns.country_name == 'United States of America')
print(stmt)
connection_live.execute(stmt)
# check & print changes
stmt = select([table_country]).order_by(asc(table_country.columns.id))
print(connection_live.execute(stmt).fetchall())

Pola yang sama digunakan untuk ketiga pernyataan:menyiapkan pernyataan, mencetak dan mengeksekusinya, dan mencetak hasilnya setelah setiap pernyataan sehingga kita dapat melihat apa yang sebenarnya terjadi dalam database. Perhatikan sekali lagi bahwa bagian dari pernyataan diperlakukan sebagai objek (.values(), .where()).

Kami akan menggunakan pengetahuan ini di artikel mendatang untuk membuat seluruh skrip ETL menggunakan SQLAlchemy.

Selanjutnya:SQLAlchemy dalam Proses ETL

Hari ini kami telah menganalisis cara menyiapkan SQLAlchemy dan cara melakukan perintah DML sederhana. Di artikel berikutnya, kita akan menggunakan pengetahuan ini untuk menulis proses ETL lengkap menggunakan SQLAlchemy.

Anda dapat mengunduh skrip lengkap yang digunakan dalam artikel ini di sini.