Ketika model query APIs 1 tidak pergi jauh, anda dapat kembali menulis SQL mentah. Django memberikan anda dua cara dari melaksanakan permintaan SQL mentah: anda dapat menggunakan Manager.raw() untuk perform raw queries and return model instances, atau anda dapat menghindari lapisan model seluruhnya dan execute custom SQL directly.
Metode pengelola raw() dapat digunakan untuk melakukan permintaan SQL mentah yang mengembalikan instance model:
Metode ini mengambil sebuah permintaan SQL mentah, menjalankan itu, dan mengembalikan sebuah instance django.db.models.query.RawQuerySet. Instance RawQuerySet ini dapat diulang terhadap seperti QuerySet biasa untuk menyediakan instance-instance obyek.
Ini adalah terbaik digambarkan dengan sebuah contoh. Kiranya anda mempunyai model berikut:
\nclass Person(models.Model):\n first_name = models.CharField(...)\n last_name = models.CharField(...)\n birth_date = models.DateField(...)\nAnda dapat kemudian menjalankan SQL penyesuaian seperti itu:
\n>>> for p in Person.objects.raw('SELECT * FROM myapp_person'):\n... print(p)\nJohn Smith\nJane Jones\nTentu saja, contoh ini tidak sangat menarik -- itu tepatnya sama seperti menjalankan Person.objects.all(). Bagaimanapun, raw() mempuyai banyak dari pilihan lain yang memuat itu lebih bertenaga.
raw() secara otomatis memetakan bidang-bidang dalam permintaan ke bidang pada model.
Urutan dari bidang-bidang daam permintaan anda tidak masalah. Dengan kata lain, kedua dari permintaan berikut bekerja mirip:
\n>>> Person.objects.raw('SELECT id, first_name, last_name, birth_date FROM myapp_person')\n...\n>>> Person.objects.raw('SELECT last_name, birth_date, first_name, id FROM myapp_person')\n...\nPencocokan selesai berdasarkan nama. Ini berarti bahwa anda dapat menggunakan klausa AS SQL untuk memetakan bidang-bidang dalam permintaan ke bidang-bidang model. Jadi jika anda mempunyai beberapa tabel lain yang mempunyai data Person dalam nya, anda dapat dengan mudah memetakan itu menjadi instance Person:
>>> Person.objects.raw('''SELECT first AS first_name,\n... last AS last_name,\n... bd AS birth_date,\n... pk AS id,\n... FROM some_other_table''')\nSelama nama-nama cocok, instance model akan dibuat dengan benar.
\nKalau tidak, anda dapat memetakan bidang-bidang dalam permintaan ke bidang-bidang model menggunakan argumen translations pada raw(). Ini adalah nama-nama pemetaan dictionary dalam permintaan pada nama-nama dari bidang pada model. Sebagai contoh, permintaan diatas dapat juga ditulis:
>>> name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'}\n>>> Person.objects.raw('SELECT * FROM some_other_table', translations=name_map)\nraw() mendukung pengindeksan, jadi jika anda butuh hanya hasil pertama anda dapat menulis:
>>> first_person = Person.objects.raw('SELECT * FROM myapp_person')[0]\nBagaimanapun, pengindeksan dan pemotongan tidak dilakukan pada tingkat basisdata. Jika anda mempunyai sejumlah besar obyek Person dalam basisdata anda, itu lebih efesien membatasi permintaan pada tingkat SQL:
>>> first_person = Person.objects.raw('SELECT * FROM myapp_person LIMIT 1')[0]\nBidang-bidang mungkin juga ditiadakan:
\n>>> people = Person.objects.raw('SELECT id, first_name FROM myapp_person')\nObyek Person dikembalikan oleh permintaan ini akan meniadakan instance-instance model (lihat defer()). Ini berarti bahwa bidang-bidang yang dihilangkan dari permintaan akan dimuat pada permintaan. Sebagai contoh:
>>> for p in Person.objects.raw('SELECT id, first_name FROM myapp_person'):\n... print(p.first_name, # This will be retrieved by the original query\n... p.last_name) # This will be retrieved on demand\n...\nJohn Smith\nJane Jones\nDari penampilan luar, ini terlihat seperti permintaan telah mengambil kedua nama pertama dan nama terakhir. Bagaimanapun, contoh ini sebenarnya menerbitkan 3 permintaan. Hanya nama pertama yang diambil oleh permintaan raw() -- nama terakhir keduanya diambil pada permintaan mereka telah cetak.
\nHanya ada sat bidang yang anda tidak dapat tinggalkan - bidang primary key. Django menggunakan primary key untuk mencirikan instance-instance model, jadi itu harus selalu disertakan dalam permintaan mentah. Sebuah pengecualian InvalidQuery akan dimunculkan jika anda lupa menyertakan primary key.
Anda dapat juga menjalankan permintaan mengandung bidang-bidang yang tidak ditentukan pada model. Sebagai contoh, kami dapat menggunakan PostgreSQL's age() function untuk mendapatkan daftar orang dengan umur mereka dihitung oleh basisdata:
\n>>> people = Person.objects.raw('SELECT *, age(birth_date) AS age FROM myapp_person')\n>>> for p in people:\n... print("%s is %s." % (p.first_name, p.age))\nJohn is 37.\nJane is 42.\n...\nraw()Link to this heading#Jika anda butuh melakukan permintaan gambaran parameter, anda dapat menggunakan argumen params pada raw():
>>> lname = 'Doe'\n>>> Person.objects.raw('SELECT * FROM myapp_person WHERE last_name = %s', [lname])\nparams adalah sebuah parameter list atau dictionary. Anda akan menggunakan palceholder %s dalam string permintaan untuk daftar, atau placeholder %(key)s untuk sebuah dictionary (dimana key diganti oleh kunci dictionary, tentu saja), tidak peduli dari mesin basisdata anda. Placeholder itu akan diganti dengan parameter dari argumen params.
Terkadang bahkan Manager.raw() tidak cukup: anda mungkin butuh melakukan permintaan yang tidak memetakan dengan bersih pada model, atau langsung menjalankan permintaan UPDATE, INSERT, atau DELETE.
Dalam kasus-kasus ini, anda dapat selalu mengakses basisdata secara langsung, fungsi disekitar lapisan model sepenuhnya.
\nObyek django.db.connection mewakili hubungan basisdata awalan. Untuk menggunakan hubungan basisdata, panggil connection.cursor() untuk mendapatkan obyek kursor. Kemudian, panggil cursor.execute(sql, [params]) untuk menjalankan SQL dan cursor.fetchone() atau cursor.fetchall() untuk mengembalikan baris hasil.
Sebagai contoh:
\nfrom django.db import connection\n\ndef my_custom_sql(self):\n with connection.cursor() as cursor:\n cursor.execute("UPDATE bar SET foo = 1 WHERE baz = %s", [self.baz])\n cursor.execute("SELECT foo FROM bar WHERE baz = %s", [self.baz])\n row = cursor.fetchone()\n\n return row\nUntuk melindungi terhadap penyuntikan SQL, anda tidak harus menyertakan kutipan disekitar placeholder %s dalam string SQL.
Catat bahwa jika anda ingin menyertakan harfiah tanda persen dalam permintaan, anda telah menggandakan mereka dalam kasus anda sedang melewatkan parameter:
\ncursor.execute("SELECT foo FROM bar WHERE baz = '30%'")\ncursor.execute("SELECT foo FROM bar WHERE baz = '30%%' AND id = %s", [self.id])\nJika anda sedang menggunakan more than one database 1, anda dapat menggunakan django.db.connections untuk mengambil hubungan (dan kursor ) untuk basisdata khusus. django.db.connections adalah obyek seperti-dictionary yang mengizinkan anda mengambil hubungan khusus menggunakan nama lainnya:
from django.db import connections\ncursor = connections['my_db_alias'].cursor()\n# Your code here...\nSecara awalan, API DB Python akan mengembalikan hasil tanpa nama-nama bidang mereka, yang berarti anda jadi list dari nilai, daripada dict. Pada penampilan kecil dan biaya memori, anda dapat mengembalikan hasil sebagai dict dengan menggunakan sesuatu seperti ini:
def dictfetchall(cursor):\n "Return all rows from a cursor as a dict"\n columns = [col[0] for col in cursor.description]\n return [\n dict(zip(columns, row))\n for row in cursor.fetchall()\n ]\nPilihan lain adalah menggunakan collections.namedtuple() dari pustaka standar Python. Sebuah namedtuple adalah obyek seperti-tuple yang mempunyai bidang-bidang diakses oleh atribut pencarian; itu juga dapat diindeks dan berulang. Hasilnya adalah tetap dan dapat diakses oleh bidang nama atau indeks, yang mungkin berguna:
from collections import namedtuple\n\ndef namedtuplefetchall(cursor):\n "Return all rows from a cursor as a namedtuple"\n desc = cursor.description\n nt_result = namedtuple('Result', [col[0] for col in desc])\n return [nt_result(*row) for row in cursor.fetchall()]\nIni adalah sebuah contoh perbedaan diantara tiga:
\n>>> cursor.execute("SELECT id, parent_id FROM test LIMIT 2");\n>>> cursor.fetchall()\n((54360982, None), (54360880, None))\n\n>>> cursor.execute("SELECT id, parent_id FROM test LIMIT 2");\n>>> dictfetchall(cursor)\n[{'parent_id': None, 'id': 54360982}, {'parent_id': None, 'id': 54360880}]\n\n>>> cursor.execute("SELECT id, parent_id FROM test LIMIT 2");\n>>> results = namedtuplefetchall(cursor)\n>>> results\n[Result(id=54360982, parent_id=None), Result(id=54360880, parent_id=None)]\n>>> results[0].id\n54360982\n>>> results[0][0]\n54360982\nconnection dan cursor kebanyakan menerapkan API-DB Python standar digambarkan dalam pep:249 — kecuali ketika itu datang pada transaction handling 1.
Jika anda akrab dengan DB-API Python, catat bahwa pernyataan SQL dalam cursor.execute() menggunakan placeholder, "%s", daripada menambahkan parameter langsung dalam SQL. Jika anda menggunakan teknik ini, pustaka basisdata pokok akan otomatis meloloskan parameter anda seperlunya.
Juga catat bahwa Django mengharapkan placeholder "%s", bukan placeholder "?", yang digunakan oleh pengikatan Python SQLite. Ini adalah untuk kebaikan dari ketetapan dan kesegaran.
Menggunakan sebuah kursor sebagai pengelola konteks:
\nwith connection.cursor() as c:\n c.execute(...)\nsetara pada:
\nc = connection.cursor()\ntry:\n c.execute(...)\nfinally:\n c.close()\nPanggilan sebuah store procedure dengan nama diberikan. Sebuah urutan (params) atau dictionary (kparams) dari parameter masukan mungkin disediakan. Kebanyakan basisdata tidak mendukung kparams. Dari backend siap-pakai Django, hanya Oracle mendukung itu.
Sebagai contoh, diberikan ini prosedur penyimpanan dalam sebuah basisdata Oracle:
\nCREATE PROCEDURE "TEST_PROCEDURE"(v_i INTEGER, v_text NVARCHAR2(10)) AS\n p_i INTEGER;\n p_text NVARCHAR2(10);\nBEGIN\n p_i := v_i;\n p_text := v_text;\n ...\nEND;\nIni akan memanggil itu:
\nwith connection.cursor() as cursor:\n cursor.callproc('test_procedure', [1, 'test'])\n