--- title: "Bunachair sonraí iliom" version: 6.1 locale: ga source: https://docs.djangoproject.com/ga/6.1/topics/db/multi-db/ canonical: https://djangodocs.dev/ga/6.1/topics/db/multi-db/ --- # Bunachair sonraí iliom Déanann an treoir ábhair seo cur síos ar thacaíocht Django chun idirghníomhú le bunachair Glacann an chuid is mó den chuid eile de dhoiciméadú Django go bhfuil tú ag idirghníomhú le bunachar sonraí amháin. Más mian leat idirghníomhú le bunachair sonraí iolracha, beidh ort roinnt céimeanna breise a ghlacadh. > **See also** > > Féach: ref: testing-multi-db le haghaidh faisnéise faoi thástáil le bunachair sonraí iolracha. ## Sainmhíniú do bhunachar Is é an chéad chéim chun níos mó ná bunachar sonraí amháin a úsáid le Django ná insint do Django faoi na freastalaithe bunachar sonraí a bheidh á úsáid agat. Déantar é seo ag baint úsáide as an socrú:setting: DATABASES. Déanann an socrú seo mapáil ainmneacha bunachar sonraí, ar bealach iad chun tagairt a dhéanamh do bhunachar sonraí ar leith ar fud Django, chuig foclóir socruithe don nasc sonrach sin. Déantar cur síos iomlán ar na socruithe sna foclóirí istigh sa doiciméadach:setting: DATABASES. Is féidir le bunachair sonraí aon ainm a roghnaíonn tú a bheith Mar sin féin, tá tábhacht speisialta ag an alias `default`. Úsáideann Django an bunachar sonraí leis an alias de `default` nuair nach roghnaíodh aon bhunachar sonraí eile. Seo a leanas sampla `settings.py` snippet a shainmhíníonn dhá bhunachar sonraí - bunachar sonraí réamhshocraithe PostgreSQL agus bunachar sonraí MySQL ar a dtugtar `users`: ``` DATABASES = { "default": { "NAME": "app_data", "ENGINE": "django.db.backends.postgresql", "USER": "postgres_user", "PASSWORD": "s3krit", }, "users": { "NAME": "user_data", "ENGINE": "django.db.backends.mysql", "USER": "mysql_user", "PASSWORD": "priv4te", }, } ``` Mura bhfuil ciall ag coincheap bunachar sonraí réamhshocraithe\` i gcomhthéacs do thionscadail, ní mór duit a bheith cúramach an bunachar sonraí a theastaíonn uait a úsáid a shonrú i gcónaí. Éilíonn Django go ndéanfar iontráil bunachar sonraí ```default` a shainiú, ach is féidir foclóir na paraiméadair a fhágáil bán mura n-úsáidfear é. Chun seo a dhéanamh, ní mór duit:setting: `DATABASE_ROUTERS` a chur ar bun do mhúnlaí uile d'aipeanna, lena n-áirítear iad siúd in aon aipeanna contrib agus tríú páirtí atá á úsáid agat, ionas nach ndéanfar aon cheisteanna a atreorú chuig an mbunachar sonraí réamhshocraithe. Seo a leanas sampla ``settings.py``` snippet a shainmhíníonn dhá bhunachar sonraí neamh-réamhshocraithe, agus an iontráil `default` fágtha folamh d'aon ghnó: ``` DATABASES = { "default": {}, "users": { "NAME": "user_data", "ENGINE": "django.db.backends.mysql", "USER": "mysql_user", "PASSWORD": "superS3cret", }, "customers": { "NAME": "customer_data", "ENGINE": "django.db.backends.mysql", "USER": "mysql_cust", "PASSWORD": "veryPriv@ate", }, } ``` Má dhéanann tú iarracht rochtain a fháil ar bhunachar sonraí nach bhfuil sainmhínithe agat i do shuíomh: DATABASES, ardóidh Django eisceacht Django.Utils.CONNECTION.CONNECTIONDOESNOTEXIST . ## Sioncrónú do bhunachar sonraí Feidhmíonn an t-ordú bainistíochta: DJADmin: imirce ar bhunachar sonraí amháin ag an am. De réir réamhshocraithe, oibríonn sé ar an mbunachar sonraí `réamhshocraithe`, ach tríd an rogha: --database a sholáthar, is féidir leat a rá dó bunachar sonraí difriúil a \shioncronú. Mar sin, chun gach samhail a shioncronú ar gach bunachar sonraí sa chéad shampla thuas, bheadh ort glaoch ar: ```shell $ ./manage.py migrate $ ./manage.py migrate --database=users ``` Mura dteastaíonn uait go ndéanfaí gach feidhmchlár a shioncronú le bunachar sonraí áirithe, is féidir leat a: ref: ródaire bunachar sonraí \\`a shainiú a chuireann beartas i bhfeidhm ag cur srian ar infhaighteacht samhlacha áirithe. Má d'fhág tú, mar atá sa dara sampla thuas, an bunachar sonraí `default` folamh, ní mór duit ainm bunachar sonraí a sholáthar gach uair a rith tú: djadmin: migrate. Trí ainm an bhunachar sonraí a fhágáil, d'ardódh earráid. Maidir leis an dara sampla: ```shell $ ./manage.py migrate --database=users $ ./manage.py migrate --database=customers ``` ### Orduithe bainistíochta eile a úsáid Oibríonn an chuid is mó d'orduithe ```django-admin ``eile a idirghníomhaíonn leis an mbunachar sonraí ar an mbealach céanna le: djadmin: `migrate` - ní oibríonn siad riamh ar bhunachar sonraí amháin ag an am, ag baint úsáide as ``- bunachar sonraí``` chun an bunachar sonraí a úsáidtear a rialú. Eisceacht ón riail seo is ea an t-ordú:djadmin: makemigrations. Bailíonn sé stair na himirce sna bunachair sonraí chun fadhbanna a ghabháil leis na comhaid imirce atá ann cheana féin (a d'fhéadfadh a bheith mar thoradh orthu a chur in eagar) sula gcruthaítear imirce nua. \De réir réamhshocraithe, ní sheiceálann sé ach an bunachar sonraí default\`, ach déanann sé dul i gcomhairle leis an modh:meth: allow\_migrate de:ref: ródair má tá aon cheann suiteáilte. ## Ródú uathoibríoch bunachar Is é an bealach is éasca le bunachair sonraí iolracha a úsáid ná scéim ródaithe bunachar sonraí a bhunú. Cinntíonn an scéim ródaithe réamhshocraithe go bhfanann rudaí 'greamaitheach' lena mbunachar sonraí bunaidh (ie, sábhálfar réad a aisghabhadh ón mbunachar sonraí foo' ar an mbunachar sonraí céanna). Cinntíonn an scéim ródaithe réamhshocraithe mura sonraítear bunachar sonraí, go dtagann gach ceist ar ais chuig an mbunachar sonraí \`réamhshocraithe\`. Ní gá duit aon rud a dhéanamh chun an scéim ródaithe réamhshocraithe a ghníomhachtú - cuirtear ar fáil í 'amach as an mbosca' ar gach tionscadal Django. Mar sin féin, más mian leat iompraíochtaí leithdháileadh bunachar sonraí níos spéisiúla a chur i bhfeidhm, is féidir leat do ródairí bunachar sonraí féin a shainiú agus ### Ródaithe bunachar sonraí Is rang é Ródaire bunachar sonraí a sholáthraíonn suas le ceithre mhodh: #### `db_for_read(model, **hints)` Moltar an bunachar sonraí ba chóir a úsáid le haghaidh oibríochtaí léitheoireachta le haghaidh rudaí de chineál samhail\`. Má tá oibríocht bunachar sonraí in ann aon fhaisnéis bhreise a sholáthar a d'fhéadfadh cabhrú le bunachar sonraí a roghnú, cuirfear ar fáil sa bhfoclóir leideanna . \Cuirtear sonraí ar leideanna bailí ar fáil: ref: thíos . Tugann sé ar ais `None` mura bhfuil aon mholadh ann. #### `db_for_write(model, **hints)` Moltar an bunachar sonraí ba chóir a úsáid le haghaidh scríobh rudaí de chineál Samhail. Má tá oibríocht bunachar sonraí in ann aon fhaisnéis bhreise a sholáthar a d'fhéadfadh cabhrú le bunachar sonraí a roghnú, cuirfear ar fáil sa bhfoclóir leideanna . \Cuirtear sonraí ar leideanna bailí ar fáil: ref: thíos . Tugann sé ar ais `None` mura bhfuil aon mholadh ann. #### `allow_relation(obj1, obj2, **hints)` Tabhair ar ais `True` má chóir gaol idir `obj1` agus obj2\` a cheadú, `Fal` má chóir an gaol a chosc, nó `None` mura bhfuil aon tuairim ag an ródaire. Is oibríocht bailíochtaithe amháin é seo, a úsáidtear ag eochair eachtrach agus go leor oibríochtaí chun a chinneadh an cheart caidreamh a cheadú idir dhá réad. Mura bhfuil tuairim ag aon ródaire (ie filleann gach ródaire None ), ní cheadaítear ach caidreamh laistigh den bhunachar sonraí céanna. #### `allow_migrate(db, app_label, model_name=None, **hints)` Faigh amach an gceadaítear don oibríocht imirce a reáchtáil ar an mbunachar sonraí le alias `db`. Fill ar ais `True` más chóir go rithfeadh an oibríocht, `False` mura chóir dó rith, nó `None` mura bhfuil aon tuairim ag an ródaire. Is é an argóint seasaimh app\_label\` lipéad an fheidhmchláir atá á imirce. Socraítear `model_name` ag an gcuid is mó d'oibríochtaí imirce go luach `samhail. _meta.model_name` (an leagan íseal den tsamhail `__name__`) den tsamhail atá á imirce. Is é a luach `None` d'oibríochtaí: ~django.db.migrations.operations.runpython agus:class: ~django.db.migrations.operations.runsql mura soláthraíonn siad é ag baint úsáide as leideanna. Úsáideann oibríochtaí áirithe leideanna chun faisnéis bhreise a chur in iúl don ródaire. Nuair a shocraítear `model_name`, is gnách go mbíonn `hints` an rang samhail faoin eochair `` `samhail ``. Tabhair faoi deara go bhféadfadh sé a: ref: samhail stairiúil \, agus dá bhrí sin nach bhfuil aon tréithe, modhanna nó bainisteoirí saincheaptha aige. Níor chóir duit brath ach ar `_meta`. Is féidir an modh seo a úsáid freisin chun infhaighteacht samhail ar bhunachar sonraí ar leith a chinneadh. [`makemigrations`](/ga/6.1/ref/django-admin/#django-admin-makemigrations) always creates migrations for model changes, but if `allow_migrate()` returns `False`, any migration operations for the `model_name` will be silently skipped when running [`migrate`](/ga/6.1/ref/django-admin/#django-admin-migrate) on the `db`. Changing the behavior of `allow_migrate()` for models that already have migrations may result in broken foreign keys, extra tables, or missing tables. When [`makemigrations`](/ga/6.1/ref/django-admin/#django-admin-makemigrations) verifies the migration history, it skips databases where no app is allowed to migrate. Ní gá do ródaire na modhanna seo uach\* a sholáthar - féadfaidh sé ceann amháin nó níos mó acu a fhágáil. Má fhágtar ceann de na modhanna, scipeánfaidh Django an ródaire sin agus an seiceáil ábhartha á ndéanamh agat. #### Leideanna Is féidir na leideanna a fhaigheann an ródaire bunachar sonraí a úsáid chun cinneadh a dhéanamh cén bunachar sonraí ba chóir iarratas ar leith a fháil. At present, the only hint that will be provided is `instance`, an object instance that is related to the read or write operation that is underway. This might be the instance that is being saved, or it might be an instance that is being added in a many-to-many relation. In some cases, no instance hint will be provided at all. The router checks for the existence of an instance hint, and determines if that hint should be used to alter routing behavior. If an `instance` hint is present, the database from which it was fetched is recorded on its [`instance._state.db`](/ga/6.1/ref/models/instances/#django.db.models.Model._state). Routers will need to first consult that attribute before falling back to any fixed alias to match Django's default behavior of fetching related instances from the same database. ### Úsáid ródairí Suiteáiltear ródairí bunachar sonraí ag baint úsáide as an socrú: setting: DATABASE\_ROUTERS. Sainmhíníonn an socrú seo liosta d'ainmneacha ranga, gach ceann acu ag sonrú ródaire ar chóir an bunródaire a úsáid (`django.db.router`). Úsáideann oibríochtaí bunachar sonraí Django an ródaire bunachar sonraí chun úsáid bunachar sonraí a leithdháileadh. Aon uair a chaithfidh fiosrúchán a fháil amach cén bunachar sonraí atá le húsáid, glaonn sé ar an ródaire bonn, ag soláthar samhail agus leid (má tá sé ar fáil). Déanann an bunródaire iarracht gach rang ródaire ina dhiaidh sin go dtí go bhfilleann duine moladh bunachar sonraí. Mura dtugann aon ródairí moladh ar ais, déanann an ródaire bonn iarracht an reatha: attr: instance. \_state.db \\`den chás leideanna. Mura soláthraíodh aon sampla leideanna, nó:attr: \`instance. Is é \_state.db \\`\`\`None \`, leithdháileoidh an bunródaire an bunachar sonraí `réamhshocraithe`. ### Sampla > **Cuspóirí samplacha amháin!** > > Tá an sampla seo beartaithe mar léiriú ar an gcaoi is féidir bonneagar an ródaire a úsáid chun úsáid bunachar sonraí a athrú. Déanann sé neamhaird de ghnó roinnt saincheisteanna casta d'fhonn a léiriú conas a úsáidtear ródair > > Ní oibreoidh an sampla seo má tá caidreamh le samhlacha lasmuigh den bhunachar sonraí ``` `eile ``ag aon cheann de na samhlacha i `myapp ```. :ref: Tugann caidrimh tras-bhunachar sonraí \\`fadhbanna sláine tagartha isteach nach féidir le Django a láimhseáil faoi láthair. > > Tá an chumraíocht bunús/macasamhail (dá ngairtear máistir/sclábhaí ag roinnt bunachair sonraí) a thuairiscítear lochtach freisin - ní sholáthraíonn sé aon réiteach chun moill macasamhail a láimhseáil (ie, neamhréireachtaí fiosrúcháin a tugadh isteach mar gheall ar an am a thógtar le scríobh chun iomadú chuig na macasamhail). Ní mheasann sé freisin idirghníomhaíocht idirbhearta leis an straitéis úsáide bunachar sonraí. Mar sin - cad a chiallaíonn sé seo i gcleachtas? Déanaimis smaoineamh ar chumraíocht samplach eile. Beidh roinnt bunachar sonraí ag an gceann seo: ceann don fheidhmchlár auth\`, agus gach aip eile ag baint úsáide as socrú bunscoil/macasamhail le dhá mhacasamhail léite. Seo na socruithe a shonraíonn na bunachair sonraí seo: ``` DATABASES = { "default": {}, "auth_db": { "NAME": "auth_db_name", "ENGINE": "django.db.backends.mysql", "USER": "mysql_user", "PASSWORD": "swordfish", }, "primary": { "NAME": "primary_name", "ENGINE": "django.db.backends.mysql", "USER": "mysql_user", "PASSWORD": "spam", }, "replica1": { "NAME": "replica1_name", "ENGINE": "django.db.backends.mysql", "USER": "mysql_user", "PASSWORD": "eggs", }, "replica2": { "NAME": "replica2_name", "ENGINE": "django.db.backends.mysql", "USER": "mysql_user", "PASSWORD": "bacon", }, } ``` Anois beidh orainn ródú a láimhseáil. Ar dtús ba mhaith linn ródaire a bhfuil a fhios aige ceisteanna a sheoladh do na feidhmchláir auth\` agus contenttypes\` chuig auth\_db\` (tá samhlacha auth\` nasctha le contentType\`, mar sin caithfear iad a stóráil sa bhunachar sonraí céanna): ``` class AuthRouter: """ A router to control all database operations on models in the auth and contenttypes applications. """ route_app_labels = {"auth", "contenttypes"} def db_for_read(self, model, **hints): """ Attempts to read auth and contenttypes models go to auth_db. """ if model._meta.app_label in self.route_app_labels: return "auth_db" return None def db_for_write(self, model, **hints): """ Attempts to write auth and contenttypes models go to auth_db. """ if model._meta.app_label in self.route_app_labels: return "auth_db" return None def allow_relation(self, obj1, obj2, **hints): """ Allow relations if a model in the auth or contenttypes apps is involved. """ if ( obj1._meta.app_label in self.route_app_labels or obj2._meta.app_label in self.route_app_labels ): return True return None def allow_migrate(self, db, app_label, model_name=None, **hints): """ Make sure the auth and contenttypes apps only appear in the 'auth_db' database. """ if app_label in self.route_app_labels: return db == "auth_db" return None ``` Agus theastaíonn ródaire uainn freisin a sheolann gach aip eile chuig an gcumraíocht bunscoil/macasamhail, agus a roghnaíonn macasamhail go randamach le léamh as: ``` import random class PrimaryReplicaRouter: def db_for_read(self, model, **hints): """ Reads go to a randomly-chosen replica. """ return random.choice(["replica1", "replica2"]) def db_for_write(self, model, **hints): """ Writes always go to primary. """ return "primary" def allow_relation(self, obj1, obj2, **hints): """ Relations between objects are allowed if both objects are in the primary/replica pool. """ db_set = {"primary", "replica1", "replica2"} if obj1._state.db in db_set and obj2._state.db in db_set: return True return None def allow_migrate(self, db, app_label, model_name=None, **hints): """ All non-auth models end up in this pool. """ return True ``` Faoi dheireadh, sa chomhad socruithe, cuirimid an méid seo a leanas leis (ag cur path.to.\` in ionad an cosán Python iarbhír chuig an modúl (í) ina bhfuil na ródairí sainmhínithe): ``` DATABASE_ROUTERS = ["path.to.AuthRouter", "path.to.PrimaryReplicaRouter"] ``` Tá an t-ord ina ndéantar ródairí a phróiseáil suntasach. Cuirfear ceist ar ródairí san ord atá siad liostaithe sa socrú: SETTING: DATABASE\_ROUTERS. Sa sampla seo, déantar an Authrough \`\`a phróiseáil roimh an \`\`PrimaryRepliCarouter\`, agus mar thoradh air sin, déantar cinntí a bhaineann leis na samhlacha in auth a phróiseáil sula ndéantar aon chinneadh eile. Má liostaíodh an socrú:setting: DATABASE\_ROUTERS an dá ródaire san ord eile, bheadh primaryReplicaRouter.ALLOW\_MIGRATE () a phróiseáil ar dtús. Ciallaíonn nádúr uile an chur i bhfeidhm PrimaryReplicaOuter go mbeadh na samhlacha go léir ar fáil ar gach bunachar sonraí. With this setup installed, and all databases migrated as per [Sioncrónú do bhunachar sonraí](#synchronizing-multiple-databases), let's run some Django code: ```pycon >>> # This retrieval will be performed on the 'auth_db' database >>> fred = User.objects.get(username="fred") >>> fred.first_name = "Frederick" >>> # This save will also be directed to 'auth_db' >>> fred.save() >>> # These retrieval will be randomly allocated to a replica database >>> dna = Person.objects.get(name="Douglas Adams") >>> # A new object has no database allocation when created >>> mh = Book(title="Mostly Harmless") >>> # This assignment will consult the router, and set mh onto >>> # the same database as the author object >>> mh.author = dna >>> # This save will force the 'mh' instance onto the primary database... >>> mh.save() >>> # ... but if we re-retrieve the object, it will come back on a replica >>> mh = Book.objects.get(title="Mostly Harmless") ``` Sainmhínigh an sampla seo ródaire chun idirghníomhaíocht a láimhseáil le samhlacha ón aip auth, agus ródairí eile chun idirghníomhú le gach aip eile a láimhseáil. Má d'fhág tú do bhunachar sonraí `default` folamh agus mura dteastaíonn uait ródaire bunachar sonraí catch-all a shainiú chun gach aip nach sonraítear ar mhalairt a láimhseáil, ní mór do ródairí ainmneacha gach aip a láimhseáil in:setting: INSTALLED\_APPS sula ndéanann tú imirce. Féach:ref: contrib\_app\_multiple\_databases le haghaidh faisnéise faoi apps contrib nach mór a bheith le chéile i mbunachar sonraí amháin. ## Bunachar sonraí a roghnú de láimh Soláthraíonn Django API freisin a ligeann duit smacht iomlán a choinneáil ar úsáid bunachar sonraí i do chód. Glacfaidh leithdháileadh bunachar sonraí sonraithe de láimh tosaíocht ar bhunachar sonraí a leithdháiltear ### Bunachar sonraí a roghnú de láimh le haghaidh `QuerySet` Is féidir leat an bunachar sonraí do QuerySet\` a roghnú ag pointe ar bith sa slabhra `QuerySet`. Glaoigh ar ```using () ``ar an `QuerySet``` chun `QuerySet` eile a fháil a úsáideann an bunachar sonraí sonraithe. Tógann using () argóint amháin: ainm an bhunachar sonraí ar mhaith leat an cheist a reáchtáil. Mar shampla: ```pycon >>> # This will run on the 'default' database. >>> Author.objects.all() >>> # So will this. >>> Author.objects.using("default") >>> # This will run on the 'other' database. >>> Author.objects.using("other") ``` ### Bunachar sonraí a roghnú le haghaidh save () \`\` Úsáid an eochairfhocal `using` le Model.save () chun a shonrú ar cén bunachar sonraí ba chóir na sonraí a shábháil. Mar shampla, chun réad a shábháil chuig an mbunachar sonraí legacy\_users, d'úsáideann tú seo: ```pycon >>> my_object.save(using="legacy_users") ``` Mura sonraíonn tú ```úsáid ``, sábhálfaidh an modh ``save ()``` isteach sa bhunachar sonraí réamhshocraithe arna leithdháileadh ag na ródairí. #### Ag bogadh réad ó bhunachar sonraí amháin go ceann eile Má shábháil tú sampla chuig bunachar sonraí amháin, b'fhéidir go mbeadh sé mealltach save (using =...) a úsáid mar bhealach chun an sampla a aistriú chuig bunachar sonraí nua. Mar sin féin, mura nglacann tú céimeanna iomchuí, d'fhéadfadh roinnt iarmhairtí gan choinne a bheith aige seo. Smaoinigh ar an sampla seo a leanas: ```pycon >>> p = Person(name="Fred") >>> p.save(using="first") # (statement 1) >>> p.save(using="second") # (statement 2) ``` I ráiteas 1, sábhálfar réad nua `` `Person `` chuig an mbunachar sonraí `chéad`. Ag an am seo, níl eochair phríomhúil ag p\`, mar sin eisíonn Django ráiteas `INSERT` SQL. Cruthaíonn sé seo eochair phríomhúil, agus sannann Django an príomh-eochair sin do p\`. Nuair a tharlaíonn an sábháil i ráiteas 2, tá príomhluach ag p\` cheana féin, agus déanfaidh Django iarracht an eochair phríomhúil sin a úsáid ar an mbunachar sonraí nua. Mura bhfuil an príomhluach in úsáid sa bhunachar sonraí dara , ansin ní bheidh aon fhadhbanna agat - cóipeálfar an réad chuig an mbunachar sonraí nua. Mar sin féin, má tá príomh-eochair p\` in úsáid cheana féin ar an mbunachar sonraí ```dara ``, cuirfear an réad atá ann cheana sa bhunachar sonraí ``soicin` nuair a shábháiltear `p```. Is féidir leat é seo a sheachaint ar dhá bhealach. Ar dtús, is féidir leat eochair phríomhúil an cháis a ghlanadh. Mura bhfuil aon phríomh-eochair ag réad, déileálfaidh Django leis mar réad nua, ag seachaint aon chaillteanas sonraí ar an mbunachar sonraí dara : ```pycon >>> p = Person(name="Fred") >>> p.save(using="first") >>> p.pk = None # Clear the primary key. >>> p.save(using="second") # Write a completely new object. ``` Is é an dara rogha ná an rogha `force_insert` a úsáid chun ```save () ``chun a chinntiú go ndéanann Django SQL ``INSERT```: ```pycon >>> p = Person(name="Fred") >>> p.save(using="first") >>> p.save(using="second", force_insert=True) ``` Cinnteoidh sé seo go mbeidh an príomh-eochair chéanna ag an duine darb ainm Fred\` ar an dá bhunachar sonraí. Má tá an príomh-eochair sin in úsáid cheana féin nuair a dhéanann tú iarracht sábháil ar an mbunachar sonraí dara , ardófar earráid. ### Bunachar sonraí a roghnú le scriosadh as De réir réamhshocraithe, cuirfear glao chun réad atá ann cheana a scriosadh ar an mbunachar sonraí céanna a úsáideadh chun an réad a aisghabháil sa chéad áit: ```pycon >>> u = User.objects.using("legacy_users").get(username="fred") >>> u.delete() # will delete from the `legacy_users` database ``` Chun an bunachar sonraí as a scriosfar samhail a shonrú, cuir argóint eochairfhocal ```úsáid ``chuig an modh ``Model.delete ()```. Oibríonn an argóint seo díreach cosúil leis an argóint eochairfhocal ``` `úsáid ``chun `save () ```. Mar shampla, má tá tú ag aistriú úsáideora ón mbunachar sonraí legacy\_users chuig an mbunachar sonraí new\_users\`, d'fhéadfá na horduithe seo a úsáid: ```pycon >>> user_obj.save(using="new_users") >>> user_obj.delete(using="legacy_users") ``` ### Bainisteoirí a úsáid le bunachair sonraí il Úsáid an modh db\_manager () ar bhainisteoirí chun rochtain a thabhairt do bhainisteoirí ar bhunachar sonraí neamh-réamhshocraithe. Mar shampla, abair go bhfuil modh bainisteora saincheaptha agat a théann i dteagmháil leis an mbunachar sonraí - ```User.Objects.create_user () ``. Toisc gur modh bainisteora é `create_user () ``, ní modh ``QuerySet```, ní féidir leat `User.Objects.using ('new_users') .create_user ()` a dhéanamh. (Níl an modh create\_user () \`ar fáil ach ar \`\`User.Objects\`, an bainisteoir, ní ar rudaí QuerySet\` a dhíorthaítear ón mbainisteoir.) Is é an réiteach ná db\_manager () a úsáid, mar seo: ``` User.objects.db_manager("new_users").create_user(...) ``` Filleann db\_manager () cóip den bhainisteoir atá ceangailte leis an mbunachar sonraí a shonraíonn tú. #### Ag baint úsáide as get\_queryset () le bunachair sonraí iolracha Má tá tú ag cur ```get_queryset () ``ar do bhainisteoir, déan cinnte glaoch ar an modh ar an tuismitheoir (ag baint úsáide as ``super ()```) nó déan láimhseáil chuí an tréith `_db` ar an mbainisteoir (sreang ina bhfuil ainm an bhunachar sonraí le húsáid). Mar shampla, más mian leat rang saincheaptha `QuerySet` a thabhairt ar ais ón modh `get_queryset`, d'fhéadfá seo a dhéanamh: ``` class MyManager(models.Manager): def get_queryset(self): qs = CustomQuerySet(self.model) if self._db is not None: qs = qs.using(self._db) return qs ``` ## Bunachair sonraí iolracha a nochtadh i gcomhéadan riaracháin D Níl aon tacaíocht shoiléir ag riarachán Django do iliomad bunachair sonraí. Más mian leat comhéadan riaracháin a sholáthar do mhúnla ar bhunachar sonraí seachas an ceann a shonraíonn do slabhra ródaire, beidh ort ranganna saincheap:class: ~django.contrib.admin.modelAdmin a scríobh a threoróidh an riarachán bunachar sonraí sonrach a úsáid le haghaidh ábhar. Tá na modhanna seo a leanas ag rudaí ModelAdmin a éilíonn saincheaptha le haghaidh tacaíochta ilbhunachar sonraí: ``` class MultiDBModelAdmin(admin.ModelAdmin): # A handy constant for the name of the alternate database. using = "other" def save_model(self, request, obj, form, change): # Tell Django to save objects to the 'other' database. obj.save(using=self.using) def delete_model(self, request, obj): # Tell Django to delete objects from the 'other' database obj.delete(using=self.using) def get_queryset(self, request): # Tell Django to look for objects on the 'other' database. return super().get_queryset(request).using(self.using) def formfield_for_foreignkey(self, db_field, request, **kwargs): # Tell Django to populate ForeignKey widgets using a query # on the 'other' database. return super().formfield_for_foreignkey( db_field, request, using=self.using, **kwargs ) def formfield_for_manytomany(self, db_field, request, **kwargs): # Tell Django to populate ManyToMany widgets using a query # on the 'other' database. return super().formfield_for_manytomany( db_field, request, using=self.using, **kwargs ) ``` Cuireann an cur i bhfeidhm a chuirtear ar fáil anseo straitéis ilbhunachar sonraí i bhfeidhm ina ndéantar gach rud de chineál ar leith a stóráil ar bhunachar sonraí ar leith (m.sh., tá gach rud ```Úsáideora ``sa bhunachar sonraí ``eile```). Má tá do úsáid a bhaineann le bunachair sonraí iolracha níos casta, beidh ar do ModelAdmin\` an straitéis sin a léiriú. [`InlineModelAdmin`](/ga/6.1/ref/contrib/admin/#django.contrib.admin.InlineModelAdmin) objects can be handled in a similar fashion. They require three customized methods: ``` class MultiDBTabularInline(admin.TabularInline): using = "other" def get_queryset(self, request): # Tell Django to look for inline objects on the 'other' database. return super().get_queryset(request).using(self.using) def formfield_for_foreignkey(self, db_field, request, **kwargs): # Tell Django to populate ForeignKey widgets using a query # on the 'other' database. return super().formfield_for_foreignkey( db_field, request, using=self.using, **kwargs ) def formfield_for_manytomany(self, db_field, request, **kwargs): # Tell Django to populate ManyToMany widgets using a query # on the 'other' database. return super().formfield_for_manytomany( db_field, request, using=self.using, **kwargs ) ``` Nuair a bheidh do shainmhínithe riaracháin samhail scríofa agat, is féidir iad a chlárú le haon shampla `Riarachán`: ``` from django.contrib import admin from myapp.models import Author, Book, Publisher # Import our custom ModelAdmin and TabularInline from where they're defined. from myproject.admin import MultiDBModelAdmin, MultiDBTabularInline # Specialize the multi-db admin objects for use with specific models. class BookInline(MultiDBTabularInline): model = Book class PublisherAdmin(MultiDBModelAdmin): inlines = [BookInline] admin.site.register(Author, MultiDBModelAdmin) admin.site.register(Publisher, PublisherAdmin) othersite = admin.AdminSite("othersite") othersite.register(Publisher, MultiDBModelAdmin) ``` Bunaíonn an sampla seo dhá shuíomh riaracháin. Ar an gcéad láithreán, nochtar na rudaí `Údar` agus Foilsitheoir\`; tá inlíne táblaí ag rudaí Foilsitheora a thaispeánann leabhair arna fhoilsiú ag an bhfoilsitheoir sin. Nochtann an dara suíomh ach foilsitheoirí, gan na línte. ## Cúrsaí amh a úsáid le bunachair sonraí iolracha Má tá níos mó ná bunachar sonraí amháin á úsáid agat is féidir leat `django.db.connections` a úsáid chun an nasc (agus an cúrsóir) a fháil le haghaidh bunachar sonraí ar leith. Is réad cosúil le foclóir é `django.db.connections` a ligeann duit nasc ar leith a aisghabháil ag baint úsáide as a ainm: ``` from django.db import connections with connections["my_db_alias"].cursor() as cursor: ... ``` ## Teorainneacha ar bhunachar sonraí ### Caidreamh trasbhunachar sonraí Faoi láthair ní sholáthraíonn Django aon tacaíocht d'eochair eachtracha nó caidrimh go leor a chuimsíonn bunachair sonraí iolracha. Má d'úsáid tú ródaire chun samhlacha a dheighilt chuig bunachair sonraí éagsúla, caithfidh aon eochair eachtrach agus caidrimh go leor a shainmhíníonn na samhlacha sin a bheith inmheánach le bunachar sonraí amháin. Tá sé seo mar gheall ar shláine tagartha. D'fhonn caidreamh idir dhá réad a choinneáil, ní mór go mbeadh a fhios ag Django go bhfuil príomh-eochair an réada gaolmhara bailí. Má stóráiltear an príomh-eochair ar bhunachar sonraí ar leithligh, ní féidir bailíocht eochair phríomhúil a mheas go héasca. Má tá Postgres, SQLite, Oracle, nó MySQL á úsáid agat le InnoDB, cuirtear é seo i bhfeidhm ag leibhéal sláine an bhunachar sonraí - cosc ar phríomhshrianta ar leibhéal bunachar sonraí caidrimh nach féidir a bhailíochtú a chruthú. Mar sin féin, má tá MySQL á úsáid agat le táblaí MyISAM, níl aon sláine tagartha forfheidhmithe ann; mar thoradh air sin, b'fhéidir go mbeidh tú in ann eochracha eachtracha trasbhunachar sonraí 'bréige' a dhéanamh. Mar sin féin, ní thacaíonn Django leis an gcumraíocht seo go hoifigiúil. ### Iompar aipeanna contrib Cuimsíonn roinnt aipeanna contrib samhlacha, agus braitheann roinnt aipeanna ar dhaoine eile. Ós rud é go bhfuil caidrimh tras-bhunachar sonraí dodhéanta, cruthaíonn sé seo roinnt srianta ar an gcaoi ar féidir leat na samhlacha seo - is féidir gach ceann de ContentTypes.ContentType\`, Sessions.Session\` agus `Sites.Site` a stóráil in aon bhunachar sonraí, mar gheall ar ródaire oiriúnach. - Tá samhlacha `auth` \- `Úsáideor`, Grúpa\` agus `Cead` \- nasctha le chéile agus nasctha le `ContentType`, mar sin ní mór iad a stóráil sa bhunachar sonraí céanna le ContentType\`. - Braitheann ```admin ``ar `auth```, mar sin caithfidh a mhúnlaí a bheith sa bhunachar sonraí céanna le `auth`. - Braitheann `flatpages` agus ```atreoruithe ``ar `suíomhanna```, mar sin caithfidh a gcuid samhlacha a bheith sa bhunachar sonraí céanna le suíomhanna . Ina theannta sin, cruthaítear roinnt rudaí go huathoibríoch díreach tar éis: cruthaíonn migrate tábla chun iad a choinneáil i mbunachar sonraí: - réamhshocraithe Suíomh , - “cineál ábhair” do gach samhail (lena n-áirítear iad siúd nach stóráiltear sa bhunachar sonraí sin), - na Ceadúna\` do gach samhail (lena n-áirítear iad siúd nach stóráiltear sa bhunachar sonraí sin). Maidir le socruithe coitianta le bunachair sonraí iolracha, níl sé úsáideach na rudaí seo a bheith i níos mó ná bunachar sonraí amháin. I measc na socruithe coitianta tá bunúsche/macasamhail agus nascadh le bunachair sonraí Dá bhrí sin, moltar a scríobh a:ref: ródaire bunachar sonraí \\`a cheadaíonn na trí mhúnla seo a shioncrónú le bunachar sonraí amháin. Úsáid an cur chuige céanna le haghaidh aipeanna contrib agus tríú páirtí nach dteastaíonn a dtáblaí uathu i iliomad bunachar > **Warning** > > Má tá cineálacha ábhair á shioncronú agat le níos mó ná bunachar sonraí amháin, bí ar an eolas go bhféadfadh nach n-oireann a bpríomh-eochracha trasna bunachair sonraí D'fhéadfadh éilliú sonraí nó caillteanas sonraí mar thoradh air seo.