Tinjauan satu garis:
Perilaku execute()adalah sama dalam semua kasus, tetapi mereka 3 metode yang berbeda, di Engine, Connection, dan Sessionkelas.
Apa sebenarnya itu execute():
Untuk memahami perilaku execute()kita perlu melihat ke dalam Executablekelas. Executableadalah superclass untuk semua "pernyataan" jenis objek, termasuk select (), delete (), update (), insert (), text () - dengan kata-kata sesederhana mungkin, dan Executablemerupakan konstruksi ekspresi SQL yang didukung oleh SQLAlchemy.
Dalam semua kasus, execute()metode ini menggunakan teks SQL atau ekspresi SQL yang dikonstruksi yaitu setiap variasi konstruksi ekspresi SQL yang didukung dalam SQLAlchemy dan mengembalikan hasil kueri (a ResultProxy- Membungkus DB-APIobjek kursor untuk memberikan akses yang lebih mudah ke kolom baris.)
Untuk memperjelasnya lebih lanjut (hanya untuk klarifikasi konseptual, bukan pendekatan yang disarankan) :
Selain Engine.execute()(eksekusi tanpa sambungan),, Connection.execute()dan Session.execute(), juga dimungkinkan untuk menggunakan execute()langsung pada Executablekonstruksi apa pun . The Executablekelas memiliki implementasi itu sendiri execute()- Sesuai dokumentasi resmi, satu baris deskripsi tentang apa yang execute()dilakukannya adalah " Kompilasi dan jalankan iniExecutable ". Dalam hal ini kita perlu secara eksplisit mengikat Executable(konstruksi ekspresi SQL) dengan Connectionobjek atau, Engineobjek (yang secara implisit mendapatkan Connectionobjek), sehingga execute()akan tahu di mana harus mengeksekusi SQL.
Contoh berikut menunjukkan dengan baik - Diberikan tabel seperti di bawah ini:
from sqlalchemy import MetaData, Table, Column, Integer
meta = MetaData()
users_table = Table('users', meta,
Column('id', Integer, primary_key=True),
Column('name', String(50)))
Eksekusi eksplisit yaitu Connection.execute()- meneruskan teks SQL atau membangun ekspresi SQL ke execute()metode Connection:
engine = create_engine('sqlite:///file.db')
connection = engine.connect()
result = connection.execute(users_table.select())
for row in result:
# ....
connection.close()
Eksekusi connectionless eksplisit yaitu Engine.execute()- melewati teks SQL atau membangun ekspresi SQL langsung ke execute()metode Engine:
engine = create_engine('sqlite:///file.db')
result = engine.execute(users_table.select())
for row in result:
# ....
result.close()
Eksekusi implisit yaitu Executable.execute()- juga tanpa koneksi, dan memanggil execute()metode Executable, yaitu, memanggil execute()metode langsung pada SQLkonstruksi ekspresi (turunan dari Executable) itu sendiri.
engine = create_engine('sqlite:///file.db')
meta.bind = engine
result = users_table.select().execute()
for row in result:
# ....
result.close()
Catatan: Menyebutkan contoh eksekusi implisit untuk tujuan klarifikasi - cara eksekusi ini sangat tidak disarankan - sesuai dokumen :
“Eksekusi implisit” adalah pola penggunaan yang sangat lama yang dalam kebanyakan kasus lebih membingungkan daripada membantu, dan penggunaannya tidak disarankan. Kedua pola tersebut tampaknya mendorong "jalan pintas" yang terlalu sering digunakan dalam desain aplikasi yang kemudian menimbulkan masalah.
Pertanyaan Anda:
Seperti yang saya mengerti jika seseorang menggunakan engine.execute itu membuat koneksi, buka sesi (Alchemy peduli untuk Anda) dan jalankan query.
Anda benar untuk bagian "jika seseorang menggunakannya engine.executemenciptakan connection" tetapi tidak untuk "terbuka session(Alkimia peduli untuk Anda) dan mengeksekusi permintaan" - Menggunakan Engine.execute()dan Connection.execute()(hampir) satu hal yang sama, secara formal, Connectionobjek dibuat secara implisit , dan dalam kasus selanjutnya kami secara eksplisit instantiate. Apa yang sebenarnya terjadi dalam kasus ini adalah:
`Engine` object (instantiated via `create_engine()`) -> `Connection` object (instantiated via `engine_instance.connect()`) -> `connection.execute({*SQL expression*})`
Tetapi apakah ada perbedaan global antara ketiga cara ini dalam melakukan tugas seperti itu?
Pada lapisan DB itu hal yang persis sama, semuanya mengeksekusi SQL (ekspresi teks atau berbagai konstruksi ekspresi SQL). Dari sudut pandang aplikasi ada dua opsi:
- Eksekusi langsung - Menggunakan
Engine.execute()atauConnection.execute()
- Menggunakan
sessions- efisien menangani transaksi sebagai unit tunggal-of-kerja, dengan mudah melalui session.add(), session.rollback(), session.commit(), session.close(). Ini adalah cara untuk berinteraksi dengan DB jika ORM yaitu tabel yang dipetakan. Memberikan identity_map untuk secara instan mengakses objek yang baru dibuat / ditambahkan saat permintaan tunggal.
Session.execute()akhirnya menggunakan Connection.execute()metode eksekusi pernyataan untuk mengeksekusi pernyataan SQL. Menggunakan Sessionobjek adalah cara yang direkomendasikan oleh SQLAlchemy ORM untuk aplikasi berinteraksi dengan database.
Kutipan dari dokumen :
Penting untuk dicatat bahwa ketika menggunakan ORM SQLAlchemy, objek-objek ini umumnya tidak diakses; sebaliknya, objek Sesi digunakan sebagai antarmuka ke database. Namun, untuk aplikasi yang dibangun berdasarkan penggunaan langsung pernyataan SQL tekstual dan / atau konstruksi ekspresi SQL tanpa keterlibatan oleh layanan manajemen level ORM yang lebih tinggi, Engine dan Connection adalah raja (dan ratu?) - baca terus.