Panduan topik ini menggambarkan dukungan Django untuk interaksi dengan banyak basisdata. Kebanyakan dari sisa dokumentasi Djangomenganggap anda berinteraksi dengan basisdata tunggal. Jika anda ingin berinteraksi dengan banyak basisdata, anda akan butuh mengambil beberapa langkah-langkah tambahan.
\n\nLangkah pertama untuk menggunakan lebih dari satu basisdata dengan Django adalah memberitahu Django tentang peladen basisdata anda akan gunakan. Ini dilakukan menggunakan pengaturan DATABASES. Pengaturan ini memetakan nama lain basisdata, yang adalah cara mengacu ke basisdata tertentu sepanjang Django, ke sebuah kamus dari pengaturan untuk hubungan tertentu itu. Pengaturan di sebelah dalam kamus digambarkan sepenuhnya dalam dokumentasi DATABASES.
Basisdata dapat mempunyai nama lain apapun anda pilih. Bagaimanapun, nama lain default mempunyai makna khusus. Django menggunakan basisdata dengan nama lain dari default ketika tidak ada lagi basisdata telah dipilih.
Berikut adalah sebuah contoh potongan settings.py menentukan dua basisdata -- sebuah awalan basisdata PostgreSQL dan basisdata MySQL disebut users:
DATABASES = {\n 'default': {\n 'NAME': 'app_data',\n 'ENGINE': 'django.db.backends.postgresql',\n 'USER': 'postgres_user',\n 'PASSWORD': 's3krit'\n },\n 'users': {\n 'NAME': 'user_data',\n 'ENGINE': 'django.db.backends.mysql',\n 'USER': 'mysql_user',\n 'PASSWORD': 'priv4te'\n }\n}\nJika konsep dari basisdata default tidak masuk akal dalam konteks proyek anda, anda butuh berhati-hati untuk selalu menentukan basisdata anda ingin gunakan. Django membutuhkan masukan basisdata default untuk ditentukan, tetapi parameter dictionary dapat berupa kosong jika itu akan tidak digunakan. Untuk melakkukan ini, anda harus menyetel DATABASE_ROUTERS untuk semua dari model aplikasi anda, termasuk itu dalam bantuan dan aplikasi pihak-ketiga apapun anda sedang gunakan, sehingga tidak ada permintaan ke basisdata awalan. Berikut adalah contoh potongan settings.py menentukan basisdata dua bukan-awalan, dengan masukan default sengaja dibiarkan kosong:
DATABASES = {\n 'default': {},\n 'users': {\n 'NAME': 'user_data',\n 'ENGINE': 'django.db.backends.mysql',\n 'USER': 'mysql_user',\n 'PASSWORD': 'superS3cret'\n },\n 'customers': {\n 'NAME': 'customer_data',\n 'ENGINE': 'django.db.backends.mysql',\n 'USER': 'mysql_cust',\n 'PASSWORD': 'veryPriv@ate'\n }\n}\nIf you attempt to access a database that you haven't defined in your\nDATABASES setting, Django will raise a\ndjango.utils.connection.ConnectionDoesNotExist exception.
Perintah pengelolaan migrate berjalan pada satu basisdata pada satu waktu. Secara awalan, itu berjalan pada basisdata default, tetapi dengan menyediakan pilihan --database 1, anda dapat memberitahu itu untuk mensinkronkan basisdata berbeda. Jadi, untuk mensinkronkan semua kedalam semua basisdata dalam contoh pertama diatas, anda akan butuh memanggil:
$ ./manage.py migrate\n$ ./manage.py migrate --database=users\nJika anda tidak ingin setiap aplikasi disinkronkan kedalam basisdata tertentu, anda dapat menentukan database router1 yang menerapkan batasan kebijakan ketersediaan dari model tertentu.
\nJika, seperti dalam contoh kedua diatas, anda telah meninggalkan basisdata default kosong, anda harus menyediakan sebuah nama basisdata setiap waktu anda menjalankan migrate. Menghilangkan nama basisdata akan memunculkan sebuah kesalahan. Untuk contoh kedua:
$ ./manage.py migrate --database=users\n$ ./manage.py migrate --database=customers\nKebanyakan perintah django-admin lain yang berinteraksi dengan basisdata berjalan dalam cara sama seperti migrate -- mereka hanya berjalan pada satu basisdata pada satu waktu, menggunakan --database untuk mengendalikan penggunaan basisdata.
Sebuah pengecualian pada aturan ini adalah perintah makemigrations. Itu mengecek riwayat perpindahan di basisdata untuk menangkap masalah dengan berkas perpindahan yang ada (yang dapat disebabkan dengan menyunting mereka) sebelum membuat perpindahan baru. Secara awalan, itu memeriksa hanya basisdata default, tetapi itu merundingkan metode allow_migrate() dari routers jika apapun terpasang.
Cara termudah menggunakan banyak basisdata adalah menyetel skema perutean basisdata. Skema perutean awalan memastikan bahwa obyek tetap 'sticky' ke basisdata aslinya (yaitu, obyek diambil dari basisdata foo akan disimpan pada basisdata sama). Skema perute awalan memastikan bahwa jika sebuah absisdata tidak ditentukan, semua permintaan kembali ke basisdata default.
Anda tidak perlu melakukan apapun untuk mengaktifkan skema perutean awalan -- itu disediakan 'beda dari biasanya' pada setiap proyek Django. Bagaimanapun, jika anda ingin menerapkan lebih menarik perilaku peruntukan basisdata, anda dapat menentukan dan memasang perute basisdata anda sendiri.
\nPerute basisdata adalah kelas yang menyediakan sampai empat metode:
\nSarankan basisdata yang harus digunakan untuk membaca tindakan-tindakan untuk obyek dari jenis model.
Jika tindakan basisdata dapat menyediakan informasi tambahan apapun yang mungkin membantu dalam memilih basisdata, itu akan menyediakan dalam dictionary hints. Rincian pada peunjuk sah disediakan below 1.
Mengembalikan None jika tidak ada saran.
Sarankan basisdata yang harus digunakan untuk menulis dari obyek dari jenis Model.
\nJika tindakan basisdata dapat menyediakan informasi tambahan apapun yang mungkin membantu dalam memilih basisdata, itu akan menyediakan dalam dictionary hints. Rincian pada peunjuk sah disediakan below 1.
Mengembalikan None jika tidak ada saran.
Mengembalikan True jika sebuah hubungan diantara obj1 dan obj2 harus diizinkan, False jika hubungan harus dicegah, atau None jika perute tidak memiliki pendapat. Ini adalah murni tindakan pengesahan, digunakan oleh foreign key dan tindakan many to many untuk menentukan jika hubungan harus diizinkan diantara dua obyek.
If no router has an opinion (i.e. all routers return None), only\nrelations within the same database are allowed.
Tentukan jika tindakan perpindahan diizinkan untuk menjalankan pada basisdata dengan nama lain db. Mengembalikan True jika tindakan harus berjalan, False jika itu tidak harus berjalan, atau None jika perute tidak memiliki pendapat.
Argumen penempatan app_label adalah label untuk aplikasi sedang dipindahkan.
model_name disetel oleh kebanyakan tindakan perpindahan pada nilai dari model._meta.model_name (versi huruf kecil dari model __name__) dari model sedang dipindahkan. Nilai itu adalah None untuk tindakan RunPython dan RunSQL meskipun mereka menyediakan itu menggunakan petunjuk.
hints digunakan oleh tindakan tertentu untuk berkomunikasi informasi tambahan ke perute.
Ketika hints disetel, hints biasanya mengandung kelas model dibawah kunci 'model'. Catat bahwa itu mungkin berupa historical model 1, dan dengan demikian tidak mempunyai atribut penyesuaian apapun, metode, atau pengelola. Anda harus hanya bergantung pada _meta.
Metode ini dapat juga digunakan untuk menentukan ketersediaan dari sebuah model pada basisdata yang diberikan.
\nmakemigrations selalu membuat perpindahan untuk perubahan model, tetapi jika allow_migrate() mengembalikan False, tindakan perpindahan apapun untuk model_name akan secara diam dilewatkan ketika menjalankan migrate pada db. Merubah perilaku dari allow_migrate() untuk model yang sudah berpindah mungkin menghasilkan rusak dalam foreign key, tabel tambahan, atau tabel hilang. Ketika makemigrations memeriksa riwayat perpindahan, itu melewati basisdata dimana tidak ada aplikasi diizinkan berpindah.
Perute tidak harus menyediakan semua metode ini -- itu mungkin menghilangkan satu atau lebih dari mereka. Jika satu dari metode ini dihilangkan, Django akan melewati perute itu ketika melakukan pemeriksaan terkait.
\nPetunjuk diterima oleh perute basisdata dapat digunakan untuk memutuskan basisdata mana harus menerima permintaan yang diberikan.
\nSaat sekarang, petunjuk satu-satunya akan disediakan adalah instance, sebuah instance obyek yang terkait ke tindakan baca atau tulis yang berlangsung. Ini mungkin instance yang sedang disimpan, atau itu mungkin berupa sebuah instance yang sedang ditambahkan dalam hubungan many-to-many. Dalam beberapa kasus, tidak ada petunjuk instance akan disediakan sama sekali. Perute memeriksa untuk kehadiran dari sebuah petunjuk instance, dan menentukan jika petunjuk itu harus digunakan untuk merubah perulaku perutean.
Perute basisdata dipasang menggunakan pengaturan DATABASE_ROUTERS. Pengaturan ini menentukan daftar dari nama-nama kelas, setiap menentukan perute harus digunakan dengan perute master (django.db.router).
The master router is used by Django's database operations to allocate\ndatabase usage. Whenever a query needs to know which database to use,\nit calls the master router, providing a model and a hint (if\navailable). Django then tries each router in turn until a database\nsuggestion can be found. If no suggestion can be found, it tries the\ncurrent instance._state.db of the hint\ninstance. If a hint instance wasn't provided, or instance._state.db is None, the master router will allocate\nthe default database.
Jadi - apa ini artinya dalam praktik? Mari kita pertimbangkan konfigurasi contoh lain. Satu ini akan mempunyai beberapa basisdata: satu untuk aplikasi auth, dan semua aplikasi lain menggunakan setelah utama/tiruan dengan duatiruan baca. Ini adalah pengaturan menentukan basisdata ini:
DATABASES = {\n 'default': {},\n 'auth_db': {\n 'NAME': 'auth_db_name',\n 'ENGINE': 'django.db.backends.mysql',\n 'USER': 'mysql_user',\n 'PASSWORD': 'swordfish',\n },\n 'primary': {\n 'NAME': 'primary_name',\n 'ENGINE': 'django.db.backends.mysql',\n 'USER': 'mysql_user',\n 'PASSWORD': 'spam',\n },\n 'replica1': {\n 'NAME': 'replica1_name',\n 'ENGINE': 'django.db.backends.mysql',\n 'USER': 'mysql_user',\n 'PASSWORD': 'eggs',\n },\n 'replica2': {\n 'NAME': 'replica2_name',\n 'ENGINE': 'django.db.backends.mysql',\n 'USER': 'mysql_user',\n 'PASSWORD': 'bacon',\n },\n}\nNow we'll need to handle routing. First we want a router that knows to\nsend queries for the auth and contenttypes apps to auth_db\n(auth models are linked to ContentType, so they must be stored in the\nsame database):
class AuthRouter:\n """\n A router to control all database operations on models in the\n auth and contenttypes applications.\n """\n route_app_labels = {'auth', 'contenttypes'}\n\n def db_for_read(self, model, **hints):\n """\n Attempts to read auth and contenttypes models go to auth_db.\n """\n if model._meta.app_label in self.route_app_labels:\n return 'auth_db'\n return None\n\n def db_for_write(self, model, **hints):\n """\n Attempts to write auth and contenttypes models go to auth_db.\n """\n if model._meta.app_label in self.route_app_labels:\n return 'auth_db'\n return None\n\n def allow_relation(self, obj1, obj2, **hints):\n """\n Allow relations if a model in the auth or contenttypes apps is\n involved.\n """\n if (\n obj1._meta.app_label in self.route_app_labels or\n obj2._meta.app_label in self.route_app_labels\n ):\n return True\n return None\n\n def allow_migrate(self, db, app_label, model_name=None, **hints):\n """\n Make sure the auth and contenttypes apps only appear in the\n 'auth_db' database.\n """\n if app_label in self.route_app_labels:\n return db == 'auth_db'\n return None\nDan kami juga ingin sebuah perute yang mengirim semua aplikasi lain semua ke konfigurasi utama/tiruan, dan secara acak memilih sebuah tiruan untuk dibaca:
\nimport random\n\nclass PrimaryReplicaRouter:\n def db_for_read(self, model, **hints):\n """\n Reads go to a randomly-chosen replica.\n """\n return random.choice(['replica1', 'replica2'])\n\n def db_for_write(self, model, **hints):\n """\n Writes always go to primary.\n """\n return 'primary'\n\n def allow_relation(self, obj1, obj2, **hints):\n """\n Relations between objects are allowed if both objects are\n in the primary/replica pool.\n """\n db_set = {'primary', 'replica1', 'replica2'}\n if obj1._state.db in db_set and obj2._state.db in db_set:\n return True\n return None\n\n def allow_migrate(self, db, app_label, model_name=None, **hints):\n """\n All non-auth models end up in this pool.\n """\n return True\nAkhirnya, dalam berkas pengaturan, kami menambahkan berikut (mengganti path.to. dengan jalur Python sebenarnya pada modul dimana perute ditentukan):
DATABASE_ROUTERS = ['path.to.AuthRouter', 'path.to.PrimaryReplicaRouter']\nUrutan dimana perute diolah adalah penting. Perute akan diminta agar mereka didaftarkan dalam pengaturan DATABASE_ROUTERS. Dalam contoh ini, AuthRouter diolah sebelum PrimaryReplicaRouter, dan sebagai hasil, keputusan tentang model-model dalam auth diolah sebelum keputusan lain apapun dibuat. Jika pengaturan DATABASE_ROUTERS mendaftarkan dua perute dalam urutan lain, PrimaryReplicaRouter.allow_migrate() akan diolah dahulu. Tangkap-semua alami dari penerapan PrimaryReplicaRouter akan berarti bahwa semua model-model akan tersedia pada semua basisdata.
With this setup installed, and all databases migrated as per\nSinkronisasi basisdata anda, lets run some Django code:
\n>>> # This retrieval will be performed on the 'auth_db' database\n>>> fred = User.objects.get(username='fred')\n>>> fred.first_name = 'Frederick'\n\n>>> # This save will also be directed to 'auth_db'\n>>> fred.save()\n\n>>> # These retrieval will be randomly allocated to a replica database\n>>> dna = Person.objects.get(name='Douglas Adams')\n\n>>> # A new object has no database allocation when created\n>>> mh = Book(title='Mostly Harmless')\n\n>>> # This assignment will consult the router, and set mh onto\n>>> # the same database as the author object\n>>> mh.author = dna\n\n>>> # This save will force the 'mh' instance onto the primary database...\n>>> mh.save()\n\n>>> # ... but if we re-retrieve the object, it will come back on a replica\n>>> mh = Book.objects.get(title='Mostly Harmless')\nContoh ini menentukan sebuah perute untuk menangani interaksi dengan model-model dari aplikasi auth, dan perute lain untuk mengangani interaksi dengan semua aplikasi lain. Jika anda membiarkan basisdata default anda kosong dan tidak ingin menentukan perute basisdata tangkap-semua untuk mengangani semua aplikasi tidak sebaliknya ditentukan, perute anda harus menangani nama-nama dari semua aplikasi dalam INSTALLED_APPS sebelum anda berpindah. Lihat Perilaku dari aplikasi bantuan untuk informasi tentang apliaksi bantuan yang harus bersama-sama dalam satu basisdata.
Django juga menyediakan sebuah API yang mengizinkan anda merawat kendali lengkap terhadap penggunaan basisdata dalam kode anda. Peruntukan basisdata ditentukan manual terhadap basisdata diperuntukkan oleh sebuah perute.
\nQuerySetLink to this heading#You can select the database for a QuerySet at any point in the\nQuerySet "chain." Call using() on the QuerySet to get another\nQuerySet that uses the specified database.
using() mengambil argumen tunggal: nama lain dari basisdata pada dimana anda ingin menjalankan permintaan. Sebagai contoh:
>>> # This will run on the 'default' database.\n>>> Author.objects.all()\n\n>>> # So will this.\n>>> Author.objects.using('default').all()\n\n>>> # This will run on the 'other' database.\n>>> Author.objects.using('other').all()\nsave()Link to this heading#Gunakan kata kunci using pada Model.save() untuk menentukan pada basisdata mana data harus disimpan.
Sebagai contoh, untuk menyimpan sebuah obyek pada basisdata legacy_users, anda akan menggunakan ini:
>>> my_object.save(using='legacy_users')\nJika anda tidak menentukan using, metode save() kan menyimpan kedalam basisdata awalan ditempatkan oleh perute.
Jika anda menyimpan sebuah instance pada satu basisdata, itu mungkin menggoda untuk menggunakan save(using=...) sebagai sebuah cara berpindah instance ke basisdata baru. Bagaimanapun, jika anda tidak mengambil langkah-langkah yang sesuai, ini dapat memiliki beberapa konsekuensi tidak diharapkan.
Pertimbangkan contoh berikut
\n>>> p = Person(name='Fred')\n>>> p.save(using='first') # (statement 1)\n>>> p.save(using='second') # (statement 2)\nDalam pernyataan 1, sebuah obyek Person baru disimpan ke basisdata first. Pada saat ini, p tidak memiliki primary key, jadi Django menerbitkan sebuah pernyataan SQL INSERT. Ini membuat sebuah primary key, dan Django memberikan primary key itu ke p.
Ketika penyimpanan muncul dalam pernyataan 2, p sudah mempunyai nilai primary key, dan Django akan berusaha menggunakan primary key itu pada basisdata baru. Jika nilai primary key tidak digunakan dalam basisdata second, kemudian akdan tidak mempunyai masalah apapun -- obyek akan disalin ke basisdata baru.
Bagaimanapun, jika primary key dari p sudah digunakan pada basisdata second, obyek yang ada dalam basisdata second akan ditimpan ketika p disimpan.
Anda dapat menghindari ini dalam dua cara. Pertama, anda dapat membersihkan primary key dari instance. Jika sebuah obyek tidak mempunyai primary key, Django akan memperlakukan itu sebagai sebuah obyek baru, menghindari kehilangan dari data pada basisdata second:
>>> p = Person(name='Fred')\n>>> p.save(using='first')\n>>> p.pk = None # Clear the primary key.\n>>> p.save(using='second') # Write a completely new object.\nPilihan kedua adalah menggunakan pilihan force_insert pada save() untuk memastikan Django melakukan INSERT SQL:
>>> p = Person(name='Fred')\n>>> p.save(using='first')\n>>> p.save(using='second', force_insert=True)\nIni akan memastikan bahwa seseorang bernama Fred akan mempunyai primary key sama pada kedua basisdata. Jika primary key sudah digunakan ketika anda mencoba menyimpan kedalam basisdata kedua, sebuah kesalahan akan dimunculkan.
Secara awalan, sebuah panggilan untuk menghapus obyek yang ada akan dijalankan pada basisdata sama yang digunakan untuk mengambil obyek dalam tempat pertama:
\n>>> u = User.objects.using('legacy_users').get(username='fred')\n>>> u.delete() # will delete from the `legacy_users` database\nUntuk menentukan basisdata dari model mana akan dihapus, lewatkan sebuah argumen kata kunci using pada metode Model.delete(). Argumen ini bekerja seperti argumen kata kunci using pada save().
Sebagai contoh, jika anda sedang memindahkan pengguna dari basisdata legacy_users ke basisdata new_users, anda mungkin menggunakan perintah-perintah ini:
>>> user_obj.save(using='new_users')\n>>> user_obj.delete(using='legacy_users')\nGunakan metode db_manager() pada pengelola untuk memberikan pengelola mengakses ke basisdata bukan-awalan.
Sebagai contoh, katakan anda mempunyai metode pengelolaan penyesuaian yang menyentuh basisdata -- User.objects.create_user(). Karena create_user() adalah metode pengelola, bukan metode QuerySet, anda tidak dapat melakukan User.objects.using('new_users').create_user(). (Metode create_user() hanya tersedia pada User.objects, pengelola, bukan pada obyek QuerySet diturunkan dari pengelola.) Pemecahannya adalah menggunakan db_manager(), seperti ini:
User.objects.db_manager('new_users').create_user(...)\ndb_manager() mengembalikan sebuah salinan dari ikatan pengelola pada basisdata anda tentukan.
get_queryset() dengan basisdata banyakLink to this heading#Jika anda menimpa get_queryset() pada pengelola anda, apstikan untuk antara memanggil metode pada induk (menggunakan super()) atau melakukan penanganan sesuai dari atribut _db pada pengelola (sebuah string mengandung nama dari basisdata untuk digunakan).
Sebagai contoh, jika anda ingin mengembalikan penyesuaian kelas QuerySet dari metode get_queryset, anda dapat melakukan ini:
class MyManager(models.Manager):\n def get_queryset(self):\n qs = CustomQuerySet(self.model)\n if self._db is not None:\n qs = qs.using(self._db)\n return qs\nAdmin Django tidak mempunyai dukungan jelas untuk banyak basisdata. Jika anda ingin menyediakan sebuah antarmuka admin untuk sebuah model pada sebuah basisdata daripada selain ditentukan oleh rantai peute anda, anda akan butuh menulis kelas-kelas ModelAdmin penyesuaian yang akan langsung ke admin untuk menggunakan basisdata khusus untuk isi.
Obyek ModelAdmin mempunyai lima metode yang membutuhkan penyesuaian untuk dukungan banyak-basisdata:
class MultiDBModelAdmin(admin.ModelAdmin):\n # A handy constant for the name of the alternate database.\n using = 'other'\n\n def save_model(self, request, obj, form, change):\n # Tell Django to save objects to the 'other' database.\n obj.save(using=self.using)\n\n def delete_model(self, request, obj):\n # Tell Django to delete objects from the 'other' database\n obj.delete(using=self.using)\n\n def get_queryset(self, request):\n # Tell Django to look for objects on the 'other' database.\n return super().get_queryset(request).using(self.using)\n\n def formfield_for_foreignkey(self, db_field, request, **kwargs):\n # Tell Django to populate ForeignKey widgets using a query\n # on the 'other' database.\n return super().formfield_for_foreignkey(db_field, request, using=self.using, **kwargs)\n\n def formfield_for_manytomany(self, db_field, request, **kwargs):\n # Tell Django to populate ManyToMany widgets using a query\n # on the 'other' database.\n return super().formfield_for_manytomany(db_field, request, using=self.using, **kwargs)\nPenerapan disediakan disini menerapkan strategi banyak-basisdata dimana semua obyek dari jenis yang diberikan disimpan pada basisdata khusus (sebagai contoh, semua obyek User dalam basisdata lain). Jika penggunaan anda dari banyak basisdata lebih rumit, ModelAdmin anda akan butuh mencerminkan strategi itu.
Obyek InlineModelAdmin dapat ditangani di gaya yang mirip. Mereka membutuhkan tiga metode penyesuaian:
class MultiDBTabularInline(admin.TabularInline):\n using = 'other'\n\n def get_queryset(self, request):\n # Tell Django to look for inline objects on the 'other' database.\n return super().get_queryset(request).using(self.using)\n\n def formfield_for_foreignkey(self, db_field, request, **kwargs):\n # Tell Django to populate ForeignKey widgets using a query\n # on the 'other' database.\n return super().formfield_for_foreignkey(db_field, request, using=self.using, **kwargs)\n\n def formfield_for_manytomany(self, db_field, request, **kwargs):\n # Tell Django to populate ManyToMany widgets using a query\n # on the 'other' database.\n return super().formfield_for_manytomany(db_field, request, using=self.using, **kwargs)\nSekali anda telah menulis pengertian admin model anda, mereka dapat didaftarkan dengan instance Admin apapun:
from django.contrib import admin\n\n# Specialize the multi-db admin objects for use with specific models.\nclass BookInline(MultiDBTabularInline):\n model = Book\n\nclass PublisherAdmin(MultiDBModelAdmin):\n inlines = [BookInline]\n\nadmin.site.register(Author, MultiDBModelAdmin)\nadmin.site.register(Publisher, PublisherAdmin)\n\nothersite = admin.AdminSite('othersite')\nothersite.register(Publisher, MultiDBModelAdmin)\nContoh ini menyetel dua situs admin. Pada situs pertama, obyek-obyek Author dan Publisher dibuka; obyek-obyek Publisher mempunyai sebuah dibarisan datar menunjukkan buku-buku diterbitkan oleh penerbit. Situs kedua membuka hanya penerbit, tanpa barisan.
Jika anda menggunakan lebih dari satu basisdata anda dapat menggunakan django.db.connections untuk mengambil hubungan (dan kursor) untuk basisdata tertentu. django.db.connections adalah objek seperti-kamus yang mengizinkan anda mengambil hubungan tertentu menggunakan nama lainnya:
from django.db import connections\nwith connections['my_db_alias'].cursor() as cursor:\n ...\nDjango saat ini tidak menyediakan dukungan apapun untuk foreign key atau hubungan many-to-many menjangkau banyak basisdata. Jika anda telah menggunakan sebuah perute pada model sebagian ke basisdata berbeda, foreign key apapun dan hubungan many-to-many ditentukan oleh modek-model tersebut harus secara internal pada basisdata tunggal.
\nIni karena dari kesatuan referensial. Untuk merawat hubungan diantara dua obyek, Django butuh mengetahui bahwa primary key dari obyek terkait adalah sah. Jika primary key disimpan pada basisdata terpisah, itu tidak mungkin dengan mudah menilai keabsahan primary key.
\nJika anda sedang menggunakan Postgres, Oracle, atau MySQL dengan InnoDB, ini dipaksa pada tingkat kesatuan basisdata -- batasan kunci tingkatan basisdata mencegah dari pembuatan dari hubungan yang tidak dapat disahkan.
\nBagaimanapun, jika anda sedang menggunakan SQLite atay MySQL dengan tabel MyISAM, tidak ada pemaksaan kesatuan referensial; sebagai hasil, anda mungkin dapat me 'niru' foreign key basisdata. bagaimanapun, konfigurasi ini tidak secara resmi didukung oleh Django.
\nBeberapa aplikasi bantuan termasuk model-model, dan beberapa aplikasi bergantung pada lainnya. Sejak hubungan silang-basisdata tidak dimungkinkan, ini membuat beberapa pembatasan pada bagaimana anda dapat memisahkan model-model ini terhadap basisdata:
\nsetiap satu dari contenttypes.ContentType, sessions.Session dan sites.Site dapat disimpan dalam basisdata apapun, diberikan perute yang cocok.
Model-model auth — User, Group dan Permission — dikaitkan bersama-sama dan dikaitkan pada ContentType, sehingga mereka harus disimpan dalam basisdata sama sebagai ContentType.
admin bergantung pada auth, jadi modelnya harus di basisdata sama seperti auth.
flatpages dan redirects bergantung pada sites,jadi model-model mereka harus di basisdata yang sama seperti sites.
Sebagai tambahan, beberapa obyek otomatis dibuat hanya setelah migrate membuat tabel untuk menahan mereka dalam basisdata:
Site awal,
sebuah ContentType untuk setiap model (termasuk itu tidak disimpan di basisdata itu),
the Permissions for each model (including those not stored in that\ndatabase).
Untuk pengaturan umum dengan banyak basisdata, itu tidak berguna memiliki obyek-obyek ini dalam lebih dari satu basisdata. Pengaturan umum menyertakan utama/tiruan dan menghubungkan ke basisdata luar. Karena itu, itu dianjurkan untuk menulis database router1 yang mengizinkan mensinkronkan ketiga model ini pada hanya satu basisdata. Gunakan pendekatan sama untuk aplikasi bantuan dan pihak-ketiga yang tidak butuh tabel mereka dalam banyak basisdata.
\n\n